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',
  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             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: 'editVerifyJob',
 171     },
 172
 173     store: {
 174         type: 'diff',
 175         autoDestroy: true,
 176         autoDestroyRstore: true,
 177         sorters: 'id',
 178         rstore: {
 179             type: 'update',
 180             storeid: 'pbs-verify-jobs-status',
 181             model: 'pbs-verify-jobs-status',
 182             interval: 5000,
 183         },
 184     },
 185
 186     tbar: [
 187         {
 188             xtype: 'proxmoxButton',
 189             text: gettext('Add'),
 190             handler: 'addVerifyJob',
 191             selModel: false,
 192         },
 193         {
 194             xtype: 'proxmoxButton',
 195             text: gettext('Edit'),
 196             handler: 'editVerifyJob',
 197             disabled: true,
 198         },
 199         {
 200             xtype: 'proxmoxStdRemoveButton',
 201             baseurl: '/config/verify/',
 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: 'runVerifyJob',
 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             flex: 2,
 231             sortable: true,
 232             hidden: true,
 233         },
 234         {
 235             header: gettext('Skip Verified'),
 236             dataIndex: 'ignore-verified',
 237             renderer: Proxmox.Utils.format_boolean,
 238             flex: 2,
 239             sortable: true,
 240         },
 241         {
 242             header: gettext('Re-Verfiy Age'),
 243             dataIndex: 'outdated-after',
 244             renderer: v => v ? v +' '+ gettext('Days') : gettext('Never'),
 245             flex: 2,
 246             sortable: true,
 247         },
 248         {
 249             header: gettext('Schedule'),
 250             dataIndex: 'schedule',
 251             sortable: true,
 252             flex: 2,
 253         },
 254         {
 255             header: gettext('Status'),
 256             dataIndex: 'last-run-state',
 257             renderer: 'render_verify_status',
 258             flex: 4,
 259         },
 260         {
 261             header: gettext('Last Verification'),
 262             dataIndex: 'last-run-endtime',
 263             renderer: 'render_optional_timestamp',
 264             flex: 3,
 265             sortable: true,
 266         },
 267         {
 268             text: gettext('Duration'),
 269             dataIndex: 'duration',
 270             renderer: Proxmox.Utils.render_duration,
 271             flex: 2,
 272         },
 273         {
 274             header: gettext('Next Run'),
 275             dataIndex: 'next-run',
 276             renderer: 'render_next_run',
 277             flex: 3,
 278             sortable: true,
 279         },
 280         {
 281             header: gettext('Comment'),
 282             dataIndex: 'comment',
 283             renderer: Ext.String.htmlEncode,
 284             flex: 4,
 285             sortable: true,
 286         },
 287     ],
 288 });