www/manager6/grid/BackupView.js

   1 Ext.define('PVE.grid.BackupView', {
   2     extend: 'Ext.grid.GridPanel',
   3
   4     alias: ['widget.pveBackupView'],
   5
   6     onlineHelp: 'chapter_vzdump',
   7
   8     stateful: true,
   9     stateId: 'grid-guest-backup',
  10
  11     initComponent : function() {
  12         var me = this;
  13
  14         var nodename = me.pveSelNode.data.node;
  15         if (!nodename) {
  16             throw "no node name specified";
  17         }
  18
  19         var vmid = me.pveSelNode.data.vmid;
  20         if (!vmid) {
  21             throw "no VM ID specified";
  22         }
  23
  24         var vmtype = me.pveSelNode.data.type;
  25         if (!vmtype) {
  26             throw "no VM type specified";
  27         }
  28
  29         var vmtypeFilter;
  30         if (vmtype === 'lxc' || vmtype === 'openvz') {
  31             vmtypeFilter = function(item) {
  32                 return PVE.Utils.volume_is_lxc_backup(item.data.volid, item.data.format);
  33             };
  34         } else if (vmtype === 'qemu') {
  35             vmtypeFilter = function(item) {
  36                 return PVE.Utils.volume_is_qemu_backup(item.data.volid, item.data.format);
  37             };
  38         } else {
  39             throw "unsupported VM type '" + vmtype + "'";
  40         }
  41
  42         var searchFilter = {
  43             property: 'volid',
  44             value: '',
  45             anyMatch: true,
  46             caseSensitive: false,
  47         };
  48
  49         var vmidFilter = {
  50             property: 'vmid',
  51             value: vmid,
  52             exactMatch: true,
  53         };
  54
  55         me.store = Ext.create('Ext.data.Store', {
  56             model: 'pve-storage-content',
  57             sorters: {
  58                 property: 'volid',
  59                 order: 'DESC',
  60             },
  61             filters: [
  62                 vmtypeFilter,
  63                 searchFilter,
  64                 vmidFilter,
  65                 ],
  66         });
  67
  68         let updateFilter = function() {
  69             me.store.filter([
  70                 vmtypeFilter,
  71                 searchFilter,
  72                 vmidFilter,
  73             ]);
  74         };
  75
  76         var reload = Ext.Function.createBuffered(function() {
  77             if (me.store) {
  78                 me.store.load();
  79             }
  80         }, 100);
  81
  82         var setStorage = function(storage) {
  83             var url = '/api2/json/nodes/' + nodename + '/storage/' + storage + '/content';
  84             url += '?content=backup';
  85
  86             me.store.setProxy({
  87                 type: 'proxmox',
  88                 url: url,
  89             });
  90
  91             reload();
  92         };
  93
  94         var storagesel = Ext.create('PVE.form.StorageSelector', {
  95             nodename: nodename,
  96             fieldLabel: gettext('Storage'),
  97             labelAlign: 'right',
  98             storageContent: 'backup',
  99             allowBlank: false,
 100             listeners: {
 101                 change: function(f, value) {
 102                     let storage = f.getStore().findRecord('storage', value, 0, false, true, true);
 103                     if (storage) {
 104                         let isPBS = storage.data.type === 'pbs';
 105                         me.getColumns().forEach((column) => {
 106                             let id = column.dataIndex;
 107                             if (id === 'verification' || id === 'encrypted') {
 108                                 column.setHidden(!isPBS);
 109                             }
 110                         });
 111                     }
 112                     setStorage(value);
 113                 },
 114             },
 115         });
 116
 117         var storagefilter = Ext.create('Ext.form.field.Text', {
 118             fieldLabel: gettext('Search'),
 119             labelWidth: 50,
 120             labelAlign: 'right',
 121             enableKeyEvents: true,
 122             value: searchFilter.value,
 123             listeners: {
 124                 buffer: 500,
 125                 keyup: function(field) {
 126                     me.store.clearFilter(true);
 127                     searchFilter.value = field.getValue();
 128                     updateFilter();
 129                 },
 130             },
 131         });
 132
 133         var vmidfilterCB = Ext.create('Ext.form.field.Checkbox', {
 134             boxLabel: gettext('Filter VMID'),
 135             value: '1',
 136             listeners: {
 137                 change: function(cb, value) {
 138                     vmidFilter.value = value ? vmid : '';
 139                     vmidFilter.exactMatch = !!value;
 140                     updateFilter();
 141                 },
 142             },
 143         });
 144
 145         var sm = Ext.create('Ext.selection.RowModel', {});
 146
 147         var backup_btn = Ext.create('Ext.button.Button', {
 148             text: gettext('Backup now'),
 149             handler: function() {
 150                 var win = Ext.create('PVE.window.Backup', {
 151                     nodename: nodename,
 152                     vmid: vmid,
 153                     vmtype: vmtype,
 154                     storage: storagesel.getValue(),
 155                     listeners : {
 156                         close: function() {
 157                             reload();
 158                         },
 159                     },
 160                 });
 161                 win.show();
 162             },
 163         });
 164
 165         var restore_btn = Ext.create('Proxmox.button.Button', {
 166             text: gettext('Restore'),
 167             disabled: true,
 168             selModel: sm,
 169             enableFn: function(rec) {
 170                 return !!rec;
 171             },
 172             handler: function(b, e, rec) {
 173                 let win = Ext.create('PVE.window.Restore', {
 174                     nodename: nodename,
 175                     vmid: vmid,
 176                     volid: rec.data.volid,
 177                     volidText: PVE.Utils.render_storage_content(rec.data.volid, {}, rec),
 178                     vmtype: vmtype,
 179                 });
 180                 win.show();
 181                 win.on('destroy', reload);
 182             },
 183         });
 184
 185         var delete_btn = Ext.create('Proxmox.button.StdRemoveButton', {
 186             selModel: sm,
 187             dangerous: true,
 188             delay: 5,
 189             confirmMsg: function(rec) {
 190                 var msg = Ext.String.format(gettext('Are you sure you want to remove entry {0}'),
 191                                             "'" + rec.data.volid + "'");
 192                 msg += " " + gettext('This will permanently erase all data.');
 193
 194                 return msg;
 195             },
 196             getUrl: function(rec) {
 197                 var storage = storagesel.getValue();
 198                 return '/nodes/' + nodename + '/storage/' + storage + '/content/' + rec.data.volid;
 199             },
 200             callback: function() {
 201                 reload();
 202             },
 203         });
 204
 205         var config_btn = Ext.create('Proxmox.button.Button', {
 206             text: gettext('Show Configuration'),
 207             disabled: true,
 208             selModel: sm,
 209             enableFn: function(rec) {
 210                 return !!rec;
 211             },
 212             handler: function(b, e, rec) {
 213                 var storage = storagesel.getValue();
 214                 if (!storage) {
 215                     return;
 216                 }
 217
 218                 var win = Ext.create('PVE.window.BackupConfig', {
 219                     volume: rec.data.volid,
 220                     pveSelNode: me.pveSelNode,
 221                 });
 222
 223                 win.show();
 224             },
 225         });
 226
 227         Ext.apply(me, {
 228             selModel: sm,
 229             tbar: {
 230                 overflowHandler: 'scroller',
 231                 items: [
 232                     backup_btn,
 233                     restore_btn,
 234                     delete_btn,
 235                     '-',
 236                     config_btn,
 237                     '-',
 238                     {
 239                         xtype: 'proxmoxButton',
 240                         text: gettext('Edit Notes'),
 241                         disabled: true,
 242                         enableFn: function() {
 243                             let storageVal = storagesel.getValue();
 244                             let storage = storagesel
 245                                 .getStore()
 246                                 .findRecord('storage', storageVal, 0, false, true, true);
 247                             if (storage) {
 248                                 return storage.data.type !== 'pbs';
 249                             }
 250                             return true;
 251                         },
 252                         handler: function() {
 253                             let volid = sm.getSelection()[0].data.volid;
 254                             var storage = storagesel.getValue();
 255                             Ext.create('Proxmox.window.Edit', {
 256                                 autoLoad: true,
 257                                 width: 600,
 258                                 height: 400,
 259                                 resizable: true,
 260                                 title: gettext('Notes'),
 261                                 url: `/api2/extjs/nodes/${nodename}/storage/${storage}/content/${volid}`,
 262                                 layout: 'fit',
 263                                 items: [
 264                                     {
 265                                         xtype: 'textarea',
 266                                         layout: 'fit',
 267                                         name: 'notes',
 268                                         height: '100%',
 269                                     },
 270                                 ],
 271                                 listeners: {
 272                                     destroy: () => reload(),
 273                                 },
 274                             }).show();
 275                         },
 276                     },
 277                     '->',
 278                     storagesel,
 279                     '-',
 280                     vmidfilterCB,
 281                     storagefilter,
 282                 ],
 283             },
 284             columns: [
 285                 {
 286                     header: gettext('Name'),
 287                     flex: 2,
 288                     sortable: true,
 289                     renderer: PVE.Utils.render_storage_content,
 290                     dataIndex: 'volid',
 291                 },
 292                 {
 293                     header: gettext('Notes'),
 294                     dataIndex: 'notes',
 295                     flex: 1,
 296                     renderer: Ext.htmlEncode,
 297                 },
 298                 {
 299                     header: gettext('Date'),
 300                     width: 150,
 301                     dataIndex: 'vdate',
 302                 },
 303                 {
 304                     header: gettext('Format'),
 305                     width: 100,
 306                     dataIndex: 'format',
 307                 },
 308                 {
 309                     header: gettext('Size'),
 310                     width: 100,
 311                     renderer: Proxmox.Utils.format_size,
 312                     dataIndex: 'size',
 313                 },
 314                 {
 315                     header: gettext('VMID'),
 316                     dataIndex: 'vmid',
 317                     hidden: true,
 318                 },
 319                 {
 320                     header: gettext('Encrypted'),
 321                     dataIndex: 'encrypted',
 322                     renderer: PVE.Utils.render_backup_encryption,
 323                 },
 324                 {
 325                     header: gettext('Verify State'),
 326                     dataIndex: 'verification',
 327                     renderer: PVE.Utils.render_backup_verification,
 328                 },
 329             ],
 330         });
 331
 332         me.callParent();
 333     },
 334 });