src/window/TaskViewer.js

   1 Ext.define('Proxmox.window.TaskProgress', {
   2     extend: 'Ext.window.Window',
   3     alias: 'widget.proxmoxTaskProgress',
   4
   5     taskDone: Ext.emptyFn,
   6
   7     initComponent: function() {
   8         let me = this;
   9
  10         if (!me.upid) {
  11             throw "no task specified";
  12         }
  13
  14         let task = Proxmox.Utils.parse_task_upid(me.upid);
  15
  16         let statstore = Ext.create('Proxmox.data.ObjectStore', {
  17             url: "/api2/json/nodes/" + task.node + "/tasks/" + me.upid + "/status",
  18             interval: 1000,
  19             rows: {
  20                 status: { defaultValue: 'unknown' },
  21                 exitstatus: { defaultValue: 'unknown' },
  22             },
  23         });
  24
  25         me.on('destroy', statstore.stopUpdate);
  26
  27         let getObjectValue = function(key, defaultValue) {
  28             let rec = statstore.getById(key);
  29             if (rec) {
  30                 return rec.data.value;
  31             }
  32             return defaultValue;
  33         };
  34
  35         let pbar = Ext.create('Ext.ProgressBar', { text: 'running...' });
  36
  37         me.mon(statstore, 'load', function() {
  38             let status = getObjectValue('status');
  39             if (status === 'stopped') {
  40                 let exitstatus = getObjectValue('exitstatus');
  41                 if (exitstatus === 'OK') {
  42                     pbar.reset();
  43                     pbar.updateText("Done!");
  44                     Ext.Function.defer(me.close, 1000, me);
  45                 } else {
  46                     me.close();
  47                     Ext.Msg.alert('Task failed', exitstatus);
  48                 }
  49                 me.taskDone(exitstatus === 'OK');
  50             }
  51         });
  52
  53         let descr = Proxmox.Utils.format_task_description(task.type, task.id);
  54
  55         Ext.apply(me, {
  56             title: gettext('Task') + ': ' + descr,
  57             width: 300,
  58             layout: 'auto',
  59             modal: true,
  60             bodyPadding: 5,
  61             items: pbar,
  62             buttons: [
  63                 {
  64                     text: gettext('Details'),
  65                     handler: function() {
  66                         let win = Ext.create('Proxmox.window.TaskViewer', {
  67                             taskDone: me.taskDone,
  68                             upid: me.upid,
  69                         });
  70                         win.show();
  71                         me.close();
  72                     },
  73                 },
  74             ],
  75         });
  76
  77         me.callParent();
  78
  79         statstore.startUpdate();
  80
  81         pbar.wait();
  82     },
  83 });
  84
  85 // fixme: how can we avoid those lint errors?
  86
  87 Ext.define('Proxmox.window.TaskViewer', {
  88     extend: 'Ext.window.Window',
  89     alias: 'widget.proxmoxTaskViewer',
  90
  91     extraTitle: '', // string to prepend after the generic task title
  92
  93     taskDone: Ext.emptyFn,
  94
  95     initComponent: function() {
  96         let me = this;
  97
  98         if (!me.upid) {
  99             throw "no task specified";
 100         }
 101
 102         let task = Proxmox.Utils.parse_task_upid(me.upid);
 103
 104         let statgrid;
 105
 106         let rows = {
 107             status: {
 108                 header: gettext('Status'),
 109                 defaultValue: 'unknown',
 110                 renderer: function(value) {
 111                     if (value !== 'stopped') {
 112                         return value;
 113                     }
 114                     let es = statgrid.getObjectValue('exitstatus');
 115                     if (es) {
 116                         return value + ': ' + es;
 117                     }
 118                     return 'unknown';
 119                 },
 120             },
 121             exitstatus: {
 122                 visible: false,
 123             },
 124             type: {
 125                 header: gettext('Task type'),
 126                 required: true,
 127             },
 128             user: {
 129                 header: gettext('User name'),
 130                 renderer: function(value) {
 131                     let user = value;
 132                     let tokenid = statgrid.getObjectValue('tokenid');
 133                     if (tokenid) {
 134                         user += `!${tokenid} (API Token)`;
 135                     }
 136                     return Ext.String.htmlEncode(user);
 137                 },
 138                 required: true,
 139             },
 140             tokenid: {
 141                 header: gettext('API Token'),
 142                 renderer: Ext.String.htmlEncode,
 143                 visible: false,
 144             },
 145             node: {
 146                 header: gettext('Node'),
 147                 required: true,
 148             },
 149             pid: {
 150                 header: gettext('Process ID'),
 151                 required: true,
 152             },
 153             task_id: {
 154                 header: gettext('Task ID'),
 155             },
 156             starttime: {
 157                 header: gettext('Start Time'),
 158                 required: true,
 159                 renderer: Proxmox.Utils.render_timestamp,
 160             },
 161             upid: {
 162                 header: gettext('Unique task ID'),
 163                 renderer: Ext.String.htmlEncode,
 164             },
 165         };
 166
 167         if (me.endtime) {
 168             if (typeof me.endtime === 'object') {
 169                 // convert to epoch
 170                 me.endtime = parseInt(me.endtime.getTime()/1000, 10);
 171             }
 172             rows.endtime = {
 173                 header: gettext('End Time'),
 174                 required: true,
 175                 renderer: function() {
 176                     return Proxmox.Utils.render_timestamp(me.endtime);
 177                 },
 178             };
 179         }
 180
 181         rows.duration = {
 182             header: gettext('Duration'),
 183             required: true,
 184             renderer: function() {
 185                 let starttime = statgrid.getObjectValue('starttime');
 186                 let endtime = me.endtime || Date.now()/1000;
 187                 let duration = endtime - starttime;
 188                 return Proxmox.Utils.format_duration_human(duration);
 189             },
 190         };
 191
 192         let statstore = Ext.create('Proxmox.data.ObjectStore', {
 193             url: "/api2/json/nodes/" + task.node + "/tasks/" + me.upid + "/status",
 194             interval: 1000,
 195             rows: rows,
 196         });
 197
 198         me.on('destroy', statstore.stopUpdate);
 199
 200         let stop_task = function() {
 201             Proxmox.Utils.API2Request({
 202                 url: "/nodes/" + task.node + "/tasks/" + me.upid,
 203                 waitMsgTarget: me,
 204                 method: 'DELETE',
 205                 failure: function(response, opts) {
 206                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 207                 },
 208             });
 209         };
 210
 211         let stop_btn1 = new Ext.Button({
 212             text: gettext('Stop'),
 213             disabled: true,
 214             handler: stop_task,
 215         });
 216
 217         let stop_btn2 = new Ext.Button({
 218             text: gettext('Stop'),
 219             disabled: true,
 220             handler: stop_task,
 221         });
 222
 223         statgrid = Ext.create('Proxmox.grid.ObjectGrid', {
 224             title: gettext('Status'),
 225             layout: 'fit',
 226             tbar: [stop_btn1],
 227             rstore: statstore,
 228             rows: rows,
 229             border: false,
 230         });
 231
 232         let logView = Ext.create('Proxmox.panel.LogView', {
 233             title: gettext('Output'),
 234             tbar: [stop_btn2],
 235             border: false,
 236             url: "/api2/extjs/nodes/" + task.node + "/tasks/" + me.upid + "/log",
 237         });
 238
 239         me.mon(statstore, 'load', function() {
 240             let status = statgrid.getObjectValue('status');
 241
 242             if (status === 'stopped') {
 243                 logView.scrollToEnd = false;
 244                 logView.requestUpdate();
 245                 statstore.stopUpdate();
 246                 me.taskDone(statgrid.getObjectValue('exitstatus') === 'OK');
 247             }
 248
 249             stop_btn1.setDisabled(status !== 'running');
 250             stop_btn2.setDisabled(status !== 'running');
 251         });
 252
 253         statstore.startUpdate();
 254
 255         Ext.apply(me, {
 256             title: "Task viewer: " + task.desc + me.extraTitle,
 257             width: 800,
 258             height: 400,
 259             layout: 'fit',
 260             modal: true,
 261             items: [{
 262                 xtype: 'tabpanel',
 263                 region: 'center',
 264                 items: [logView, statgrid],
 265             }],
 266         });
 267
 268         me.callParent();
 269
 270         logView.fireEvent('show', logView);
 271     },
 272 });
 273