www/manager6/storage/BackupView.js

   1 Ext.define('PVE.storage.BackupView', {
   2     extend: 'PVE.storage.ContentView',
   3
   4     alias: 'widget.pveStorageBackupView',
   5
   6     showColumns: ['name', 'notes', 'protected', 'date', 'format', 'size'],
   7
   8     initComponent: function() {
   9         var me = this;
  10
  11         var nodename = me.nodename = me.pveSelNode.data.node;
  12         if (!nodename) {
  13             throw "no node name specified";
  14         }
  15
  16         var storage = me.storage = me.pveSelNode.data.storage;
  17         if (!storage) {
  18             throw "no storage ID specified";
  19         }
  20
  21         me.content = 'backup';
  22
  23         var sm = me.sm = Ext.create('Ext.selection.RowModel', {});
  24
  25         var reload = function() {
  26             me.store.load();
  27         };
  28
  29         let pruneButton = Ext.create('Proxmox.button.Button', {
  30             text: gettext('Prune group'),
  31             disabled: true,
  32             selModel: sm,
  33             setBackupGroup: function(backup) {
  34                 if (backup) {
  35                     let name = backup.text;
  36                     let vmid = backup.vmid;
  37                     let format = backup.format;
  38
  39                     let vmtype;
  40                     if (name.startsWith('vzdump-lxc-') || format === "pbs-ct") {
  41                         vmtype = 'lxc';
  42                     } else if (name.startsWith('vzdump-qemu-') || format === "pbs-vm") {
  43                         vmtype = 'qemu';
  44                     }
  45
  46                     if (vmid && vmtype) {
  47                         this.setText(gettext('Prune group') + ` ${vmtype}/${vmid}`);
  48                         this.vmid = vmid;
  49                         this.vmtype = vmtype;
  50                         this.setDisabled(false);
  51                         return;
  52                     }
  53                 }
  54                 this.setText(gettext('Prune group'));
  55                 this.vmid = null;
  56                 this.vmtype = null;
  57                 this.setDisabled(true);
  58             },
  59             handler: function(b, e, rec) {
  60                 let win = Ext.create('PVE.window.Prune', {
  61                     nodename: nodename,
  62                     storage: storage,
  63                     backup_id: this.vmid,
  64                     backup_type: this.vmtype,
  65                 });
  66                 win.show();
  67                 win.on('destroy', reload);
  68             },
  69         });
  70
  71         me.on('selectionchange', function(model, srecords, eOpts) {
  72             if (srecords.length === 1) {
  73                 pruneButton.setBackupGroup(srecords[0].data);
  74             } else {
  75                 pruneButton.setBackupGroup(null);
  76             }
  77         });
  78
  79         let isPBS = me.pluginType === 'pbs';
  80
  81         me.tbar = [
  82             {
  83                 xtype: 'proxmoxButton',
  84                 text: gettext('Restore'),
  85                 selModel: sm,
  86                 disabled: true,
  87                 handler: function(b, e, rec) {
  88                     var vmtype;
  89                     if (PVE.Utils.volume_is_qemu_backup(rec.data.volid, rec.data.format)) {
  90                         vmtype = 'qemu';
  91                     } else if (PVE.Utils.volume_is_lxc_backup(rec.data.volid, rec.data.format)) {
  92                         vmtype = 'lxc';
  93                     } else {
  94                         return;
  95                     }
  96
  97                     var win = Ext.create('PVE.window.Restore', {
  98                         nodename: nodename,
  99                         volid: rec.data.volid,
 100                         volidText: PVE.Utils.render_storage_content(rec.data.volid, {}, rec),
 101                         vmtype: vmtype,
 102                         isPBS: isPBS,
 103                     });
 104                     win.show();
 105                     win.on('destroy', reload);
 106                 },
 107             },
 108         ];
 109         if (isPBS) {
 110             me.tbar.push({
 111                 xtype: 'proxmoxButton',
 112                 text: gettext('File Restore'),
 113                 disabled: true,
 114                 selModel: sm,
 115                 handler: function(b, e, rec) {
 116                     let isVMArchive = PVE.Utils.volume_is_qemu_backup(rec.data.volid, rec.data.format);
 117                     Ext.create('Proxmox.window.FileBrowser', {
 118                         title: gettext('File Restore') + " - " + rec.data.text,
 119                         listURL: `/api2/json/nodes/localhost/storage/${me.storage}/file-restore/list`,
 120                         downloadURL: `/api2/json/nodes/localhost/storage/${me.storage}/file-restore/download`,
 121                         extraParams: {
 122                             volume: rec.data.volid,
 123                         },
 124                         archive: isVMArchive ? 'all' : undefined,
 125                         autoShow: true,
 126                     });
 127                 },
 128             });
 129         }
 130         me.tbar.push(
 131             {
 132                 xtype: 'proxmoxButton',
 133                 text: gettext('Show Configuration'),
 134                 disabled: true,
 135                 selModel: sm,
 136                 handler: function(b, e, rec) {
 137                     var win = Ext.create('PVE.window.BackupConfig', {
 138                         volume: rec.data.volid,
 139                         pveSelNode: me.pveSelNode,
 140                     });
 141
 142                     win.show();
 143                 },
 144             },
 145             {
 146                 xtype: 'proxmoxButton',
 147                 text: gettext('Edit Notes'),
 148                 disabled: true,
 149                 selModel: sm,
 150                 handler: function(b, e, rec) {
 151                     let volid = rec.data.volid;
 152                     Ext.create('Proxmox.window.Edit', {
 153                         autoLoad: true,
 154                         width: 600,
 155                         height: 400,
 156                         resizable: true,
 157                         title: gettext('Notes'),
 158                         url: `/api2/extjs/nodes/${nodename}/storage/${me.storage}/content/${volid}`,
 159                         layout: 'fit',
 160                         items: [
 161                             {
 162                                 xtype: 'textarea',
 163                                 layout: 'fit',
 164                                 name: 'notes',
 165                                 height: '100%',
 166                             },
 167                         ],
 168                         listeners: {
 169                             destroy: () => reload(),
 170                         },
 171                     }).show();
 172                 },
 173             },
 174             {
 175                 xtype: 'proxmoxButton',
 176                 text: gettext('Change Protection'),
 177                 disabled: true,
 178                 handler: function(button, event, record) {
 179                     const volid = record.data.volid;
 180                     Proxmox.Utils.API2Request({
 181                         url: `/api2/extjs/nodes/${nodename}/storage/${me.storage}/content/${volid}`,
 182                         method: 'PUT',
 183                         waitMsgTarget: me,
 184                         params: { 'protected': record.data.protected ? 0 : 1 },
 185                         failure: (response) => Ext.Msg.alert('Error', response.htmlStatus),
 186                         success: (response) => reload(),
 187                     });
 188                 },
 189             },
 190             '-',
 191             pruneButton,
 192         );
 193
 194         if (isPBS) {
 195             me.extraColumns = {
 196                 encrypted: {
 197                     header: gettext('Encrypted'),
 198                     dataIndex: 'encrypted',
 199                     renderer: PVE.Utils.render_backup_encryption,
 200                     sorter: {
 201                         property: 'encrypted',
 202                         transform: (value) => value ? 1 : 0,
 203                     },
 204                 },
 205                 verification: {
 206                     header: gettext('Verify State'),
 207                     dataIndex: 'verification',
 208                     renderer: PVE.Utils.render_backup_verification,
 209                     sorter: {
 210                         property: 'verification',
 211                         transform: (value) => {
 212                             let state = value?.state ?? 'none';
 213                             let order = PVE.Utils.verificationStateOrder;
 214                             return order[state] ?? order.__default__;
 215                         },
 216                     },
 217                 },
 218             };
 219         }
 220
 221         me.callParent();
 222
 223         me.store.getSorters().clear();
 224         me.store.setSorters([
 225             {
 226                 property: 'vmid',
 227                 direction: 'ASC',
 228             },
 229             {
 230                 property: 'vdate',
 231                 direction: 'DESC',
 232             },
 233         ]);
 234     },
 235 });