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