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         let me = this;
   9
  10         me.isCreate = !me.jobid;
  11
  12         let url, method;
  13         if (me.isCreate) {
  14             url = '/api2/extjs/cluster/backup';
  15             method = 'POST';
  16         } else {
  17             url = '/api2/extjs/cluster/backup/' + me.jobid;
  18             method = 'PUT';
  19         }
  20
  21         let vmidField = Ext.create('Ext.form.field.Hidden', {
  22             name: 'vmid',
  23         });
  24
  25         // 'value' can be assigned a string or an array
  26         let selModeField = Ext.create('Proxmox.form.KVComboBox', {
  27             xtype: 'proxmoxKVComboBox',
  28             comboItems: [
  29                 ['include', gettext('Include selected VMs')],
  30                 ['all', gettext('All')],
  31                 ['exclude', gettext('Exclude selected VMs')],
  32                 ['pool', gettext('Pool based')],
  33             ],
  34             fieldLabel: gettext('Selection mode'),
  35             name: 'selMode',
  36             value: '',
  37         });
  38
  39         let sm = Ext.create('Ext.selection.CheckboxModel', {
  40             mode: 'SIMPLE',
  41             listeners: {
  42                 selectionchange: function(model, selected) {
  43                     var sel = [];
  44                     Ext.Array.each(selected, function(record) {
  45                         sel.push(record.data.vmid);
  46                     });
  47
  48                     // to avoid endless recursion suspend the vmidField change
  49                     // event temporary as it calls us again
  50                     vmidField.suspendEvent('change');
  51                     vmidField.setValue(sel);
  52                     vmidField.resumeEvent('change');
  53                 },
  54             },
  55         });
  56
  57         let storagesel = Ext.create('PVE.form.StorageSelector', {
  58             fieldLabel: gettext('Storage'),
  59             clusterView: true,
  60             storageContent: 'backup',
  61             allowBlank: false,
  62             name: 'storage',
  63             listeners: {
  64                 change: function(f, v) {
  65                     let store = f.getStore();
  66                     let rec = store.findRecord('storage', v, 0, false, true, true);
  67                     let compressionSelector = me.down('pveCompressionSelector');
  68
  69                     if (rec && rec.data && rec.data.type === 'pbs') {
  70                         compressionSelector.setValue('zstd');
  71                         compressionSelector.setDisabled(true);
  72                     } else if (!compressionSelector.getEditable()) {
  73                         compressionSelector.setDisabled(false);
  74                     }
  75                 },
  76             },
  77         });
  78
  79         let store = new Ext.data.Store({
  80             model: 'PVEResources',
  81             sorters: {
  82                 property: 'vmid',
  83                 order: 'ASC',
  84             },
  85         });
  86
  87         let vmgrid = Ext.createWidget('grid', {
  88             store: store,
  89             border: true,
  90             height: 300,
  91             selModel: sm,
  92             disabled: true,
  93             columns: [
  94                 {
  95                     header: 'ID',
  96                     dataIndex: 'vmid',
  97                     width: 60,
  98                 },
  99                 {
 100                     header: gettext('Node'),
 101                     dataIndex: 'node',
 102                 },
 103                 {
 104                     header: gettext('Status'),
 105                     dataIndex: 'uptime',
 106                     renderer: function(value) {
 107                         if (value) {
 108                             return Proxmox.Utils.runningText;
 109                         } else {
 110                             return Proxmox.Utils.stoppedText;
 111                         }
 112                     },
 113                 },
 114                 {
 115                     header: gettext('Name'),
 116                     dataIndex: 'name',
 117                     flex: 1,
 118                 },
 119                 {
 120                     header: gettext('Type'),
 121                     dataIndex: 'type',
 122                 },
 123             ],
 124         });
 125
 126         let selectPoolMembers = function(poolid) {
 127             if (!poolid) {
 128                 return;
 129             }
 130             sm.deselectAll(true);
 131             store.filter([
 132                 {
 133                     id: 'poolFilter',
 134                     property: 'pool',
 135                     value: poolid,
 136                 },
 137             ]);
 138             sm.selectAll(true);
 139         };
 140
 141         let selPool = Ext.create('PVE.form.PoolSelector', {
 142             fieldLabel: gettext('Pool to backup'),
 143             hidden: true,
 144             allowBlank: true,
 145             name: 'pool',
 146             listeners: {
 147                 change: function(selpool, newValue, oldValue) {
 148                     selectPoolMembers(newValue);
 149                 },
 150             },
 151         });
 152
 153         let nodesel = Ext.create('PVE.form.NodeSelector', {
 154             name: 'node',
 155             fieldLabel: gettext('Node'),
 156             allowBlank: true,
 157             editable: true,
 158             autoSelect: false,
 159             emptyText: '-- ' + gettext('All') + ' --',
 160             listeners: {
 161                 change: function(f, value) {
 162                     storagesel.setNodename(value);
 163                     let mode = selModeField.getValue();
 164                     store.clearFilter();
 165                     store.filterBy(function(rec) {
 166                         return !value || rec.get('node') === value;
 167                     });
 168                     if (mode === 'all') {
 169                         sm.selectAll(true);
 170                     }
 171                     if (mode === 'pool') {
 172                         selectPoolMembers(selPool.value);
 173                     }
 174                 },
 175             },
 176         });
 177
 178         let column1 = [
 179             nodesel,
 180             storagesel,
 181             {
 182                 xtype: 'pveCalendarEvent',
 183                 fieldLabel: gettext('Schedule'),
 184                 allowBlank: false,
 185                 name: 'schedule',
 186             },
 187             selModeField,
 188             selPool,
 189         ];
 190
 191         let column2 = [
 192             {
 193                 xtype: 'textfield',
 194                 fieldLabel: gettext('Send email to'),
 195                 name: 'mailto',
 196             },
 197             {
 198                 xtype: 'pveEmailNotificationSelector',
 199                 fieldLabel: gettext('Email'),
 200                 name: 'mailnotification',
 201                 deleteEmpty: !me.isCreate,
 202                 value: me.isCreate ? 'always' : '',
 203             },
 204             {
 205                 xtype: 'pveCompressionSelector',
 206                 fieldLabel: gettext('Compression'),
 207                 name: 'compress',
 208                 deleteEmpty: !me.isCreate,
 209                 value: 'zstd',
 210             },
 211             {
 212                 xtype: 'pveBackupModeSelector',
 213                 fieldLabel: gettext('Mode'),
 214                 value: 'snapshot',
 215                 name: 'mode',
 216             },
 217             {
 218                 xtype: 'proxmoxcheckbox',
 219                 fieldLabel: gettext('Enable'),
 220                 name: 'enabled',
 221                 uncheckedValue: 0,
 222                 defaultValue: 1,
 223                 checked: true,
 224             },
 225             vmidField,
 226         ];
 227
 228         let ipanel = Ext.create('Proxmox.panel.InputPanel', {
 229             onlineHelp: 'chapter_vzdump',
 230             column1: column1,
 231             column2: column2,
 232             columnB: [
 233                 {
 234                     xtype: 'proxmoxtextfield',
 235                     name: 'comment',
 236                     fieldLabel: gettext('Comment'),
 237                     deleteEmpty: !me.isCreate,
 238                 },
 239             ],
 240             onGetValues: function(values) {
 241                 if (!values.node) {
 242                     if (!me.isCreate) {
 243                         Proxmox.Utils.assemble_field_data(values, { 'delete': 'node' });
 244                     }
 245                     delete values.node;
 246                 }
 247
 248                 if (!values.id && me.isCreate) {
 249                     values.id = 'backup-' + Ext.data.identifier.Uuid.Global.generate().slice(0, 13);
 250                 }
 251
 252                 let selMode = values.selMode;
 253                 delete values.selMode;
 254
 255                 if (selMode === 'all') {
 256                     values.all = 1;
 257                     values.exclude = '';
 258                     delete values.vmid;
 259                 } else if (selMode === 'exclude') {
 260                     values.all = 1;
 261                     values.exclude = values.vmid;
 262                     delete values.vmid;
 263                 } else if (selMode === 'pool') {
 264                     delete values.vmid;
 265                 }
 266
 267                 if (selMode !== 'pool') {
 268                     delete values.pool;
 269                 }
 270                 return values;
 271             },
 272         });
 273
 274         let update_vmid_selection = function(list, mode) {
 275             if (mode !== 'all' && mode !== 'pool') {
 276                 sm.deselectAll(true);
 277                 if (list) {
 278                     Ext.Array.each(list.split(','), function(vmid) {
 279                         var rec = store.findRecord('vmid', vmid, 0, false, true, true);
 280                         if (rec) {
 281                             sm.select(rec, true);
 282                         }
 283                     });
 284                 }
 285             }
 286         };
 287
 288         vmidField.on('change', function(f, value) {
 289             let mode = selModeField.getValue();
 290             update_vmid_selection(value, mode);
 291         });
 292
 293         selModeField.on('change', function(f, value, oldValue) {
 294             if (oldValue === 'pool') {
 295                 store.removeFilter('poolFilter');
 296             }
 297
 298             if (oldValue === 'all') {
 299                 sm.deselectAll(true);
 300                 vmidField.setValue('');
 301             }
 302
 303             if (value === 'all') {
 304                 sm.selectAll(true);
 305                 vmgrid.setDisabled(true);
 306             } else {
 307                 vmgrid.setDisabled(false);
 308             }
 309
 310             if (value === 'pool') {
 311                 vmgrid.setDisabled(true);
 312                 vmidField.setValue('');
 313                 selPool.setVisible(true);
 314                 selPool.allowBlank = false;
 315                 selectPoolMembers(selPool.value);
 316             } else {
 317                 selPool.setVisible(false);
 318                 selPool.allowBlank = true;
 319             }
 320             let list = vmidField.getValue();
 321             update_vmid_selection(list, value);
 322         });
 323
 324         let reload = function() {
 325             store.load({
 326                 params: {
 327                     type: 'vm',
 328                 },
 329                 callback: function() {
 330                     let node = nodesel.getValue();
 331                     store.clearFilter();
 332                     store.filterBy(rec => !node || node.length === 0 || rec.get('node') === node);
 333                     let list = vmidField.getValue();
 334                     let mode = selModeField.getValue();
 335                     if (mode === 'all') {
 336                         sm.selectAll(true);
 337                     } else if (mode === 'pool') {
 338                         selectPoolMembers(selPool.value);
 339                     } else {
 340                         update_vmid_selection(list, mode);
 341                     }
 342                 },
 343             });
 344         };
 345
 346         Ext.applyIf(me, {
 347             subject: gettext("Backup Job"),
 348             url: url,
 349             method: method,
 350             bodyPadding: 0,
 351             items: [
 352                 {
 353                     xtype: 'tabpanel',
 354                     region: 'center',
 355                     layout: 'fit',
 356                     bodyPadding: 10,
 357                     items: [
 358                         {
 359                             xtype: 'container',
 360                             title: gettext('General'),
 361                             region: 'center',
 362                             layout: {
 363                                 type: 'vbox',
 364                                 align: 'stretch',
 365                             },
 366                             items: [
 367                                 ipanel,
 368                                 vmgrid,
 369                             ],
 370                         },
 371                         {
 372                             xtype: 'pveBackupJobPrunePanel',
 373                             title: gettext('Retention'),
 374                             isCreate: me.isCreate,
 375                             keepAllDefaultForCreate: false,
 376                             showPBSHint: false,
 377                             fallbackHintHtml: gettext('Without any keep option, the storage\'s configuration or node\'s vzdump.conf is used as fallback'),
 378                         },
 379                     ],
 380                 },
 381             ],
 382
 383         });
 384
 385         me.callParent();
 386
 387         if (me.isCreate) {
 388             selModeField.setValue('include');
 389         } else {
 390             me.load({
 391                 success: function(response, options) {
 392                     let data = response.result.data;
 393
 394                     data.dow = (data.dow || '').split(',');
 395
 396                     if (data.all || data.exclude) {
 397                         if (data.exclude) {
 398                             data.vmid = data.exclude;
 399                             data.selMode = 'exclude';
 400                         } else {
 401                             data.vmid = '';
 402                             data.selMode = 'all';
 403                         }
 404                     } else if (data.pool) {
 405                         data.selMode = 'pool';
 406                         data.selPool = data.pool;
 407                     } else {
 408                         data.selMode = 'include';
 409                     }
 410
 411                     if (data['prune-backups']) {
 412                         Object.assign(data, data['prune-backups']);
 413                         delete data['prune-backups'];
 414                     } else if (data.maxfiles !== undefined) {
 415                         if (data.maxfiles > 0) {
 416                             data['keep-last'] = data.maxfiles;
 417                         } else {
 418                             data['keep-all'] = 1;
 419                         }
 420                         delete data.maxfiles;
 421                     }
 422
 423                     me.setValues(data);
 424                 },
 425             });
 426         }
 427
 428         reload();
 429     },
 430 });
 431
 432 Ext.define('PVE.dc.BackupView', {
 433     extend: 'Ext.grid.GridPanel',
 434
 435     alias: ['widget.pveDcBackupView'],
 436
 437     onlineHelp: 'chapter_vzdump',
 438
 439     allText: '-- ' + gettext('All') + ' --',
 440
 441     initComponent: function() {
 442         let me = this;
 443
 444         let store = new Ext.data.Store({
 445             model: 'pve-cluster-backup',
 446             proxy: {
 447                 type: 'proxmox',
 448                 url: "/api2/json/cluster/backup",
 449             },
 450         });
 451
 452         let not_backed_store = new Ext.data.Store({
 453             sorters: 'vmid',
 454             proxy: {
 455                 type: 'proxmox',
 456                 url: 'api2/json/cluster/backup-info/not-backed-up',
 457             },
 458         });
 459
 460         let noBackupJobWarning, noBackupJobInfoButton;
 461         let reload = function() {
 462             store.load();
 463             not_backed_store.load({
 464                 callback: function(records, operation, success) {
 465                     noBackupJobWarning.setVisible(records.length > 0);
 466                     noBackupJobInfoButton.setVisible(records.length > 0);
 467                 },
 468             });
 469         };
 470
 471         let sm = Ext.create('Ext.selection.RowModel', {});
 472
 473         let run_editor = function() {
 474             let rec = sm.getSelection()[0];
 475             if (!rec) {
 476                 return;
 477             }
 478
 479             let win = Ext.create('PVE.dc.BackupEdit', {
 480                 jobid: rec.data.id,
 481             });
 482             win.on('destroy', reload);
 483             win.show();
 484         };
 485
 486         let run_detail = function() {
 487             let record = sm.getSelection()[0];
 488             if (!record) {
 489                 return;
 490             }
 491             Ext.create('Ext.window.Window', {
 492                 modal: true,
 493                 width: 800,
 494                 height: 600,
 495                 stateful: true,
 496                 stateId: 'backup-detail-view',
 497                 resizable: true,
 498                 layout: 'fit',
 499                 title: gettext('Backup Details'),
 500                 items: [
 501                     {
 502                         xtype: 'panel',
 503                         region: 'center',
 504                         layout: {
 505                             type: 'vbox',
 506                             align: 'stretch',
 507                         },
 508                         items: [
 509                             {
 510                                 xtype: 'pveBackupInfo',
 511                                 flex: 0,
 512                                 layout: 'fit',
 513                                 record: record.data,
 514                             },
 515                             {
 516                                 xtype: 'pveBackupDiskTree',
 517                                 title: gettext('Included disks'),
 518                                 flex: 1,
 519                                 jobid: record.data.id,
 520                             },
 521                         ],
 522                     },
 523                 ],
 524             }).show();
 525         };
 526
 527         let run_backup_now = function(job) {
 528             job = Ext.clone(job);
 529
 530             let jobNode = job.node;
 531             // Remove properties related to scheduling
 532             delete job.enabled;
 533             delete job.starttime;
 534             delete job.dow;
 535             delete job.id;
 536             delete job.schedule;
 537             delete job.type;
 538             delete job.node;
 539             job.all = job.all === true ? 1 : 0;
 540
 541             if (job['prune-backups']) {
 542                 job['prune-backups'] = PVE.Parser.printPropertyString(job['prune-backups']);
 543             }
 544
 545             let allNodes = PVE.data.ResourceStore.getNodes();
 546             let nodes = allNodes.filter(node => node.status === 'online').map(node => node.node);
 547             let errors = [];
 548
 549             if (jobNode !== undefined) {
 550                 if (!nodes.includes(jobNode)) {
 551                     Ext.Msg.alert('Error', "Node '"+ jobNode +"' from backup job isn't online!");
 552                     return;
 553                 }
 554                 nodes = [jobNode];
 555             } else {
 556                 let unkownNodes = allNodes.filter(node => node.status !== 'online');
 557                 if (unkownNodes.length > 0) {errors.push(unkownNodes.map(node => node.node + ": " + gettext("Node is offline")));}
 558             }
 559             let jobTotalCount = nodes.length, jobsStarted = 0;
 560
 561             Ext.Msg.show({
 562                 title: gettext('Please wait...'),
 563                 closable: false,
 564                 progress: true,
 565                 progressText: '0/' + jobTotalCount,
 566             });
 567
 568             let postRequest = function() {
 569                 jobsStarted++;
 570                 Ext.Msg.updateProgress(jobsStarted / jobTotalCount, jobsStarted + '/' + jobTotalCount);
 571
 572                 if (jobsStarted === jobTotalCount) {
 573                     Ext.Msg.hide();
 574                     if (errors.length > 0) {
 575                         Ext.Msg.alert('Error', 'Some errors have been encountered:<br />' + errors.join('<br />'));
 576                     }
 577                 }
 578             };
 579
 580             nodes.forEach(node => Proxmox.Utils.API2Request({
 581                 url: '/nodes/' + node + '/vzdump',
 582                 method: 'POST',
 583                 params: job,
 584                 failure: function(response, opts) {
 585                     errors.push(node + ': ' + response.htmlStatus);
 586                     postRequest();
 587                 },
 588                 success: postRequest,
 589             }));
 590         };
 591
 592         let run_show_not_backed = function() {
 593             Ext.create('Ext.window.Window', {
 594                 modal: true,
 595                 width: 600,
 596                 height: 500,
 597                 resizable: true,
 598                 layout: 'fit',
 599                 title: gettext('Guests without backup job'),
 600                 items: [
 601                     {
 602                         xtype: 'panel',
 603                         region: 'center',
 604                         layout: {
 605                             type: 'vbox',
 606                             align: 'stretch',
 607                         },
 608                         items: [
 609                             {
 610                                 xtype: 'pveBackedGuests',
 611                                 flex: 1,
 612                                 layout: 'fit',
 613                                 store: not_backed_store,
 614                             },
 615                         ],
 616                     },
 617                 ],
 618             }).show();
 619         };
 620
 621         var edit_btn = new Proxmox.button.Button({
 622             text: gettext('Edit'),
 623             disabled: true,
 624             selModel: sm,
 625             handler: run_editor,
 626         });
 627
 628         var run_btn = new Proxmox.button.Button({
 629             text: gettext('Run now'),
 630             disabled: true,
 631             selModel: sm,
 632             handler: function() {
 633                 var rec = sm.getSelection()[0];
 634                 if (!rec) {
 635                     return;
 636                 }
 637
 638                 Ext.Msg.show({
 639                     title: gettext('Confirm'),
 640                     icon: Ext.Msg.QUESTION,
 641                     msg: gettext('Start the selected backup job now?'),
 642                     buttons: Ext.Msg.YESNO,
 643                     callback: function(btn) {
 644                         if (btn !== 'yes') {
 645                             return;
 646                         }
 647                         run_backup_now(rec.data);
 648                     },
 649                 });
 650             },
 651         });
 652
 653         var remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
 654             selModel: sm,
 655             baseurl: '/cluster/backup',
 656             callback: function() {
 657                 reload();
 658             },
 659         });
 660
 661         var detail_btn = new Proxmox.button.Button({
 662             text: gettext('Job Detail'),
 663             disabled: true,
 664             tooltip: gettext('Show job details and which guests and volumes are affected by the backup job'),
 665             selModel: sm,
 666             handler: run_detail,
 667         });
 668
 669         noBackupJobWarning = Ext.create('Ext.toolbar.TextItem', {
 670             html: '<i class="fa fa-fw fa-exclamation-circle"></i>' + gettext('Some guests are not covered by any backup job.'),
 671             hidden: true,
 672         });
 673
 674         noBackupJobInfoButton = new Proxmox.button.Button({
 675             text: gettext('Show'),
 676             hidden: true,
 677             handler: run_show_not_backed,
 678         });
 679
 680         Proxmox.Utils.monStoreErrors(me, store);
 681
 682         Ext.apply(me, {
 683             store: store,
 684             selModel: sm,
 685             stateful: true,
 686             stateId: 'grid-dc-backup',
 687             viewConfig: {
 688                 trackOver: false,
 689             },
 690             tbar: [
 691                 {
 692                     text: gettext('Add'),
 693                     handler: function() {
 694                         var win = Ext.create('PVE.dc.BackupEdit', {});
 695                         win.on('destroy', reload);
 696                         win.show();
 697                     },
 698                 },
 699                 '-',
 700                 remove_btn,
 701                 edit_btn,
 702                 detail_btn,
 703                 '-',
 704                 run_btn,
 705                 '->',
 706                 noBackupJobWarning,
 707                 noBackupJobInfoButton,
 708                 '-',
 709                 {
 710                     xtype: 'proxmoxButton',
 711                     selModel: null,
 712                     text: gettext('Schedule Simulator'),
 713                     handler: () => {
 714                         let record = sm.getSelection()[0];
 715                         let schedule;
 716                         if (record) {
 717                             schedule = record.data.schedule;
 718                         }
 719                         Ext.create('PVE.window.ScheduleSimulator', {
 720                             schedule,
 721                         }).show();
 722                     },
 723                 },
 724             ],
 725             columns: [
 726                 {
 727                     header: gettext('Enabled'),
 728                     width: 80,
 729                     dataIndex: 'enabled',
 730                     xtype: 'checkcolumn',
 731                     sortable: true,
 732                     disabled: true,
 733                     disabledCls: 'x-item-enabled',
 734                     stopSelection: false,
 735                 },
 736                 {
 737                     header: gettext('ID'),
 738                     dataIndex: 'id',
 739                     hidden: true,
 740                 },
 741                 {
 742                     header: gettext('Node'),
 743                     width: 100,
 744                     sortable: true,
 745                     dataIndex: 'node',
 746                     renderer: function(value) {
 747                         if (value) {
 748                             return value;
 749                         }
 750                         return me.allText;
 751                     },
 752                 },
 753                 {
 754                     header: gettext('Schedule'),
 755                     width: 150,
 756                     dataIndex: 'schedule',
 757                 },
 758                 {
 759                     header: gettext('Storage'),
 760                     width: 100,
 761                     sortable: true,
 762                     dataIndex: 'storage',
 763                 },
 764                 {
 765                     header: gettext('Comment'),
 766                     dataIndex: 'comment',
 767                     renderer: Ext.htmlEncode,
 768                     sorter: (a, b) => (a.data.comment || '').localeCompare(b.data.comment || ''),
 769                     flex: 1,
 770                 },
 771                 {
 772                     header: gettext('Selection'),
 773                     flex: 2,
 774                     sortable: false,
 775                     dataIndex: 'vmid',
 776                     renderer: PVE.Utils.render_backup_selection,
 777                 },
 778             ],
 779             listeners: {
 780                 activate: reload,
 781                 itemdblclick: run_editor,
 782             },
 783         });
 784
 785         me.callParent();
 786     },
 787 }, function() {
 788     Ext.define('pve-cluster-backup', {
 789         extend: 'Ext.data.Model',
 790         fields: [
 791             'id',
 792             'compress',
 793             'dow',
 794             'exclude',
 795             'mailto',
 796             'mode',
 797             'node',
 798             'pool',
 799             'starttime',
 800             'storage',
 801             'vmid',
 802             { name: 'enabled', type: 'boolean' },
 803             { name: 'all', type: 'boolean' },
 804         ],
 805     });
 806 });