www/config/SyncView.js

   1 Ext.define('pbs-sync-jobs-status', {
   2     extend: 'Ext.data.Model',
   3     fields: [
   4         'id', 'remote', 'remote-store', 'store', 'schedule',
   5         'next-run', 'last-run-upid', 'last-run-state', 'last-run-endtime',
   6         {
   7             name: 'duration',
   8             calculate: function(data) {
   9                 let endtime = data['last-run-endtime'];
  10                 if (!endtime) return undefined;
  11                 let task = Proxmox.Utils.parse_task_upid(data['last-run-upid']);
  12                 return endtime - task.starttime;
  13             },
  14         },
  15         'comment',
  16     ],
  17     idProperty: 'id',
  18     proxy: {
  19         type: 'proxmox',
  20         url: '/api2/json/admin/sync',
  21     },
  22 });
  23
  24 Ext.define('PBS.config.SyncJobView', {
  25     extend: 'Ext.grid.GridPanel',
  26     alias: 'widget.pbsSyncJobView',
  27
  28     stateful: true,
  29     stateId: 'grid-sync-jobs',
  30
  31     title: gettext('Sync Jobs'),
  32
  33     controller: {
  34         xclass: 'Ext.app.ViewController',
  35
  36         addSyncJob: function() {
  37             let me = this;
  38             let view = me.getView();
  39             Ext.create('PBS.window.SyncJobEdit', {
  40                 datastore: view.datastore,
  41                 listeners: {
  42                     destroy: function() {
  43                         me.reload();
  44                     },
  45                 },
  46             }).show();
  47         },
  48
  49         editSyncJob: function() {
  50             let me = this;
  51             let view = me.getView();
  52             let selection = view.getSelection();
  53             if (selection.length < 1) return;
  54
  55             Ext.create('PBS.window.SyncJobEdit', {
  56                 datastore: view.datastore,
  57                 id: selection[0].data.id,
  58                 listeners: {
  59                     destroy: function() {
  60                         me.reload();
  61                     },
  62                 },
  63             }).show();
  64         },
  65
  66         openTaskLog: function() {
  67             let me = this;
  68             let view = me.getView();
  69             let selection = view.getSelection();
  70             if (selection.length < 1) return;
  71
  72             let upid = selection[0].data['last-run-upid'];
  73             if (!upid) return;
  74
  75             Ext.create('Proxmox.window.TaskViewer', {
  76                 upid,
  77             }).show();
  78         },
  79
  80         runSyncJob: function() {
  81             let me = this;
  82             let view = me.getView();
  83             let selection = view.getSelection();
  84             if (selection.length < 1) return;
  85
  86             let id = selection[0].data.id;
  87             Proxmox.Utils.API2Request({
  88                 method: 'POST',
  89                 url: `/admin/sync/${id}/run`,
  90                 success: function(response, opt) {
  91                     Ext.create('Proxmox.window.TaskViewer', {
  92                         upid: response.result.data,
  93                         taskDone: function(success) {
  94                             me.reload();
  95                         },
  96                     }).show();
  97                 },
  98                 failure: function(response, opt) {
  99                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 100                 },
 101             });
 102         },
 103
 104         render_sync_status: function(value, metadata, record) {
 105             if (!record.data['last-run-upid']) {
 106                 return '-';
 107             }
 108
 109             if (!record.data['last-run-endtime']) {
 110                 metadata.tdCls = 'x-grid-row-loading';
 111                 return '';
 112             }
 113
 114             let parsed = Proxmox.Utils.parse_task_status(value);
 115             let text = value;
 116             let icon = '';
 117             switch (parsed) {
 118                 case 'unknown':
 119                     icon = 'question faded';
 120                     text = Proxmox.Utils.unknownText;
 121                     break;
 122                 case 'error':
 123                     icon = 'times critical';
 124                     text = Proxmox.Utils.errorText + ': ' + value;
 125                     break;
 126                 case 'warning':
 127                     icon = 'exclamation warning';
 128                     break;
 129                 case 'ok':
 130                     icon = 'check good';
 131                     text = gettext("OK");
 132             }
 133
 134             return `<i class="fa fa-${icon}"></i> ${text}`;
 135         },
 136
 137         render_next_run: function(value, metadat, record) {
 138             if (!value) return '-';
 139
 140             let now = new Date();
 141             let next = new Date(value*1000);
 142
 143             if (next < now) {
 144                 return gettext('pending');
 145             }
 146             return Proxmox.Utils.render_timestamp(value);
 147         },
 148
 149         render_optional_timestamp: function(value, metadata, record) {
 150             if (!value) return '-';
 151             return Proxmox.Utils.render_timestamp(value);
 152         },
 153
 154         startStore: function() { this.getView().getStore().rstore.startUpdate(); },
 155         stopStore: function() { this.getView().getStore().rstore.stopUpdate(); },
 156
 157         reload: function() { this.getView().getStore().rstore.load(); },
 158
 159         init: function(view) {
 160             view.getStore().rstore.getProxy().setExtraParams({
 161                 store: view.datastore,
 162             });
 163             Proxmox.Utils.monStoreErrors(view, view.getStore().rstore);
 164         },
 165     },
 166
 167     listeners: {
 168         activate: 'startStore',
 169         deactivate: 'stopStore',
 170         itemdblclick: 'editSyncJob',
 171     },
 172
 173     store: {
 174         type: 'diff',
 175         autoDestroy: true,
 176         autoDestroyRstore: true,
 177         sorters: 'id',
 178         rstore: {
 179             type: 'update',
 180             storeid: 'pbs-sync-jobs-status',
 181             model: 'pbs-sync-jobs-status',
 182             interval: 5000,
 183         },
 184     },
 185
 186     tbar: [
 187         {
 188             xtype: 'proxmoxButton',
 189             text: gettext('Add'),
 190             handler: 'addSyncJob',
 191             selModel: false,
 192         },
 193         {
 194             xtype: 'proxmoxButton',
 195             text: gettext('Edit'),
 196             handler: 'editSyncJob',
 197             disabled: true,
 198         },
 199         {
 200             xtype: 'proxmoxStdRemoveButton',
 201             baseurl: '/config/sync/',
 202             callback: 'reload',
 203         },
 204         '-',
 205         {
 206             xtype: 'proxmoxButton',
 207             text: gettext('Log'),
 208             handler: 'openTaskLog',
 209             enableFn: (rec) => !!rec.data['last-run-upid'],
 210             disabled: true,
 211         },
 212         {
 213             xtype: 'proxmoxButton',
 214             text: gettext('Run now'),
 215             handler: 'runSyncJob',
 216             disabled: true,
 217         },
 218     ],
 219
 220     viewConfig: {
 221         trackOver: false,
 222     },
 223
 224     columns: [
 225         {
 226             header: gettext('Sync Job'),
 227             width: 100,
 228             sortable: true,
 229             renderer: Ext.String.htmlEncode,
 230             dataIndex: 'id',
 231         },
 232         {
 233             header: gettext('Remote'),
 234             width: 100,
 235             sortable: true,
 236             dataIndex: 'remote',
 237         },
 238         {
 239             header: gettext('Remote Store'),
 240             width: 100,
 241             sortable: true,
 242             dataIndex: 'remote-store',
 243         },
 244         {
 245             header: gettext('Local Store'),
 246             width: 100,
 247             sortable: true,
 248             dataIndex: 'store',
 249         },
 250         {
 251             header: gettext('Schedule'),
 252             sortable: true,
 253             dataIndex: 'schedule',
 254         },
 255         {
 256             header: gettext('Status'),
 257             dataIndex: 'last-run-state',
 258             flex: 1,
 259             renderer: 'render_sync_status',
 260         },
 261         {
 262             header: gettext('Last Sync'),
 263             sortable: true,
 264             minWidth: 200,
 265             renderer: 'render_optional_timestamp',
 266             dataIndex: 'last-run-endtime',
 267         },
 268         {
 269             text: gettext('Duration'),
 270             dataIndex: 'duration',
 271             width: 60,
 272             renderer: Proxmox.Utils.render_duration,
 273         },
 274         {
 275             header: gettext('Next Run'),
 276             sortable: true,
 277             minWidth: 200,
 278             renderer: 'render_next_run',
 279             dataIndex: 'next-run',
 280         },
 281         {
 282             header: gettext('Comment'),
 283             hidden: true,
 284             sortable: true,
 285             renderer: Ext.String.htmlEncode,
 286             dataIndex: 'comment',
 287         },
 288     ],
 289 });