js/PBSSnapshotView.js

   1 Ext.define('PMG.PBSConfig', {
   2     extend: 'Ext.panel.Panel',
   3     xtype: 'pmgPBSConfig',
   4
   5     controller: {
   6         xclass: 'Ext.app.ViewController',
   7
   8         callRestore: function(grid, record) {
   9             let remote = this.getViewModel().get('remote');
  10             Ext.create('PMG.RestoreWindow', {
  11                 remote: remote,
  12                 backup_id: record.data['backup-id'],
  13                 backup_time: record.data['backup-time'],
  14             }).show();
  15         },
  16
  17         restoreSnapshot: function(button) {
  18             let me = this;
  19             let view = me.lookup('snapshotsGrid');
  20             let record = view.getSelection()[0];
  21             me.callRestore(view, record);
  22         },
  23
  24         runBackup: function(button) {
  25             let me = this;
  26             let view = me.lookup('snapshotsGrid');
  27             let remote = me.getViewModel().get('remote');
  28             Proxmox.Utils.API2Request({
  29                 url: `/nodes/${Proxmox.NodeName}/pbs/${remote}/snapshot`,
  30                 method: 'POST',
  31                 waitMsgTarget: view,
  32                 failure: function(response, opts) {
  33                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
  34                 },
  35                 success: function(response, opts) {
  36                     let upid = response.result.data;
  37
  38                     let win = Ext.create('Proxmox.window.TaskViewer', {
  39                         upid: upid,
  40                     });
  41                     win.show();
  42                     me.mon(win, 'close', function() { view.getStore().load(); });
  43                 },
  44             });
  45         },
  46
  47         reload: function(grid) {
  48             let me = this;
  49             let selection = grid.getSelection();
  50             me.showInfo(grid, selection);
  51         },
  52
  53         showInfo: function(grid, selected) {
  54             let me = this;
  55             let viewModel = me.getViewModel();
  56             if (selected[0]) {
  57                 let remote = selected[0].data.remote;
  58                 viewModel.set('selected', true);
  59                 viewModel.set('remote', remote);
  60
  61                 // set grid stores and load them
  62                 let remstore = me.lookup('snapshotsGrid').getStore();
  63                 remstore
  64                     .getProxy()
  65                     .setUrl(`/api2/json/nodes/${Proxmox.NodeName}/pbs/${remote}/snapshot`);
  66                 remstore.load();
  67
  68                 let scheduleStore = me.lookup('schedulegrid').rstore;
  69                 scheduleStore
  70                     .getProxy()
  71                     .setUrl(`/api2/json/nodes/${Proxmox.NodeName}/pbs/${remote}/timer`);
  72                 scheduleStore.load();
  73             } else {
  74                 viewModel.set('selected', false);
  75             }
  76         },
  77         reloadSnapshots: function() {
  78             let me = this;
  79             let grid = me.lookup('grid');
  80             let selection = grid.getSelection();
  81             me.showInfo(grid, selection);
  82         },
  83         init: function(view) {
  84             let me = this;
  85             me.lookup('grid').relayEvents(view, ['activate']);
  86
  87             let remoteGrid = me.lookup('grid');
  88             view.mon(remoteGrid.store, 'load', function(store, r, success, o) {
  89                 if (success) {
  90                     remoteGrid.getSelectionModel().select(0);
  91                 }
  92             });
  93
  94             let snapshotGrid = me.lookup('snapshotsGrid');
  95             let schedulegrid = me.lookup('schedulegrid');
  96
  97             Proxmox.Utils.monStoreErrors(snapshotGrid, snapshotGrid.getStore(), true);
  98             Proxmox.Utils.monStoreErrors(schedulegrid, schedulegrid.getStore(), true);
  99         },
 100
 101         control: {
 102             'grid[reference=grid]': {
 103                 selectionchange: 'showInfo',
 104                 load: 'reload',
 105             },
 106             'grid[reference=snapshotsGrid]': {
 107                 itemdblclick: 'restoreSnapshot',
 108             },
 109         },
 110     },
 111
 112     viewModel: {
 113         data: {
 114             remote: '',
 115             selected: false,
 116         },
 117     },
 118
 119     layout: 'border',
 120
 121     items: [
 122         {
 123             xtype: 'pmgPBSConfigGrid',
 124             reference: 'grid',
 125             title: gettext('Remote'),
 126             hidden: false,
 127             region: 'center',
 128             minHeight: 130,
 129             border: false,
 130         },
 131         {
 132             xtype: 'proxmoxObjectGrid',
 133             region: 'south',
 134             reference: 'schedulegrid',
 135             title: gettext('Schedule'),
 136             height: 155,
 137             border: false,
 138             hidden: true,
 139             emptyText: gettext('No schedule setup.'),
 140             tbar: [
 141                 {
 142                     text: gettext('Set Schedule'),
 143                     handler: function() {
 144                         let me = this;
 145                         let remote = me.lookupViewModel().get('remote');
 146                         let win = Ext.createWidget('pmgPBSScheduleEdit', {
 147                             remote: remote,
 148                             autoShow: true,
 149                         });
 150                         win.on('destroy', () => me.up('grid').rstore.load());
 151                     },
 152                 },
 153                 {
 154                     xtype: 'proxmoxStdRemoveButton',
 155                     baseurl: `/nodes/${Proxmox.NodeName}/pbs/`,
 156                     callback: function() {
 157                         this.up('grid').rstore.load();
 158                     },
 159                     text: gettext('Remove Schedule'),
 160                     selModel: false,
 161                     confirmMsg: function(_rec) {
 162                         let me = this;
 163                         let remote = me.lookupViewModel().get('remote');
 164                         return Ext.String.format(
 165                             gettext('Are you sure you want to remove the schedule for {0}'),
 166                             `'${remote}'`,
 167                         );
 168                     },
 169                     getUrl: function(_rec) {
 170                         let remote = this.lookupViewModel().get('remote');
 171                         return `${this.baseurl}/${remote}/timer`;
 172                     },
 173                 },
 174                 '->',
 175                 {
 176                     text: gettext('Reload'),
 177                     iconCls: 'fa fa-refresh',
 178                     handler: function() {
 179                         this.up('grid').rstore.load();
 180                     },
 181                 },
 182             ],
 183             bind: {
 184                 title: Ext.String.format(gettext("Schedule on '{0}'"), '{remote}'),
 185                 hidden: '{!selected}',
 186             },
 187             url: '/', // hack, obj. grid is a bit dumb..
 188             rows: {
 189                 schedule: {
 190                     text: gettext('Schedule'),
 191                     required: true,
 192                     defaultValue: gettext('None'),
 193                 },
 194                 delay: {
 195                     text: gettext('Delay'),
 196                 },
 197                 'next-run': {
 198                     text: gettext('Next Run'),
 199                 },
 200             },
 201         },
 202         {
 203             xtype: 'grid',
 204             region: 'south',
 205             reference: 'snapshotsGrid',
 206             height: '50%',
 207             border: false,
 208             split: true,
 209             hidden: true,
 210             emptyText: gettext('No backups on remote'),
 211             tbar: [
 212                 {
 213                     text: gettext('Backup'),
 214                     handler: 'runBackup',
 215                 },
 216                 {
 217                     xtype: 'proxmoxButton',
 218                     text: gettext('Restore'),
 219                     handler: 'restoreSnapshot',
 220                     disabled: true,
 221                 },
 222                 {
 223                     xtype: 'proxmoxStdRemoveButton',
 224                     text: gettext('Forget Snapshot'),
 225                     disabled: true,
 226                     getUrl: function(rec) {
 227                         let me = this;
 228                         let remote = me.lookupViewModel().get('remote');
 229                         let snapshot = `${rec.data['backup-id']}/${rec.data['backup-time']}`;
 230                         return `/nodes/${Proxmox.NodeName}/pbs/${remote}/snapshot/${snapshot}`;
 231                     },
 232                     confirmMsg: function(rec) {
 233                         let me = this;
 234                         let snapshot = `${rec.data['backup-id']}/${rec.data['backup-time']}`;
 235                         return Ext.String.format(
 236                             gettext('Are you sure you want to forget snapshot {0}'),
 237                             `'${snapshot}'`,
 238                         );
 239                     },
 240                     callback: 'reloadSnapshots',
 241                 },
 242                 '->',
 243                 {
 244                     text: gettext('Reload'),
 245                     iconCls: 'fa fa-refresh',
 246                     handler: function() {
 247                         this.up('grid').store.load();
 248                     },
 249                 },
 250             ],
 251             store: {
 252                 fields: ['backup-id', 'backup-time', 'size', 'ctime', 'encrypted'],
 253                 proxy: { type: 'proxmox' },
 254                 sorters: [
 255                     {
 256                         property: 'backup-time',
 257                         direction: 'DESC',
 258                     },
 259                 ],
 260             },
 261             bind: {
 262                 title: Ext.String.format(
 263                     gettext("Backup snapshots on '{0}'"),
 264                     '{remote}',
 265                 ),
 266                 hidden: '{!selected}',
 267             },
 268             columns: [
 269                 {
 270                     text: 'Group ID',
 271                     dataIndex: 'backup-id',
 272                     flex: 1,
 273                 },
 274                 {
 275                     text: 'Time',
 276                     dataIndex: 'backup-time',
 277                     width: 180,
 278                 },
 279                 {
 280                     text: 'Size',
 281                     dataIndex: 'size',
 282                     renderer: Proxmox.Utils.format_size,
 283                     flex: 1,
 284                 },
 285                 {
 286                     text: 'Encrypted',
 287                     dataIndex: 'encrypted',
 288                     hidden: true, // FIXME: actually return from API
 289                     renderer: Proxmox.Utils.format_boolean,
 290                     flex: 1,
 291                 },
 292             ],
 293         },
 294     ],
 295
 296 });