www/manager6/window/Migrate.js

   1 Ext.define('PVE.window.Migrate', {
   2     extend: 'Ext.window.Window',
   3
   4     vmtype: undefined,
   5     nodename: undefined,
   6     vmid: undefined,
   7     maxHeight: 450,
   8
   9     viewModel: {
  10         data: {
  11             vmid: undefined,
  12             nodename: undefined,
  13             vmtype: undefined,
  14             running: false,
  15             qemu: {
  16                 onlineHelp: 'qm_migration',
  17                 commonName: 'VM'
  18             },
  19             lxc: {
  20                 onlineHelp: 'pct_migration',
  21                 commonName: 'CT'
  22             },
  23             migration: {
  24                 possible: true,
  25                 preconditions: [],
  26                 'with-local-disks': 0,
  27                 mode: undefined,
  28                 allowedNodes: undefined,
  29                 overwriteLocalResourceCheck: false,
  30                 hasLocalResources: false
  31             }
  32
  33         },
  34
  35         formulas: {
  36             setMigrationMode: function(get) {
  37                 if (get('running')){
  38                     if (get('vmtype') === 'qemu') {
  39                         return gettext('Online');
  40                     } else {
  41                         return gettext('Restart Mode');
  42                     }
  43                 } else {
  44                     return gettext('Offline');
  45                 }
  46             },
  47             setStorageselectorHidden: function(get) {
  48                     if (get('migration.with-local-disks') && get('running')) {
  49                         return false;
  50                     } else {
  51                         return true;
  52                     }
  53             },
  54             setLocalResourceCheckboxHidden: function(get) {
  55                 if (get('running') || !get('migration.hasLocalResources') ||
  56                     Proxmox.UserName !== 'root@pam') {
  57                     return true;
  58                 } else {
  59                     return false;
  60                 }
  61             }
  62         }
  63     },
  64
  65     controller: {
  66         xclass: 'Ext.app.ViewController',
  67         control: {
  68             'panel[reference=formPanel]': {
  69                 validityChange: function(panel, isValid) {
  70                     this.getViewModel().set('migration.possible', isValid);
  71                     this.checkMigratePreconditions();
  72                 }
  73             }
  74         },
  75
  76         init: function(view) {
  77             var me = this,
  78                 vm = view.getViewModel();
  79
  80             if (!view.nodename) {
  81                 throw "missing custom view config: nodename";
  82             }
  83             vm.set('nodename', view.nodename);
  84
  85             if (!view.vmid) {
  86                 throw "missing custom view config: vmid";
  87             }
  88             vm.set('vmid', view.vmid);
  89
  90             if (!view.vmtype) {
  91                 throw "missing custom view config: vmtype";
  92             }
  93             vm.set('vmtype', view.vmtype);
  94
  95
  96             view.setTitle(
  97                 Ext.String.format('{0} {1} {2}', gettext('Migrate'), vm.get(view.vmtype).commonName, view.vmid)
  98             );
  99             me.lookup('proxmoxHelpButton').setHelpConfig({
 100                 onlineHelp: vm.get(view.vmtype).onlineHelp
 101             });
 102             me.checkMigratePreconditions();
 103             me.lookup('formPanel').isValid();
 104
 105         },
 106
 107         onTargetChange: function (nodeSelector) {
 108             //Always display the storages of the currently seleceted migration target
 109             this.lookup('pveDiskStorageSelector').setNodename(nodeSelector.value);
 110             this.checkMigratePreconditions();
 111         },
 112
 113         startMigration: function() {
 114             var me = this,
 115                 view = me.getView(),
 116                 vm = me.getViewModel();
 117
 118             var values = me.lookup('formPanel').getValues();
 119             var params = {
 120                 target: values.target
 121             };
 122
 123             if (vm.get('migration.mode')) {
 124                 params[vm.get('migration.mode')] = 1;
 125             }
 126             if (vm.get('migration.with-local-disks')) {
 127                 params['with-local-disks'] = 1;
 128             }
 129             //offline migration to a different storage currently might fail at a late stage
 130             //(i.e. after some disks have been moved), so don't expose it yet in the GUI
 131             if (vm.get('migration.with-local-disks') && vm.get('running') && values.targetstorage) {
 132                 params.targetstorage = values.targetstorage;
 133             }
 134
 135             if (vm.get('migration.overwriteLocalResourceCheck')) {
 136                 params['force'] = 1;
 137             }
 138
 139             Proxmox.Utils.API2Request({
 140                 params: params,
 141                 url: '/nodes/' + vm.get('nodename') + '/' + vm.get('vmtype') + '/' + vm.get('vmid') + '/migrate',
 142                 waitMsgTarget: view,
 143                 method: 'POST',
 144                 failure: function(response, opts) {
 145                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 146                 },
 147                 success: function(response, options) {
 148                     var upid = response.result.data;
 149                     var extraTitle = Ext.String.format(' ({0} ---> {1})', vm.get('nodename'), params.target);
 150
 151                     Ext.create('Proxmox.window.TaskViewer', {
 152                         upid: upid,
 153                         extraTitle: extraTitle
 154                     }).show();
 155
 156                     view.close();
 157                 }
 158             });
 159
 160         },
 161
 162         checkMigratePreconditions: function(resetMigrationPossible) {
 163             var me = this,
 164                 vm = me.getViewModel();
 165
 166             var vmrec = PVE.data.ResourceStore.findRecord('vmid', vm.get('vmid'),
 167                         0, false, false, true);
 168             if (vmrec && vmrec.data && vmrec.data.running) {
 169                 vm.set('running', true);
 170             }
 171
 172             if (vm.get('vmtype') === 'qemu') {
 173                 me.checkQemuPreconditions(resetMigrationPossible);
 174             } else {
 175                 me.checkLxcPreconditions(resetMigrationPossible);
 176             }
 177             me.lookup('pveNodeSelector').disallowedNodes = [vm.get('nodename')];
 178
 179             // Only allow nodes where the local storage is available in case of offline migration
 180             // where storage migration is not possible
 181             me.lookup('pveNodeSelector').allowedNodes = vm.get('migration.allowedNodes');
 182
 183             me.lookup('formPanel').isValid();
 184
 185         },
 186
 187         checkQemuPreconditions: function(resetMigrationPossible) {
 188             var me = this,
 189                 vm = me.getViewModel(),
 190                 migrateStats;
 191
 192             if (vm.get('running')) {
 193                 vm.set('migration.mode', 'online');
 194             }
 195
 196             Proxmox.Utils.API2Request({
 197                 url: '/nodes/' + vm.get('nodename') + '/' + vm.get('vmtype') + '/' + vm.get('vmid') + '/migrate',
 198                 method: 'GET',
 199                 failure: function(response, opts) {
 200                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 201                 },
 202                 success: function(response, options) {
 203                     migrateStats = response.result.data;
 204                     if (migrateStats.running) {
 205                         vm.set('running', true);
 206                     }
 207                     // Get migration object from viewmodel to prevent
 208                     // to many bind callbacks
 209                     var migration = vm.get('migration');
 210                     if (resetMigrationPossible) migration.possible = true;
 211                     migration.preconditions = [];
 212
 213                     if (migrateStats.allowed_nodes) {
 214                         migration.allowedNodes = migrateStats.allowed_nodes;
 215                         var target = me.lookup('pveNodeSelector').value;
 216                         if (target.length && !migrateStats.allowed_nodes.includes(target)) {
 217                             let disallowed = migrateStats.not_allowed_nodes[target];
 218                             let missing_storages = disallowed.unavailable_storages.join(', ');
 219
 220                             migration.possible = false;
 221                             migration.preconditions.push({
 222                                 text: 'Storage (' + missing_storages + ') not available on selected target. ' +
 223                                   'Start VM to use live storage migration or select other target node',
 224                                 severity: 'error'
 225                             });
 226                         }
 227                     }
 228
 229                     if (migrateStats.local_resources.length) {
 230                         migration.hasLocalResources = true;
 231                         if(!migration.overwriteLocalResourceCheck || vm.get('running')){
 232                             migration.possible = false;
 233                             migration.preconditions.push({
 234                                 text: Ext.String.format('Can\'t migrate VM with local resources: {0}',
 235                                 migrateStats.local_resources.join(', ')),
 236                                 severity: 'error'
 237                             });
 238                         } else {
 239                             migration.preconditions.push({
 240                                 text: Ext.String.format('Migrate VM with local resources: {0}. ' +
 241                                 'This might fail if resources aren\'t available on the target node.',
 242                                 migrateStats.local_resources.join(', ')),
 243                                 severity: 'warning'
 244                             });
 245                         }
 246                     }
 247
 248                     if (migrateStats.local_disks.length) {
 249
 250                         migrateStats.local_disks.forEach(function (disk) {
 251                             if (disk.cdrom && disk.cdrom === 1) {
 252                                 if (disk.volid.includes('vm-'+vm.get('vmid')+'-cloudinit')) {
 253                                     if (migrateStats.running) {
 254                                         migration.possible = false;
 255                                         migration.preconditions.push({
 256                                              text: "Can't live migrate VM with local cloudinit disk, use shared storage instead",
 257                                              severity: 'error'
 258                                         });
 259                                     } else {
 260                                         return;
 261                                     }
 262                                 } else {
 263                                     migration.possible = false;
 264                                     migration.preconditions.push({
 265                                         text: "Can't migrate VM with local CD/DVD",
 266                                         severity: 'error'
 267                                     });
 268                                 }
 269                             } else {
 270                                 var size_string = disk.size ? '(' + PVE.Utils.render_size(disk.size) + ')' : '';
 271                                 migration['with-local-disks'] = 1;
 272                                 migration.preconditions.push({
 273                                     text: Ext.String.format('Migration with local disk might take long: {0} {1}',
 274                                           disk.volid, size_string),
 275                                     severity: 'warning'
 276                                 });
 277                             }
 278                         });
 279
 280                     }
 281
 282                     vm.set('migration', migration);
 283
 284                 }
 285             });
 286         },
 287         checkLxcPreconditions: function(resetMigrationPossible) {
 288             var me = this,
 289                 vm = me.getViewModel();
 290             if (vm.get('running')) {
 291                 vm.set('migration.mode', 'restart');
 292             }
 293         }
 294
 295
 296     },
 297
 298     width: 600,
 299     modal: true,
 300     layout: {
 301         type: 'vbox',
 302         align: 'stretch'
 303     },
 304     border: false,
 305     items: [
 306         {
 307             xtype: 'form',
 308             reference: 'formPanel',
 309             bodyPadding: 10,
 310             border: false,
 311             layout: 'hbox',
 312             items: [
 313                 {
 314                     xtype: 'container',
 315                     flex: 1,
 316                     items: [{
 317                         xtype: 'displayfield',
 318                         name: 'source',
 319                         fieldLabel: gettext('Source node'),
 320                         bind: {
 321                             value: '{nodename}'
 322                         }
 323                     },
 324                     {
 325                         xtype: 'displayfield',
 326                         reference: 'migrationMode',
 327                         fieldLabel: gettext('Mode'),
 328                         bind: {
 329                             value: '{setMigrationMode}'
 330                         }
 331                     }]
 332                 },
 333                 {
 334                     xtype: 'container',
 335                     flex: 1,
 336                     items: [{
 337                         xtype: 'pveNodeSelector',
 338                         reference: 'pveNodeSelector',
 339                         name: 'target',
 340                         fieldLabel: gettext('Target node'),
 341                         allowBlank: false,
 342                         disallowedNodes: undefined,
 343                         onlineValidator: true,
 344                         listeners: {
 345                             change: 'onTargetChange'
 346                         }
 347                     },
 348                     {
 349                             xtype: 'pveStorageSelector',
 350                             reference: 'pveDiskStorageSelector',
 351                             name: 'targetstorage',
 352                             fieldLabel: gettext('Target storage'),
 353                             storageContent: 'images',
 354                             allowBlank: true,
 355                             autoSelect: false,
 356                             emptyText: gettext('Current layout'),
 357                             bind: {
 358                                 hidden: '{setStorageselectorHidden}'
 359                             }
 360                     },
 361                     {
 362                         xtype: 'proxmoxcheckbox',
 363                         name: 'overwriteLocalResourceCheck',
 364                         fieldLabel: gettext('Force'),
 365                         autoEl: {
 366                             tag: 'div',
 367                             'data-qtip': 'Overwrite local resources unavailable check'
 368                         },
 369                         bind: {
 370                             hidden: '{setLocalResourceCheckboxHidden}',
 371                             value: '{migration.overwriteLocalResourceCheck}'
 372                         },
 373                         listeners: {
 374                             change: {fn: 'checkMigratePreconditions', extraArg: true}
 375                         }
 376                 }]
 377                 }
 378             ]
 379         },
 380         {
 381             xtype: 'gridpanel',
 382             reference: 'preconditionGrid',
 383             selectable: false,
 384             flex: 1,
 385             columns: [{
 386                 text: '',
 387                 dataIndex: 'severity',
 388                 renderer: function(v) {
 389                     switch (v) {
 390                         case 'warning':
 391                             return '<i class="fa fa-exclamation-triangle warning"></i> ';
 392                         case 'error':
 393                             return '<i class="fa fa-times critical"></i>';
 394                         default:
 395                             return v;
 396                     }
 397                 },
 398                 width: 35
 399             },
 400             {
 401                 text: 'Info',
 402                 dataIndex: 'text',
 403                 cellWrap: true,
 404                 flex: 1
 405             }],
 406             bind: {
 407                 hidden: '{!migration.preconditions.length}',
 408                 store: {
 409                     fields: ['severity', 'text'],
 410                     data: '{migration.preconditions}',
 411                     sorters: 'text',
 412                 }
 413             }
 414         }
 415
 416     ],
 417     buttons: [
 418         {
 419             xtype: 'proxmoxHelpButton',
 420             reference: 'proxmoxHelpButton',
 421             onlineHelp: 'pct_migration',
 422             listenToGlobalEvent: false,
 423             hidden: false
 424         },
 425         '->',
 426         {
 427             xtype: 'button',
 428             reference: 'submitButton',
 429             text: gettext('Migrate'),
 430             handler: 'startMigration',
 431             bind: {
 432                 disabled: '{!migration.possible}'
 433             }
 434         }
 435     ]
 436 });