www/manager6/dc/Backup.js

   1 Ext.define('PVE.dc.BackupEdit', {
   2     extend: 'Proxmox.window.Edit',
   3     alias: ['widget.pveDcBackupEdit'],
   4
   5     defaultFocus: undefined,
   6
   7     initComponent : function() {
   8          var me = this;
   9
  10         me.isCreate = !me.jobid;
  11
  12         var url;
  13         var method;
  14
  15         if (me.isCreate) {
  16             url = '/api2/extjs/cluster/backup';
  17             method = 'POST';
  18         } else {
  19             url = '/api2/extjs/cluster/backup/' + me.jobid;
  20             method = 'PUT';
  21         }
  22
  23         var vmidField = Ext.create('Ext.form.field.Hidden', {
  24             name: 'vmid'
  25         });
  26
  27         /*jslint confusion: true*/
  28         // 'value' can be assigned a string or an array
  29         var selModeField =  Ext.create('Proxmox.form.KVComboBox', {
  30             xtype: 'proxmoxKVComboBox',
  31             comboItems: [
  32                 ['include', gettext('Include selected VMs')],
  33                 ['all', gettext('All')],
  34                 ['exclude', gettext('Exclude selected VMs')],
  35                 ['pool', gettext('Pool based')]
  36             ],
  37             fieldLabel: gettext('Selection mode'),
  38             name: 'selMode',
  39             value: ''
  40         });
  41
  42         var sm = Ext.create('Ext.selection.CheckboxModel', {
  43             mode: 'SIMPLE',
  44             listeners: {
  45                 selectionchange: function(model, selected) {
  46                     var sel = [];
  47                     Ext.Array.each(selected, function(record) {
  48                         sel.push(record.data.vmid);
  49                     });
  50
  51                     // to avoid endless recursion suspend the vmidField change
  52                     // event temporary as it calls us again
  53                     vmidField.suspendEvent('change');
  54                     vmidField.setValue(sel);
  55                     vmidField.resumeEvent('change');
  56                 }
  57             }
  58         });
  59
  60         var storagesel = Ext.create('PVE.form.StorageSelector', {
  61             fieldLabel: gettext('Storage'),
  62             nodename: 'localhost',
  63             storageContent: 'backup',
  64             allowBlank: false,
  65             name: 'storage'
  66         });
  67
  68         var store = new Ext.data.Store({
  69             model: 'PVEResources',
  70             sorters: {
  71                 property: 'vmid',
  72                 order: 'ASC'
  73             }
  74         });
  75
  76         var vmgrid = Ext.createWidget('grid', {
  77             store: store,
  78             border: true,
  79             height: 300,
  80             selModel: sm,
  81             disabled: true,
  82             columns: [
  83                 {
  84                     header: 'ID',
  85                     dataIndex: 'vmid',
  86                     width: 60
  87                 },
  88                 {
  89                     header: gettext('Node'),
  90                     dataIndex: 'node'
  91                 },
  92                 {
  93                     header: gettext('Status'),
  94                     dataIndex: 'uptime',
  95                     renderer: function(value) {
  96                         if (value) {
  97                             return Proxmox.Utils.runningText;
  98                         } else {
  99                             return Proxmox.Utils.stoppedText;
 100                         }
 101                     }
 102                 },
 103                 {
 104                     header: gettext('Name'),
 105                     dataIndex: 'name',
 106                     flex: 1
 107                 },
 108                 {
 109                     header: gettext('Type'),
 110                     dataIndex: 'type'
 111                 }
 112             ]
 113         });
 114
 115         var selectPoolMembers = function(poolid) {
 116             if (!poolid) {
 117                 return;
 118             }
 119             sm.deselectAll(true);
 120             store.filter([
 121                 {
 122                     id: 'poolFilter',
 123                     property: 'pool',
 124                     value: poolid
 125                 }
 126             ]);
 127             sm.selectAll(true);
 128         };
 129
 130         var selPool = Ext.create('PVE.form.PoolSelector', {
 131             fieldLabel: gettext('Pool to backup'),
 132             hidden: true,
 133             allowBlank: true,
 134             name: 'pool',
 135             listeners: {
 136                 change: function( selpool, newValue, oldValue) {
 137                     selectPoolMembers(newValue);
 138                 }
 139             }
 140         });
 141
 142         var nodesel = Ext.create('PVE.form.NodeSelector', {
 143             name: 'node',
 144             fieldLabel: gettext('Node'),
 145             allowBlank: true,
 146             editable: true,
 147             autoSelect: false,
 148             emptyText: '-- ' + gettext('All') + ' --',
 149             listeners: {
 150                 change: function(f, value) {
 151                     storagesel.setNodename(value || 'localhost');
 152                     var mode = selModeField.getValue();
 153                     store.clearFilter();
 154                     store.filterBy(function(rec) {
 155                         return (!value || rec.get('node') === value);
 156                     });
 157                     if (mode === 'all') {
 158                         sm.selectAll(true);
 159                     }
 160
 161                     if (mode === 'pool') {
 162                         selectPoolMembers(selPool.value);
 163                     }
 164                 }
 165             }
 166         });
 167
 168         var column1 = [
 169             nodesel,
 170             storagesel,
 171             {
 172                 xtype: 'pveDayOfWeekSelector',
 173                 name: 'dow',
 174                 fieldLabel: gettext('Day of week'),
 175                 multiSelect: true,
 176                 value: ['sat'],
 177                 allowBlank: false
 178             },
 179             {
 180                 xtype: 'timefield',
 181                 fieldLabel: gettext('Start Time'),
 182                 name: 'starttime',
 183                 format: 'H:i',
 184                 formatText: 'HH:MM',
 185                 value: '00:00',
 186                 allowBlank: false
 187             },
 188             selModeField,
 189             selPool
 190         ];
 191
 192         var column2 = [
 193             {
 194                 xtype: 'textfield',
 195                 fieldLabel: gettext('Send email to'),
 196                 name: 'mailto'
 197             },
 198             {
 199                 xtype: 'pveEmailNotificationSelector',
 200                 fieldLabel: gettext('Email notification'),
 201                 name: 'mailnotification',
 202                 deleteEmpty: me.isCreate ? false : true,
 203                 value: me.isCreate ? 'always' : ''
 204             },
 205             {
 206                 xtype: 'pveCompressionSelector',
 207                 fieldLabel: gettext('Compression'),
 208                 name: 'compress',
 209                 deleteEmpty: me.isCreate ? false : true,
 210                 value: 'lzo'
 211             },
 212             {
 213                 xtype: 'pveBackupModeSelector',
 214                 fieldLabel: gettext('Mode'),
 215                 value: 'snapshot',
 216                 name: 'mode'
 217             },
 218             {
 219                 xtype: 'proxmoxcheckbox',
 220                 fieldLabel: gettext('Enable'),
 221                 name: 'enabled',
 222                 uncheckedValue: 0,
 223                 defaultValue: 1,
 224                 checked: true
 225             },
 226             vmidField
 227         ];
 228         /*jslint confusion: false*/
 229
 230         var ipanel = Ext.create('Proxmox.panel.InputPanel', {
 231             onlineHelp: 'chapter_vzdump',
 232             column1: column1,
 233             column2:  column2,
 234             onGetValues: function(values) {
 235                 if (!values.node) {
 236                     if (!me.isCreate) {
 237                         Proxmox.Utils.assemble_field_data(values, { 'delete': 'node' });
 238                     }
 239                     delete values.node;
 240                 }
 241
 242                 var selMode = values.selMode;
 243                 delete values.selMode;
 244
 245                 if (selMode === 'all') {
 246                     values.all = 1;
 247                     values.exclude = '';
 248                     delete values.vmid;
 249                 } else if (selMode === 'exclude') {
 250                     values.all = 1;
 251                     values.exclude = values.vmid;
 252                     delete values.vmid;
 253                 } else if (selMode === 'pool') {
 254                     delete values.vmid;
 255                 }
 256
 257                 if (selMode !== 'pool') {
 258                     delete values.pool;
 259                 }
 260                 return values;
 261             }
 262         });
 263
 264         var update_vmid_selection = function(list, mode) {
 265             if (mode !== 'all' && mode !== 'pool') {
 266                 sm.deselectAll(true);
 267                 if (list) {
 268                     Ext.Array.each(list.split(','), function(vmid) {
 269                         var rec = store.findRecord('vmid', vmid);
 270                         if (rec) {
 271                             sm.select(rec, true);
 272                         }
 273                     });
 274                 }
 275             }
 276         };
 277
 278         vmidField.on('change', function(f, value) {
 279             var mode = selModeField.getValue();
 280             update_vmid_selection(value, mode);
 281         });
 282
 283         selModeField.on('change', function(f, value, oldValue) {
 284             if (oldValue === 'pool') {
 285                 store.removeFilter('poolFilter');
 286             }
 287
 288             if (oldValue === 'all') {
 289                 sm.deselectAll(true);
 290                 vmidField.setValue('');
 291             }
 292
 293             if (value === 'all') {
 294                 sm.selectAll(true);
 295                 vmgrid.setDisabled(true);
 296             } else {
 297                 vmgrid.setDisabled(false);
 298             }
 299
 300             if (value === 'pool') {
 301                 vmgrid.setDisabled(true);
 302                 vmidField.setValue('');
 303                 selPool.setVisible(true);
 304                 selPool.allowBlank = false;
 305                 selectPoolMembers(selPool.value);
 306
 307             } else {
 308                 selPool.setVisible(false);
 309                 selPool.allowBlank = true;
 310             }
 311             var list = vmidField.getValue();
 312             update_vmid_selection(list, value);
 313         });
 314
 315         var reload = function() {
 316             store.load({
 317                 params: { type: 'vm' },
 318                 callback: function() {
 319                     var node = nodesel.getValue();
 320                     store.clearFilter();
 321                     store.filterBy(function(rec) {
 322                         return (!node || node.length === 0 || rec.get('node') === node);
 323                     });
 324                     var list = vmidField.getValue();
 325                     var mode = selModeField.getValue();
 326                     if (mode === 'all') {
 327                         sm.selectAll(true);
 328                     } else if (mode === 'pool'){
 329                         selectPoolMembers(selPool.value);
 330                     } else {
 331                         update_vmid_selection(list, mode);
 332                     }
 333                 }
 334             });
 335         };
 336
 337         Ext.applyIf(me, {
 338             subject: gettext("Backup Job"),
 339             url: url,
 340             method: method,
 341             items: [ ipanel, vmgrid ]
 342         });
 343
 344         me.callParent();
 345
 346         if (me.isCreate) {
 347             selModeField.setValue('include');
 348         } else {
 349             me.load({
 350                 success: function(response, options) {
 351                     var data = response.result.data;
 352
 353                     data.dow = data.dow.split(',');
 354
 355                     if (data.all || data.exclude) {
 356                         if (data.exclude) {
 357                             data.vmid = data.exclude;
 358                             data.selMode = 'exclude';
 359                         } else {
 360                             data.vmid = '';
 361                             data.selMode = 'all';
 362                         }
 363                     } else if (data.pool) {
 364                         data.selMode = 'pool';
 365                         data.selPool = data.pool;
 366                     } else {
 367                         data.selMode = 'include';
 368                     }
 369
 370                     me.setValues(data);
 371                }
 372             });
 373         }
 374
 375         reload();
 376     }
 377 });
 378
 379
 380 Ext.define('PVE.dc.BackupView', {
 381     extend: 'Ext.grid.GridPanel',
 382
 383     alias: ['widget.pveDcBackupView'],
 384
 385     onlineHelp: 'chapter_vzdump',
 386
 387     allText: '-- ' + gettext('All') + ' --',
 388     allExceptText: gettext('All except {0}'),
 389
 390     initComponent : function() {
 391         var me = this;
 392
 393         var store = new Ext.data.Store({
 394             model: 'pve-cluster-backup',
 395             proxy: {
 396                 type: 'proxmox',
 397                 url: "/api2/json/cluster/backup"
 398             }
 399         });
 400
 401         var reload = function() {
 402             store.load();
 403         };
 404
 405         var sm = Ext.create('Ext.selection.RowModel', {});
 406
 407         var run_editor = function() {
 408             var rec = sm.getSelection()[0];
 409             if (!rec) {
 410                 return;
 411             }
 412
 413             var win = Ext.create('PVE.dc.BackupEdit', {
 414                 jobid: rec.data.id
 415             });
 416             win.on('destroy', reload);
 417             win.show();
 418         };
 419
 420         var run_backup_now = function(job) {
 421             job = Ext.clone(job);
 422
 423             let jobNode = job.node;
 424             // Remove properties related to scheduling
 425             delete job.enabled;
 426             delete job.starttime;
 427             delete job.dow;
 428             delete job.id;
 429             delete job.node;
 430             job.all = job.all === true ? 1 : 0;
 431
 432             let allNodes = PVE.data.ResourceStore.getNodes();
 433             let nodes = allNodes.filter(node => node.status === 'online').map(node => node.node);
 434             let errors = [];
 435
 436             if (jobNode !== undefined) {
 437                 if (!nodes.includes(jobNode)) {
 438                     Ext.Msg.alert('Error', "Node '"+ jobNode +"' from backup job isn't online!");
 439                     return;
 440                 }
 441                 nodes = [ jobNode ];
 442             } else {
 443                 let unkownNodes = allNodes.filter(node => node.status !== 'online');
 444                 if (unkownNodes.length > 0)
 445                     errors.push(unkownNodes.map(node => node.node + ": " + gettext("Node is offline")));
 446             }
 447             let jobTotalCount = nodes.length, jobsStarted = 0;
 448
 449             Ext.Msg.show({
 450                 title: gettext('Please wait...'),
 451                 closable: false,
 452                 progress: true,
 453                 progressText: '0/' + jobTotalCount,
 454             });
 455
 456             let postRequest = function () {
 457                 jobsStarted++;
 458                 Ext.Msg.updateProgress(jobsStarted / jobTotalCount, jobsStarted + '/' + jobTotalCount);
 459
 460                 if (jobsStarted == jobTotalCount) {
 461                     Ext.Msg.hide();
 462                     if (errors.length > 0) {
 463                         Ext.Msg.alert('Error', 'Some errors have been encountered:<br />' + errors.join('<br />'));
 464                     }
 465                 }
 466             };
 467
 468             nodes.forEach(node => Proxmox.Utils.API2Request({
 469                 url: '/nodes/' + node + '/vzdump',
 470                 method: 'POST',
 471                 params: job,
 472                 failure: function (response, opts) {
 473                     errors.push(node + ': ' + response.htmlStatus);
 474                     postRequest();
 475                 },
 476                 success: postRequest
 477             }));
 478         };
 479
 480         var edit_btn = new Proxmox.button.Button({
 481             text: gettext('Edit'),
 482             disabled: true,
 483             selModel: sm,
 484             handler: run_editor
 485         });
 486
 487         var run_btn = new Proxmox.button.Button({
 488             text: gettext('Run now'),
 489             disabled: true,
 490             selModel: sm,
 491             handler: function() {
 492                 var rec = sm.getSelection()[0];
 493                 if (!rec) {
 494                     return;
 495                 }
 496
 497                 Ext.Msg.show({
 498                     title: gettext('Confirm'),
 499                     icon: Ext.Msg.QUESTION,
 500                     msg: gettext('Start the selected backup job now?'),
 501                     buttons: Ext.Msg.YESNO,
 502                     callback: function(btn) {
 503                         if (btn !== 'yes') {
 504                             return;
 505                         }
 506                         run_backup_now(rec.data);
 507                     }
 508                 });
 509             }
 510         });
 511
 512         var remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
 513             selModel: sm,
 514             baseurl: '/cluster/backup',
 515             callback: function() {
 516                 reload();
 517             }
 518         });
 519
 520         Proxmox.Utils.monStoreErrors(me, store);
 521
 522         Ext.apply(me, {
 523             store: store,
 524             selModel: sm,
 525             stateful: true,
 526             stateId: 'grid-dc-backup',
 527             viewConfig: {
 528                 trackOver: false
 529             },
 530             tbar: [
 531                 {
 532                     text: gettext('Add'),
 533                     handler: function() {
 534                         var win = Ext.create('PVE.dc.BackupEdit',{});
 535                         win.on('destroy', reload);
 536                         win.show();
 537                     }
 538                 },
 539                 '-',
 540                 remove_btn,
 541                 edit_btn,
 542                 '-',
 543                 run_btn
 544             ],
 545             columns: [
 546                 {
 547                     header: gettext('Enabled'),
 548                     width: 80,
 549                     dataIndex: 'enabled',
 550                     xtype: 'checkcolumn',
 551                     sortable: true,
 552                     disabled: true,
 553                     disabledCls: 'x-item-enabled',
 554                     stopSelection: false
 555                 },
 556                 {
 557                     header: gettext('Node'),
 558                     width: 100,
 559                     sortable: true,
 560                     dataIndex: 'node',
 561                     renderer: function(value) {
 562                         if (value) {
 563                             return value;
 564                         }
 565                         return me.allText;
 566                     }
 567                 },
 568                 {
 569                     header: gettext('Day of week'),
 570                     width: 200,
 571                     sortable: false,
 572                     dataIndex: 'dow',
 573                     renderer: function(val) {
 574                         var dows = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
 575                         var selected = [];
 576                         var cur = -1;
 577                         val.split(',').forEach(function(day){
 578                             cur++;
 579                             var dow = (dows.indexOf(day)+6)%7;
 580                             if (cur === dow) {
 581                                 if (selected.length === 0 || selected[selected.length-1] === 0) {
 582                                     selected.push(1);
 583                                 } else {
 584                                     selected[selected.length-1]++;
 585                                 }
 586                             } else {
 587                                 while (cur < dow) {
 588                                     cur++;
 589                                     selected.push(0);
 590                                 }
 591                                 selected.push(1);
 592                             }
 593                         });
 594
 595                         cur = -1;
 596                         var days = [];
 597                         selected.forEach(function(item) {
 598                             cur++;
 599                             if (item > 2) {
 600                                 days.push(Ext.Date.dayNames[(cur+1)] + '-' + Ext.Date.dayNames[(cur+item)%7]);
 601                                 cur += item-1;
 602                             } else if (item == 2) {
 603                                 days.push(Ext.Date.dayNames[cur+1]);
 604                                 days.push(Ext.Date.dayNames[(cur+2)%7]);
 605                                 cur++;
 606                             } else if (item == 1) {
 607                                 days.push(Ext.Date.dayNames[(cur+1)%7]);
 608                             }
 609                         });
 610                         return days.join(', ');
 611                     }
 612                 },
 613                 {
 614                     header: gettext('Start Time'),
 615                     width: 60,
 616                     sortable: true,
 617                     dataIndex: 'starttime'
 618                 },
 619                 {
 620                     header: gettext('Storage'),
 621                     width: 100,
 622                     sortable: true,
 623                     dataIndex: 'storage'
 624                 },
 625                 {
 626                     header: gettext('Selection'),
 627                     flex: 1,
 628                     sortable: false,
 629                     dataIndex: 'vmid',
 630                     renderer: function(value, metaData, record) {
 631                         /*jslint confusion: true */
 632                         if (record.data.all) {
 633                             if (record.data.exclude) {
 634                                 return Ext.String.format(me.allExceptText, record.data.exclude);
 635                             }
 636                             return me.allText;
 637                         }
 638                         if (record.data.vmid) {
 639                             return record.data.vmid;
 640                         }
 641
 642                         if (record.data.pool) {
 643                             return "Pool '"+ record.data.pool + "'";
 644                         }
 645
 646                         return "-";
 647                     }
 648                 }
 649             ],
 650             listeners: {
 651                 activate: reload,
 652                 itemdblclick: run_editor
 653             }
 654         });
 655
 656         me.callParent();
 657     }
 658 }, function() {
 659
 660     Ext.define('pve-cluster-backup', {
 661         extend: 'Ext.data.Model',
 662         fields: [
 663             'id', 'starttime', 'dow',
 664             'storage', 'node', 'vmid', 'exclude',
 665             'mailto', 'pool', 'compress', 'mode',
 666             { name: 'enabled', type: 'boolean' },
 667             { name: 'all', type: 'boolean' }
 668         ]
 669     });
 670 });