www/config/VerifyView.js

   1 Ext.define('pbs-verify-jobs-status', {
   2     extend: 'Ext.data.Model',
   3     fields: [
   4         'id', 'store', 'outdated-after', 'ignore-verified', '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/verify',
  21     },
  22 });
  23
  24 Ext.define('PBS.config.VerifyJobView', {
  25     extend: 'Ext.grid.GridPanel',
  26     alias: 'widget.pbsVerifyJobView',
  27
  28     stateful: true,
  29     stateId: 'grid-verify-jobs-v1',
  30
  31     title: gettext('Verify Jobs'),
  32
  33     controller: {
  34         xclass: 'Ext.app.ViewController',
  35
  36         addVerifyJob: function() {
  37             let me = this;
  38             let view = me.getView();
  39             Ext.create('PBS.window.VerifyJobEdit', {
  40                 datastore: view.datastore,
  41                 listeners: {
  42                     destroy: function() {
  43                         me.reload();
  44                     },
  45                 },
  46             }).show();
  47         },
  48
  49         editVerifyJob: 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.VerifyJobEdit', {
  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         runVerifyJob: 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/verify/${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_verify_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             let params = {};
 161             if (view.datastore !== undefined) {
 162                 params.store = view.datastore;
 163             }
 164             view.getStore().rstore.getProxy().setExtraParams(params);
 165             Proxmox.Utils.monStoreErrors(view, view.getStore().rstore);
 166         },
 167     },
 168
 169     listeners: {
 170         activate: 'startStore',
 171         deactivate: 'stopStore',
 172         itemdblclick: 'editVerifyJob',
 173     },
 174
 175     store: {
 176         type: 'diff',
 177         autoDestroy: true,
 178         autoDestroyRstore: true,
 179         sorters: 'id',
 180         rstore: {
 181             type: 'update',
 182             storeid: 'pbs-verify-jobs-status',
 183             model: 'pbs-verify-jobs-status',
 184             interval: 5000,
 185         },
 186     },
 187
 188     tbar: [
 189         {
 190             xtype: 'proxmoxButton',
 191             text: gettext('Add'),
 192             handler: 'addVerifyJob',
 193             selModel: false,
 194         },
 195         {
 196             xtype: 'proxmoxButton',
 197             text: gettext('Edit'),
 198             handler: 'editVerifyJob',
 199             disabled: true,
 200         },
 201         {
 202             xtype: 'proxmoxStdRemoveButton',
 203             baseurl: '/config/verify/',
 204             confirmMsg: gettext('Remove entry?'),
 205             callback: 'reload',
 206         },
 207         '-',
 208         {
 209             xtype: 'proxmoxButton',
 210             text: gettext('Show Log'),
 211             handler: 'openTaskLog',
 212             enableFn: (rec) => !!rec.data['last-run-upid'],
 213             disabled: true,
 214         },
 215         {
 216             xtype: 'proxmoxButton',
 217             text: gettext('Run now'),
 218             handler: 'runVerifyJob',
 219             disabled: true,
 220         },
 221     ],
 222
 223     viewConfig: {
 224         trackOver: false,
 225     },
 226
 227     columns: [
 228         {
 229             header: gettext('Job ID'),
 230             dataIndex: 'id',
 231             renderer: Ext.String.htmlEncode,
 232             maxWidth: 220,
 233             minWidth: 75,
 234             flex: 1,
 235             sortable: true,
 236         },
 237         {
 238             header: gettext('Datastore'),
 239             dataIndex: 'store',
 240             flex: 1,
 241         },
 242         {
 243             header: gettext('Skip Verified'),
 244             dataIndex: 'ignore-verified',
 245             renderer: Proxmox.Utils.format_boolean,
 246             width: 100,
 247             sortable: true,
 248         },
 249         {
 250             header: gettext('Re-Verify After'),
 251             dataIndex: 'outdated-after',
 252             renderer: v => v ? v +' '+ gettext('Days') : gettext('Never'),
 253             width: 125,
 254             sortable: true,
 255         },
 256         {
 257             header: gettext('Schedule'),
 258             dataIndex: 'schedule',
 259             sortable: true,
 260             maxWidth: 220,
 261             minWidth: 80,
 262             flex: 1,
 263         },
 264         {
 265             header: gettext('Last Verification'),
 266             dataIndex: 'last-run-endtime',
 267             renderer: 'render_optional_timestamp',
 268             width: 150,
 269             sortable: true,
 270         },
 271         {
 272             text: gettext('Duration'),
 273             dataIndex: 'duration',
 274             renderer: Proxmox.Utils.render_duration,
 275             width: 80,
 276         },
 277         {
 278             header: gettext('Status'),
 279             dataIndex: 'last-run-state',
 280             renderer: 'render_verify_status',
 281             flex: 3,
 282         },
 283         {
 284             header: gettext('Next Run'),
 285             dataIndex: 'next-run',
 286             renderer: 'render_next_run',
 287             width: 150,
 288             sortable: true,
 289         },
 290         {
 291             header: gettext('Comment'),
 292             dataIndex: 'comment',
 293             renderer: Ext.String.htmlEncode,
 294             flex: 2,
 295             sortable: true,
 296         },
 297     ],
 298
 299     initComponent: function() {
 300         let me = this;
 301         let hideDatastore = !!me.datastore;
 302
 303         for (let column of me.columns) {
 304             if (column.dataIndex === 'store') {
 305                 column.hidden = hideDatastore;
 306                 break;
 307             }
 308         }
 309
 310         me.callParent();
 311     },
 312 });