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("Node"),
 160                     dataIndex: 'node',
 161                     width: 120,
 162                 },
 163                 {
 164                     header: gettext("User name"),
 165                     dataIndex: 'user',
 166                     width: 150,
 167                 },
 168                 {
 169                     header: gettext("Description"),
 170                     dataIndex: 'upid',
 171                     flex: 1,
 172                     renderer: Proxmox.Utils.render_upid,
 173                 },
 174                 {
 175                     header: gettext("Status"),
 176                     dataIndex: 'status',
 177                     width: 200,
 178                     renderer: function(value, metaData, record) {
 179                         if (value === undefined && !record.data.endtime) {
 180                             metaData.tdCls = "x-grid-row-loading";
 181                             return '';
 182                         }
 183
 184                         let parsed = Proxmox.Utils.parse_task_status(value);
 185                         switch (parsed) {
 186                             case 'unknown': return Proxmox.Utils.unknownText;
 187                             case 'error': return Proxmox.Utils.errorText + ': ' + value;
 188                             case 'ok': // fall-through
 189                             case 'warning': // fall-through
 190                             default: return value;
 191                         }
 192                     },
 193                 },
 194             ],
 195             listeners: {
 196                 itemdblclick: run_task_viewer,
 197                 selectionchange: function(v, selections) {
 198                     view_btn.setDisabled(!(selections && selections[0]));
 199                 },
 200                 show: function() { reload_task.delay(10); },
 201                 destroy: function() { reload_task.cancel(); },
 202             },
 203         });
 204
 205         me.callParent();
 206     },
 207 });