www/manager6/window/Backup.js

   1 Ext.define('PVE.window.Backup', {
   2     extend: 'Ext.window.Window',
   3
   4     resizable: false,
   5
   6     initComponent: function() {
   7         var me = this;
   8
   9         if (!me.nodename) {
  10             throw "no node name specified";
  11         }
  12
  13         if (!me.vmid) {
  14             throw "no VM ID specified";
  15         }
  16
  17         if (!me.vmtype) {
  18             throw "no VM type specified";
  19         }
  20
  21         let compressionSelector = Ext.create('PVE.form.CompressionSelector', {
  22             name: 'compress',
  23             value: 'zstd',
  24             fieldLabel: gettext('Compression'),
  25         });
  26
  27         let modeSelector = Ext.create('PVE.form.BackupModeSelector', {
  28             fieldLabel: gettext('Mode'),
  29             value: 'snapshot',
  30             name: 'mode',
  31         });
  32
  33         let mailtoField = Ext.create('Ext.form.field.Text', {
  34             fieldLabel: gettext('Send email to'),
  35             name: 'mailto',
  36             emptyText: Proxmox.Utils.noneText,
  37         });
  38
  39         const keepNames = [
  40             ['keep-last', gettext('Keep Last')],
  41             ['keep-hourly', gettext('Keep Hourly')],
  42             ['keep-daily', gettext('Keep Daily')],
  43             ['keep-weekly', gettext('Keep Weekly')],
  44             ['keep-monthly', gettext('Keep Monthly')],
  45             ['keep-yearly', gettext('Keep Yearly')],
  46         ];
  47
  48         let pruneSettings = keepNames.map(
  49             name => Ext.create('Ext.form.field.Display', {
  50                 name: name[0],
  51                 fieldLabel: name[1],
  52                 hidden: true,
  53             }),
  54         );
  55
  56         let removeCheckbox = Ext.create('Proxmox.form.Checkbox', {
  57             name: 'remove',
  58             checked: false,
  59             hidden: true,
  60             uncheckedValue: 0,
  61             fieldLabel: gettext('Prune'),
  62             autoEl: {
  63                 tag: 'div',
  64                 'data-qtip': gettext('Prune older backups afterwards'),
  65             },
  66             handler: function(checkbox, value) {
  67                 pruneSettings.forEach(field => field.setHidden(!value));
  68                 me.down('label[name="pruneLabel"]').setHidden(!value);
  69             },
  70         });
  71
  72         let initialDefaults = false;
  73
  74         var storagesel = Ext.create('PVE.form.StorageSelector', {
  75             nodename: me.nodename,
  76             name: 'storage',
  77             fieldLabel: gettext('Storage'),
  78             storageContent: 'backup',
  79             allowBlank: false,
  80             listeners: {
  81                 change: function(f, v) {
  82                     if (!initialDefaults) {
  83                         me.setLoading(false);
  84                     }
  85
  86                     if (v === null || v === undefined || v === '') {
  87                         return;
  88                     }
  89
  90                     let store = f.getStore();
  91                     let rec = store.findRecord('storage', v, 0, false, true, true);
  92
  93                     if (rec && rec.data && rec.data.type === 'pbs') {
  94                         compressionSelector.setValue('zstd');
  95                         compressionSelector.setDisabled(true);
  96                     } else if (!compressionSelector.getEditable()) {
  97                         compressionSelector.setDisabled(false);
  98                     }
  99
 100                     Proxmox.Utils.API2Request({
 101                         url: `/nodes/${me.nodename}/vzdump/defaults`,
 102                         method: 'GET',
 103                         params: {
 104                             storage: v,
 105                         },
 106                         waitMsgTarget: me,
 107                         success: function(response, opts) {
 108                             const data = response.result.data;
 109
 110                             if (!initialDefaults && data.mailto !== undefined) {
 111                                 mailtoField.setValue(data.mailto);
 112                             }
 113                             if (!initialDefaults && data.mode !== undefined) {
 114                                 modeSelector.setValue(data.mode);
 115                             }
 116
 117                             initialDefaults = true;
 118
 119                             // always update storage dependent properties
 120                             if (data['prune-backups'] !== undefined) {
 121                                 const keepParams = PVE.Parser.parsePropertyString(
 122                                     data["prune-backups"],
 123                                 );
 124                                 if (!keepParams['keep-all']) {
 125                                     removeCheckbox.setHidden(false);
 126                                     pruneSettings.forEach(function(field) {
 127                                         const keep = keepParams[field.name];
 128                                         if (keep) {
 129                                             field.setValue(keep);
 130                                         } else {
 131                                             field.reset();
 132                                         }
 133                                     });
 134                                     return;
 135                                 }
 136                             }
 137
 138                             // no defaults or keep-all=1
 139                             removeCheckbox.setHidden(true);
 140                             removeCheckbox.setValue(false);
 141                             pruneSettings.forEach(field => field.reset());
 142                         },
 143                         failure: function(response, opts) {
 144                             initialDefaults = true;
 145
 146                             removeCheckbox.setHidden(true);
 147                             removeCheckbox.setValue(false);
 148                             pruneSettings.forEach(field => field.reset());
 149
 150                             Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 151                         },
 152                     });
 153                 },
 154             },
 155         });
 156
 157         me.formPanel = Ext.create('Proxmox.panel.InputPanel', {
 158             bodyPadding: 10,
 159             border: false,
 160             column1: [
 161                 storagesel,
 162                 modeSelector,
 163                 removeCheckbox,
 164             ],
 165             column2: [
 166                 compressionSelector,
 167                 mailtoField,
 168             ],
 169             columnB: [
 170                 {
 171                     xtype: 'label',
 172                     name: 'pruneLabel',
 173                     text: gettext('Storage Retention Configuration') + ':',
 174                     hidden: true,
 175                 },
 176                 {
 177                     layout: 'hbox',
 178                     border: false,
 179                     defaults: {
 180                         border: false,
 181                         layout: 'anchor',
 182                         flex: 1,
 183                     },
 184                     items: [
 185                         {
 186                             padding: '0 10 0 0',
 187                             defaults: {
 188                                 labelWidth: 110,
 189                             },
 190                             items: [
 191                                 pruneSettings[0],
 192                                 pruneSettings[2],
 193                                 pruneSettings[4],
 194                             ],
 195                         },
 196                         {
 197                             padding: '0 0 0 10',
 198                             defaults: {
 199                                 labelWidth: 110,
 200                             },
 201                             items: [
 202                                 pruneSettings[1],
 203                                 pruneSettings[3],
 204                                 pruneSettings[5],
 205                             ],
 206                         },
 207                     ],
 208                 },
 209             ],
 210         });
 211
 212         var submitBtn = Ext.create('Ext.Button', {
 213             text: gettext('Backup'),
 214             handler: function() {
 215                 var storage = storagesel.getValue();
 216                 let values = me.formPanel.getValues();
 217                 var params = {
 218                     storage: storage,
 219                     vmid: me.vmid,
 220                     mode: values.mode,
 221                     remove: values.remove,
 222                 };
 223
 224                 if (values.mailto) {
 225                     params.mailto = values.mailto;
 226                 }
 227
 228                 if (values.compress) {
 229                     params.compress = values.compress;
 230                 }
 231
 232                 Proxmox.Utils.API2Request({
 233                     url: '/nodes/' + me.nodename + '/vzdump',
 234                     params: params,
 235                     method: 'POST',
 236                     failure: function(response, opts) {
 237                         Ext.Msg.alert('Error', response.htmlStatus);
 238                     },
 239                     success: function(response, options) {
 240                         // close later so we reload the grid
 241                         // after the task has completed
 242                         me.hide();
 243
 244                         var upid = response.result.data;
 245
 246                         var win = Ext.create('Proxmox.window.TaskViewer', {
 247                             upid: upid,
 248                             listeners: {
 249                                 close: function() {
 250                                     me.close();
 251                                 },
 252                             },
 253                         });
 254                         win.show();
 255                     },
 256                 });
 257             },
 258         });
 259
 260         var helpBtn = Ext.create('Proxmox.button.Help', {
 261             onlineHelp: 'chapter_vzdump',
 262             listenToGlobalEvent: false,
 263             hidden: false,
 264         });
 265
 266         var title = gettext('Backup') + " " +
 267             (me.vmtype === 'lxc' ? "CT" : "VM") +
 268             " " + me.vmid;
 269
 270         Ext.apply(me, {
 271             title: title,
 272             modal: true,
 273             layout: 'auto',
 274             border: false,
 275             items: [me.formPanel],
 276             buttons: [helpBtn, '->', submitBtn],
 277             listeners: {
 278                 afterrender: function() {
 279                     /// cleared within the storage selector's change listener
 280                     me.setLoading(gettext('Please wait...'));
 281                     storagesel.setValue(me.storage);
 282                 },
 283             },
 284         });
 285
 286         me.callParent();
 287     },
 288 });