src/node/Tasks.js

   1 Ext.define('Proxmox.node.Tasks', {
   2     extend: 'Ext.grid.GridPanel',
   3
   4     alias: ['widget.proxmoxNodeTasks'],
   5     stateful: true,
   6     stateId: 'grid-node-tasks',
   7     loadMask: true,
   8     sortableColumns: false,
   9     vmidFilter: 0,
  10
  11     initComponent: function() {
  12         let me = this;
  13
  14         if (!me.nodename) {
  15             throw "no node name specified";
  16         }
  17
  18         let store = Ext.create('Ext.data.BufferedStore', {
  19             pageSize: 500,
  20             autoLoad: true,
  21             remoteFilter: true,
  22             model: 'proxmox-tasks',
  23             proxy: {
  24                 type: 'proxmox',
  25                 startParam: 'start',
  26                 limitParam: 'limit',
  27                 url: "/api2/json/nodes/" + me.nodename + "/tasks",
  28             },
  29         });
  30
  31         store.on('prefetch', function() {
  32             // we want to update the scrollbar on every store load
  33             // since the total count might be different
  34             // the buffered grid plugin does this only on scrolling itself
  35             // and even reduces the scrollheight again when scrolling up
  36             me.updateLayout();
  37         });
  38
  39         let userfilter = '';
  40         let filter_errors = 0;
  41
  42         let updateProxyParams = function() {
  43             let params = {
  44                 errors: filter_errors,
  45             };
  46             if (userfilter) {
  47                 params.userfilter = userfilter;
  48             }
  49             if (me.vmidFilter) {
  50                 params.vmid = me.vmidFilter;
  51             }
  52             store.proxy.extraParams = params;
  53         };
  54
  55         updateProxyParams();
  56
  57         let reload_task = Ext.create('Ext.util.DelayedTask', function() {
  58             updateProxyParams();
  59             store.reload();
  60         });
  61
  62         let run_task_viewer = function() {
  63             let sm = me.getSelectionModel();
  64             let rec = sm.getSelection()[0];
  65             if (!rec) {
  66                 return;
  67             }
  68
  69             let win = Ext.create('Proxmox.window.TaskViewer', {
  70                 upid: rec.data.upid,
  71                 endtime: rec.data.endtime,
  72             });
  73             win.show();
  74         };
  75
  76         let view_btn = new Ext.Button({
  77             text: gettext('View'),
  78             disabled: true,
  79             handler: run_task_viewer,
  80         });
  81
  82         Proxmox.Utils.monStoreErrors(me, store, true);
  83
  84         Ext.apply(me, {
  85             store: store,
  86             viewConfig: {
  87                 trackOver: false,
  88                 stripeRows: false, // does not work with getRowClass()
  89
  90                 getRowClass: function(record, index) {
  91                     let status = record.get('status');
  92
  93                     if (status) {
  94                         let parsed = Proxmox.Utils.parse_task_status(status);
  95                         if (parsed === 'error') {
  96                             return "proxmox-invalid-row";
  97                         } else if (parsed === 'warning') {
  98                             return "proxmox-warning-row";
  99                         }
 100                     }
 101                     return '';
 102                 },
 103             },
 104             tbar: [
 105                 view_btn,
 106                 {
 107                     text: gettext('Refresh'), // FIXME: smart-auto-refresh store
 108                     handler: () => store.reload(),
 109                 },
 110                 '->',
 111                 gettext('User name') +':',
 112                 ' ',
 113                 {
 114                     xtype: 'textfield',
 115                     width: 200,
 116                     value: userfilter,
 117                     enableKeyEvents: true,
 118                     listeners: {
 119                         keyup: function(field, e) {
 120                             userfilter = field.getValue();
 121                             reload_task.delay(500);
 122                         },
 123                     },
 124                 }, ' ', gettext('Only Errors') + ':', ' ',
 125                 {
 126                     xtype: 'checkbox',
 127                     hideLabel: true,
 128                     checked: filter_errors,
 129                     listeners: {
 130                         change: function(field, checked) {
 131                             filter_errors = checked ? 1 : 0;
 132                             reload_task.delay(10);
 133                         },
 134                     },
 135                 }, ' ',
 136             ],
 137             columns: [
 138                 {
 139                     header: gettext("Start Time"),
 140                     dataIndex: 'starttime',
 141                     width: 130,
 142                     renderer: function(value) {
 143                         return Ext.Date.format(value, "M d H:i:s");
 144                     },
 145                 },
 146                 {
 147                     header: gettext("End Time"),
 148                     dataIndex: 'endtime',
 149                     width: 130,
 150                     renderer: function(value, metaData, record) {
 151                         if (!value) {
 152                             metaData.tdCls = "x-grid-row-loading";
 153                             return '';
 154                         }
 155                         return Ext.Date.format(value, "M d H:i:s");
 156                     },
 157                 },
 158                 {
 159                     header: gettext("Duration"),
 160                     hidden: true,
 161                     width: 80,
 162                     renderer: function(value, metaData, record) {
 163                         let start = record.data.starttime;
 164                         if (start) {
 165                             let end = record.data.endtime || Date.now();
 166                             let duration = end - start;
 167                             if (duration > 0) {
 168                                 duration /= 1000;
 169                             }
 170                             return Proxmox.Utils.format_duration_human(duration);
 171                         }
 172                         return Proxmox.Utils.unknownText;
 173                     },
 174                 },
 175                 {
 176                     header: gettext("Node"),
 177                     dataIndex: 'node',
 178                     width: 120,
 179                 },
 180                 {
 181                     header: gettext("User name"),
 182                     dataIndex: 'user',
 183                     width: 150,
 184                 },
 185                 {
 186                     header: gettext("Description"),
 187                     dataIndex: 'upid',
 188                     flex: 1,
 189                     renderer: Proxmox.Utils.render_upid,
 190                 },
 191                 {
 192                     header: gettext("Status"),
 193                     dataIndex: 'status',
 194                     width: 200,
 195                     renderer: function(value, metaData, record) {
 196                         if (value === undefined && !record.data.endtime) {
 197                             metaData.tdCls = "x-grid-row-loading";
 198                             return '';
 199                         }
 200
 201                         return Proxmox.Utils.format_task_status(value);
 202                     },
 203                 },
 204             ],
 205             listeners: {
 206                 itemdblclick: run_task_viewer,
 207                 selectionchange: function(v, selections) {
 208                     view_btn.setDisabled(!(selections && selections[0]));
 209                 },
 210                 show: function() { reload_task.delay(10); },
 211                 destroy: function() { reload_task.cancel(); },
 212             },
 213         });
 214
 215         me.callParent();
 216     },
 217 });