www/manager/qemu/Clone.js

   1 Ext.define('PVE.window.Clone', {
   2     extend: 'Ext.window.Window',
   3
   4     resizable: false,
   5
   6     isTemplate: false,
   7
   8     create_clone: function(values) {
   9         var me = this;
  10
  11         var params = { newid: values.newvmid };
  12
  13         if (values.snapname && values.snapname !== 'current') {
  14             params.snapname = values.snapname;
  15         }
  16
  17         if (values.pool) {
  18             params.pool = values.pool;
  19         }
  20
  21         if (values.name) {
  22             params.name = values.name;
  23         }
  24
  25         if (values.target) {
  26             params.target = values.target;
  27         }
  28
  29         if (values.clonemode === 'copy') {
  30             params.full = 1;
  31             if (values.storage) {
  32                 params.storage = values.storage;
  33                 if (values.diskformat) {
  34                     params.format = values.diskformat;
  35                 }
  36             }
  37         }
  38
  39         PVE.Utils.API2Request({
  40             params: params,
  41             url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/clone',
  42             waitMsgTarget: me,
  43             method: 'POST',
  44             failure: function(response, opts) {
  45                 Ext.Msg.alert('Error', response.htmlStatus);
  46             },
  47             success: function(response, options) {
  48                 me.close();
  49             }
  50         });
  51
  52     },
  53
  54     updateVisibility: function() {
  55         var me = this;
  56
  57         var clonemode = me.kv1.getValue();
  58         var storage = me.hdstoragesel.getValue();
  59         var rec = me.hdstoragesel.store.getById(storage);
  60
  61         me.hdstoragesel.setDisabled(clonemode === 'clone');
  62
  63         if (!rec || clonemode === 'clone') {
  64             me.formatsel.setDisabled(true);
  65             return;
  66         }
  67
  68         if (rec.data.type === 'lvm' ||
  69             rec.data.type === 'lvmthin' ||
  70             rec.data.type === 'rbd' ||
  71             rec.data.type === 'iscsi' ||
  72             rec.data.type === 'sheepdog' ||
  73             rec.data.type === 'zfs' ||
  74             rec.data.type === 'zfspool'
  75            ) {
  76             me.formatsel.setValue('raw');
  77             me.formatsel.setDisabled(true);
  78         } else {
  79             me.formatsel.setDisabled(false);
  80         }
  81     },
  82
  83     verifyFeature: function() {
  84         var me = this;
  85
  86         var snapname = me.snapshotSel.getValue();
  87         var clonemode = me.kv1.getValue();
  88
  89         var params = { feature: clonemode };
  90         if (snapname !== 'current') {
  91             params.snapname = snapname;
  92         }
  93
  94         PVE.Utils.API2Request({
  95             waitMsgTarget: me,
  96             url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/feature',
  97             params: params,
  98             method: 'GET',
  99             failure: function(response, opts) {
 100                 me.submitBtn.setDisabled(false);
 101                 Ext.Msg.alert('Error', response.htmlStatus);
 102             },
 103             success: function(response, options) {
 104                 var res = response.result.data;
 105                 me.submitBtn.setDisabled(res.hasFeature !== 1);
 106
 107                 me.targetSel.allowedNodes = res.nodes;
 108                 me.targetSel.validate();
 109             }
 110         });
 111     },
 112
 113     initComponent : function() {
 114         /*jslint confusion: true */
 115         var me = this;
 116
 117         if (!me.nodename) {
 118             throw "no node name specified";
 119         }
 120
 121         if (!me.vmid) {
 122             throw "no VM ID specified";
 123         }
 124
 125         if (!me.snapname) {
 126             me.snapname = 'current';
 127         }
 128
 129         var col1 = [];
 130         var col2 = [];
 131
 132         me.targetSel = Ext.create('PVE.form.NodeSelector', {
 133             name: 'target',
 134             fieldLabel: gettext('Target node'),
 135             selectCurNode: true,
 136             allowBlank: false,
 137             onlineValidator: true
 138         });
 139
 140         col1.push(me.targetSel);
 141
 142         var modelist = [['copy', gettext('Full Clone')]];
 143         if (me.isTemplate) {
 144             modelist.push(['clone', gettext('Linked Clone')]);
 145         }
 146
 147         me.kv1 = Ext.create('PVE.form.KVComboBox', {
 148             fieldLabel: gettext('Mode'),
 149             name: 'clonemode',
 150             allowBlank: false,
 151             value: me.isTemplate ? 'clone' : 'copy',
 152             data: modelist
 153         });
 154
 155         me.mon(me.kv1, 'change', function(t, value) {
 156             me.updateVisibility();
 157             me.verifyFeature();
 158         });
 159
 160         col2.push(me.kv1);
 161
 162         me.snapshotSel = Ext.create('PVE.form.SnapshotSelector', {
 163             name: 'snapname',
 164             fieldLabel: gettext('Snapshot'),
 165             nodename: me.nodename,
 166             vmid: me.vmid,
 167             hidden: me.isTemplate ? true : false,
 168             disabled: false,
 169             allowBlank: false,
 170             value : me.snapname,
 171             listeners: {
 172                 change: function(f, value) {
 173                     me.verifyFeature();
 174                 }
 175             }
 176         });
 177
 178         col2.push(me.snapshotSel);
 179
 180         col1.push(
 181             {
 182                 xtype: 'pveVMIDSelector',
 183                 name: 'newvmid',
 184                 value: '',
 185                 loadNextFreeVMID: true,
 186                 validateExists: false
 187             },
 188             {
 189                 xtype: 'textfield',
 190                 name: 'name',
 191                 allowBlank: true,
 192                 fieldLabel: gettext('Name')
 193             }
 194         );
 195
 196         me.hdstoragesel = Ext.create('PVE.form.StorageSelector', {
 197                 name: 'storage',
 198                 nodename: me.nodename,
 199                 fieldLabel: gettext('Target Storage'),
 200                 storageContent: 'images',
 201                 autoSelect: me.insideWizard,
 202                 allowBlank: true,
 203                 disabled: me.isTemplate ? true : false, // because default mode is clone for templates
 204                 hidden: false,
 205                 listeners: {
 206                     change: function(f, value) {
 207                         me.updateVisibility();
 208                     }
 209                 }
 210
 211         });
 212
 213         me.targetSel.on('change', function(f, value) {
 214             me.hdstoragesel.setTargetNode(value);
 215         });
 216
 217         me.formatsel = Ext.create('PVE.form.DiskFormatSelector', {
 218             name: 'diskformat',
 219             fieldLabel: gettext('Format'),
 220             value: 'raw',
 221             disabled: true,
 222             hidden: false,
 223             allowBlank: false
 224         });
 225
 226         col2.push({
 227             xtype: 'pvePoolSelector',
 228             fieldLabel: gettext('Resource Pool'),
 229             name: 'pool',
 230             value: '',
 231             allowBlank: true
 232         });
 233
 234         col2.push(me.hdstoragesel);
 235         col2.push(me.formatsel);
 236
 237         me.formPanel = Ext.create('Ext.form.Panel', {
 238             bodyPadding: 10,
 239             border: false,
 240             layout: 'column',
 241             defaultType: 'container',
 242             columns: 2,
 243             fieldDefaults: {
 244                 labelWidth: 100,
 245                 anchor: '100%'
 246             },
 247             items: [
 248                 {
 249                     columnWidth: 0.5,
 250                     padding: '0 10 0 0',
 251                     layout: 'anchor',
 252                     items: col1
 253                 },
 254                 {
 255                     columnWidth: 0.5,
 256                     padding: '0 0 0 10',
 257                     layout: 'anchor',
 258                     items: col2
 259                 }
 260             ]
 261         });
 262
 263         var form = me.formPanel.getForm();
 264
 265         var titletext = me.isTemplate ? "Template" : "VM";
 266         me.title = "Clone " + titletext + " " + me.vmid;
 267
 268         me.submitBtn = Ext.create('Ext.Button', {
 269             text: gettext('Clone'),
 270             disabled: true,
 271             handler: function() {
 272                 if (form.isValid()) {
 273                     var values = form.getValues();
 274                     me.create_clone(values);
 275                 }
 276             }
 277         });
 278
 279         Ext.apply(me, {
 280             modal: true,
 281             width: 600,
 282             height: 250,
 283             border: false,
 284             layout: 'fit',
 285             buttons: [ me.submitBtn ],
 286             items: [ me.formPanel ]
 287         });
 288
 289         me.callParent();
 290
 291         me.verifyFeature();
 292     }
 293 });