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             confirmMsg: gettext('Remove entry?'),
 203             callback: 'reload',
 204         },
 205         '-',
 206         {
 207             xtype: 'proxmoxButton',
 208             text: gettext('Show Log'),
 209             handler: 'openTaskLog',
 210             enableFn: (rec) => !!rec.data['last-run-upid'],
 211             disabled: true,
 212         },
 213         {
 214             xtype: 'proxmoxButton',
 215             text: gettext('Run now'),
 216             handler: 'runSyncJob',
 217             disabled: true,
 218         },
 219     ],
 220
 221     viewConfig: {
 222         trackOver: false,
 223     },
 224
 225     columns: [
 226         {
 227             header: gettext('Job ID'),
 228             dataIndex: 'id',
 229             renderer: Ext.String.htmlEncode,
 230             maxWidth: 220,
 231             minWidth: 75,
 232             flex: 1,
 233             sortable: true,
 234         },
 235         {
 236             header: gettext('Remote'),
 237             dataIndex: 'remote',
 238             width: 120,
 239             sortable: true,
 240         },
 241         {
 242             header: gettext('Remote Store'),
 243             dataIndex: 'remote-store',
 244             width: 120,
 245             sortable: true,
 246         },
 247         {
 248             header: gettext('Local Store'),
 249             dataIndex: 'store',
 250             width: 120,
 251             sortable: true,
 252         },
 253         {
 254             header: gettext('Schedule'),
 255             dataIndex: 'schedule',
 256             maxWidth: 220,
 257             minWidth: 80,
 258             flex: 1,
 259             sortable: true,
 260         },
 261         {
 262             header: gettext('Last Sync'),
 263             dataIndex: 'last-run-endtime',
 264             renderer: 'render_optional_timestamp',
 265             width: 150,
 266             sortable: true,
 267         },
 268         {
 269             text: gettext('Duration'),
 270             dataIndex: 'duration',
 271             renderer: Proxmox.Utils.render_duration,
 272             width: 80,
 273         },
 274         {
 275             header: gettext('Status'),
 276             dataIndex: 'last-run-state',
 277             renderer: 'render_sync_status',
 278             flex: 3,
 279         },
 280         {
 281             header: gettext('Next Run'),
 282             dataIndex: 'next-run',
 283             renderer: 'render_next_run',
 284             width: 150,
 285             sortable: true,
 286         },
 287         {
 288             header: gettext('Comment'),
 289             dataIndex: 'comment',
 290             renderer: Ext.String.htmlEncode,
 291             flex: 2,
 292             sortable: true,
 293         },
 294     ],
 295 });