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',
  41             'keep-hourly',
  42             'keep-daily',
  43             'keep-weekly',
  44             'keep-monthly',
  45             'keep-yearly',
  46         ];
  47
  48         let pruneSettings = keepNames.map(
  49             name => Ext.create('Ext.form.field.Display', {
  50                 name: name,
  51                 fieldLabel: gettext(name),
  52                 hidden: true,
  53                 disabled: true,
  54             }),
  55         );
  56
  57         let removeCheckbox = Ext.create('Proxmox.form.Checkbox', {
  58             name: 'remove',
  59             checked: false,
  60             hidden: true,
  61             uncheckedValue: 0,
  62             fieldLabel: gettext('Prune'),
  63             autoEl: {
  64                 tag: 'div',
  65                 'data-qtip': gettext('Prune older backups afterwards'),
  66             },
  67             handler: function(checkbox, value) {
  68                 pruneSettings.forEach(field => field.setDisabled(!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                     let store = f.getStore();
  83                     let rec = store.findRecord('storage', v, 0, false, true, true);
  84
  85                     if (rec && rec.data && rec.data.type === 'pbs') {
  86                         compressionSelector.setValue('zstd');
  87                         compressionSelector.setDisabled(true);
  88                     } else if (!compressionSelector.getEditable()) {
  89                         compressionSelector.setDisabled(false);
  90                     }
  91
  92                     Proxmox.Utils.API2Request({
  93                         url: `/nodes/${me.nodename}/vzdump/defaults`,
  94                         method: 'GET',
  95                         params: {
  96                             storage: v,
  97                         },
  98                         waitMsgTarget: me,
  99                         success: function(response, opts) {
 100                             const data = response.result.data;
 101
 102                             if (!initialDefaults && data.mailto !== undefined) {
 103                                 mailtoField.setValue(data.mailto);
 104                             }
 105                             if (!initialDefaults && data.mode !== undefined) {
 106                                 modeSelector.setValue(data.mode);
 107                             }
 108
 109                             initialDefaults = true;
 110
 111                             // always update storage dependent properties
 112                             if (data['prune-backups'] !== undefined) {
 113                                 const keepParams = PVE.Parser.parsePropertyString(
 114                                     data["prune-backups"],
 115                                 );
 116                                 if (!keepParams['keep-all']) {
 117                                     removeCheckbox.setHidden(false);
 118                                     pruneSettings.forEach(function(field) {
 119                                         const keep = keepParams[field.name];
 120                                         if (keep) {
 121                                             field.setValue(keep);
 122                                             field.setHidden(false);
 123                                         } else {
 124                                             field.reset();
 125                                             field.setHidden(true);
 126                                         }
 127                                     });
 128                                     return;
 129                                 }
 130                             }
 131
 132                             // no defaults or keep-all=1
 133                             removeCheckbox.setHidden(true);
 134                             removeCheckbox.setValue(false);
 135                             pruneSettings.forEach(function(field) {
 136                                 field.reset();
 137                                 field.setHidden(true);
 138                             });
 139                         },
 140                         failure: function(response, opts) {
 141                             Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 142                         },
 143                     });
 144                 },
 145             },
 146         });
 147         storagesel.setValue(me.storage);
 148
 149         me.formPanel = Ext.create('Ext.form.Panel', {
 150             bodyPadding: 10,
 151             border: false,
 152             fieldDefaults: {
 153                 labelWidth: 100,
 154                 anchor: '100%',
 155             },
 156             items: [
 157                 storagesel,
 158                 modeSelector,
 159                 compressionSelector,
 160                 mailtoField,
 161                 removeCheckbox,
 162             ].concat(pruneSettings),
 163         });
 164
 165         var form = me.formPanel.getForm();
 166
 167         var submitBtn = Ext.create('Ext.Button', {
 168             text: gettext('Backup'),
 169             handler: function() {
 170                 var storage = storagesel.getValue();
 171                 var values = form.getValues();
 172                 var params = {
 173                     storage: storage,
 174                     vmid: me.vmid,
 175                     mode: values.mode,
 176                     remove: values.remove,
 177                 };
 178
 179                 if (values.mailto) {
 180                     params.mailto = values.mailto;
 181                 }
 182
 183                 if (values.compress) {
 184                     params.compress = values.compress;
 185                 }
 186
 187                 Proxmox.Utils.API2Request({
 188                     url: '/nodes/' + me.nodename + '/vzdump',
 189                     params: params,
 190                     method: 'POST',
 191                     failure: function(response, opts) {
 192                         Ext.Msg.alert('Error', response.htmlStatus);
 193                     },
 194                     success: function(response, options) {
 195                         // close later so we reload the grid
 196                         // after the task has completed
 197                         me.hide();
 198
 199                         var upid = response.result.data;
 200
 201                         var win = Ext.create('Proxmox.window.TaskViewer', {
 202                             upid: upid,
 203                             listeners: {
 204                                 close: function() {
 205                                     me.close();
 206                                 },
 207                             },
 208                         });
 209                         win.show();
 210                     },
 211                 });
 212             },
 213         });
 214
 215         var helpBtn = Ext.create('Proxmox.button.Help', {
 216             onlineHelp: 'chapter_vzdump',
 217             listenToGlobalEvent: false,
 218             hidden: false,
 219         });
 220
 221         var title = gettext('Backup') + " " +
 222             (me.vmtype === 'lxc' ? "CT" : "VM") +
 223             " " + me.vmid;
 224
 225         Ext.apply(me, {
 226             title: title,
 227             width: 350,
 228             modal: true,
 229             layout: 'auto',
 230             border: false,
 231             items: [me.formPanel],
 232             buttons: [helpBtn, '->', submitBtn],
 233         });
 234
 235         me.callParent();
 236     },
 237 });