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         let userfilter = '';
  32         let filter_errors = 0;
  33
  34         let updateProxyParams = function() {
  35             let params = {
  36                 errors: filter_errors,
  37             };
  38             if (userfilter) {
  39                 params.userfilter = userfilter;
  40             }
  41             if (me.vmidFilter) {
  42                 params.vmid = me.vmidFilter;
  43             }
  44             store.proxy.extraParams = params;
  45         };
  46
  47         updateProxyParams();
  48
  49         let reload_task = Ext.create('Ext.util.DelayedTask', function() {
  50             updateProxyParams();
  51             store.reload();
  52         });
  53
  54         let run_task_viewer = function() {
  55             let sm = me.getSelectionModel();
  56             let rec = sm.getSelection()[0];
  57             if (!rec) {
  58                 return;
  59             }
  60
  61             let win = Ext.create('Proxmox.window.TaskViewer', {
  62                 upid: rec.data.upid,
  63             });
  64             win.show();
  65         };
  66
  67         let view_btn = new Ext.Button({
  68             text: gettext('View'),
  69             disabled: true,
  70             handler: run_task_viewer,
  71         });
  72
  73         Proxmox.Utils.monStoreErrors(me, store, true);
  74
  75         Ext.apply(me, {
  76             store: store,
  77             viewConfig: {
  78                 trackOver: false,
  79                 stripeRows: false, // does not work with getRowClass()
  80
  81                 getRowClass: function(record, index) {
  82                     let status = record.get('status');
  83
  84                     if (status) {
  85                         let parsed = Proxmox.Utils.parse_task_status(status);
  86                         if (parsed === 'error') {
  87                             return "proxmox-invalid-row";
  88                         } else if (parsed === 'warning') {
  89                             return "proxmox-warning-row";
  90                         }
  91                     }
  92                     return '';
  93                 },
  94             },
  95             tbar: [
  96                 view_btn,
  97                 {
  98                     text: gettext('Refresh'), // FIXME: smart-auto-refresh store
  99                     handler: () => store.reload(),
 100                 },
 101                 '->',
 102                 gettext('User name') +':',
 103                 ' ',
 104                 {
 105                     xtype: 'textfield',
 106                     width: 200,
 107                     value: userfilter,
 108                     enableKeyEvents: true,
 109                     listeners: {
 110                         keyup: function(field, e) {
 111                             userfilter = field.getValue();
 112                             reload_task.delay(500);
 113                         },
 114                     },
 115                 }, ' ', gettext('Only Errors') + ':', ' ',
 116                 {
 117                     xtype: 'checkbox',
 118                     hideLabel: true,
 119                     checked: filter_errors,
 120                     listeners: {
 121                         change: function(field, checked) {
 122                             filter_errors = checked ? 1 : 0;
 123                             reload_task.delay(10);
 124                         },
 125                     },
 126                 }, ' ',
 127             ],
 128             columns: [
 129                 {
 130                     header: gettext("Start Time"),
 131                     dataIndex: 'starttime',
 132                     width: 130,
 133                     renderer: function(value) {
 134                         return Ext.Date.format(value, "M d H:i:s");
 135                     },
 136                 },
 137                 {
 138                     header: gettext("End Time"),
 139                     dataIndex: 'endtime',
 140                     width: 130,
 141                     renderer: function(value, metaData, record) {
 142                         if (!value) {
 143                             metaData.tdCls = "x-grid-row-loading";
 144                             return '';
 145                         }
 146                         return Ext.Date.format(value, "M d H:i:s");
 147                     },
 148                 },
 149                 {
 150                     header: gettext("Node"),
 151                     dataIndex: 'node',
 152                     width: 120,
 153                 },
 154                 {
 155                     header: gettext("User name"),
 156                     dataIndex: 'user',
 157                     width: 150,
 158                 },
 159                 {
 160                     header: gettext("Description"),
 161                     dataIndex: 'upid',
 162                     flex: 1,
 163                     renderer: Proxmox.Utils.render_upid,
 164                 },
 165                 {
 166                     header: gettext("Status"),
 167                     dataIndex: 'status',
 168                     width: 200,
 169                     renderer: function(value, metaData, record) {
 170                         if (value === undefined && !record.data.endtime) {
 171                             metaData.tdCls = "x-grid-row-loading";
 172                             return '';
 173                         }
 174
 175                         let parsed = Proxmox.Utils.parse_task_status(value);
 176                         switch (parsed) {
 177                             case 'unknown': return Proxmox.Utils.unknownText;
 178                             case 'error': return Proxmox.Utils.errorText + ': ' + value;
 179                             case 'ok': // fall-through
 180                             case 'warning': // fall-through
 181                             default: return value;
 182                         }
 183                     },
 184                 },
 185             ],
 186             listeners: {
 187                 itemdblclick: run_task_viewer,
 188                 selectionchange: function(v, selections) {
 189                     view_btn.setDisabled(!(selections && selections[0]));
 190                 },
 191                 show: function() { reload_task.delay(10); },
 192                 destroy: function() { reload_task.cancel(); },
 193             },
 194         });
 195
 196         me.callParent();
 197     },
 198 });