www/manager6/lxc/CreateWizard.js

   1 /*global
   2   FileReader
   3 */
   4 /*jslint confusion: true */
   5 Ext.define('PVE.lxc.CreateWizard', {
   6     extend: 'PVE.window.Wizard',
   7
   8     loadSSHKeyFromFile: function(file) {
   9         var me = this;
  10         // ssh-keygen produces 740 bytes for an average 4096 bit rsa key, with
  11         // a user@host comment, 1420 for 8192 bits; current max is 16kbit
  12         // assume: 740*8 for max. 32kbit (5920 byte file)
  13         // round upwards to nearest nice number => 8192 bytes, leaves lots of comment space
  14         if (file.size > 8192) {
  15             Ext.Msg.alert(gettext('Error'), gettext("Invalid file size: ") + file.size);
  16             return;
  17         }
  18         var reader = new FileReader();
  19         reader.onload = function(evt) {
  20             me.sshkeyfield.setValue(evt.target.result);
  21         };
  22         reader.readAsText(file);
  23     },
  24
  25     initComponent: function() {
  26         var me = this;
  27
  28         var summarystore = Ext.create('Ext.data.Store', {
  29             model: 'KeyValue',
  30             sorters: [
  31                 {
  32                     property : 'key',
  33                     direction: 'ASC'
  34                 }
  35             ]
  36         });
  37
  38         var tmplsel = Ext.create('PVE.form.FileSelector', {
  39             name: 'ostemplate',
  40             storageContent: 'vztmpl',
  41             fieldLabel: gettext('Template'),
  42             allowBlank: false
  43         });
  44
  45         var tmplstoragesel = Ext.create('PVE.form.StorageSelector', {
  46             name: 'tmplstorage',
  47             fieldLabel: gettext('Storage'),
  48             storageContent: 'vztmpl',
  49             autoSelect: true,
  50             allowBlank: false,
  51             listeners: {
  52                 change: function(f, value) {
  53                     tmplsel.setStorage(value);
  54                 }
  55             }
  56         });
  57
  58         var rootfspanel = Ext.create('PVE.lxc.MountPointInputPanel', {
  59             title: gettext('Root Disk'),
  60             insideWizard: true,
  61             create: true,
  62             unused: false,
  63             onlineHelp: 'chapter-pct.html#_container_storage',
  64             confid: 'rootfs'
  65         });
  66
  67         var networkpanel = Ext.create('PVE.lxc.NetworkInputPanel', {
  68             title: gettext('Network'),
  69             insideWizard: true,
  70             dataCache: {},
  71             onlineHelp: 'chapter-pct.html#_container_network',
  72             create: true
  73         });
  74
  75         var passwordfield = Ext.createWidget('textfield', {
  76             inputType: 'password',
  77             name: 'password',
  78             value: '',
  79             fieldLabel: gettext('Password'),
  80             allowBlank: false,
  81             minLength: 5,
  82             change: function(f, value) {
  83                 if (!me.rendered) {
  84                     return;
  85                 }
  86                 me.down('field[name=confirmpw]').validate();
  87             }
  88         });
  89
  90         me.sshkeyfield = Ext.createWidget('textfield', {
  91             xtype: 'textfield',
  92             name: 'ssh-public-keys',
  93             value: '',
  94             fieldLabel: gettext('SSH public key'),
  95             allowBlank: true,
  96             validator: function(value) {
  97                 if (value.length) {
  98                     var key = PVE.Parser.parseSSHKey(value);
  99                     if (!key) {
 100                         return "Failed to recognize ssh key";
 101                     }
 102                     me.down('field[name=password]').allowBlank = true;
 103                 } else {
 104                     me.down('field[name=password]').allowBlank = false;
 105                 }
 106                 me.down('field[name=password]').validate();
 107                 return true;
 108             },
 109             afterRender: function() {
 110                 if (!window.FileReader) {
 111                     // No FileReader support in this browser
 112                     return;
 113                 }
 114                 var cancel = function(ev) {
 115                     ev = ev.event;
 116                     if (ev.preventDefault) {
 117                         ev.preventDefault();
 118                     }
 119                 };
 120                 me.sshkeyfield.inputEl.on('dragover', cancel);
 121                 me.sshkeyfield.inputEl.on('dragenter', cancel);
 122                 me.sshkeyfield.inputEl.on('drop', function(ev) {
 123                     ev = ev.event;
 124                     if (ev.preventDefault) {
 125                         ev.preventDefault();
 126                     }
 127                     var files = ev.dataTransfer.files;
 128                     me.loadSSHKeyFromFile(files[0]);
 129                 });
 130             }
 131         });
 132
 133         var column2 = [
 134             {
 135                 xtype: 'pvePoolSelector',
 136                 fieldLabel: gettext('Resource Pool'),
 137                 name: 'pool',
 138                 value: '',
 139                 allowBlank: true
 140             },
 141             passwordfield,
 142             {
 143                 xtype: 'textfield',
 144                 inputType: 'password',
 145                 name: 'confirmpw',
 146                 value: '',
 147                 fieldLabel: gettext('Confirm password'),
 148                 allowBlank: true,
 149                 validator: function(value) {
 150                     var pw = me.down('field[name=password]').getValue();
 151                     if (pw !== value) {
 152                         return "Passwords does not match!";
 153                     }
 154                     return true;
 155                 }
 156             },
 157             me.sshkeyfield
 158         ];
 159
 160         if (window.FileReader) {
 161             column2.push({
 162                 xtype: 'filebutton',
 163                 name: 'file',
 164                 text: gettext('Load SSH Key File'),
 165                 listeners: {
 166                     change: function(btn, e, value) {
 167                         e = e.event;
 168                         me.loadSSHKeyFromFile(e.target.files[0]);
 169                         btn.reset();
 170                     }
 171                 }
 172             });
 173         }
 174
 175         Ext.applyIf(me, {
 176             subject: gettext('LXC Container'),
 177             items: [
 178                 {
 179                     xtype: 'inputpanel',
 180                     title: gettext('General'),
 181                     column1: [
 182                         {
 183                             xtype: 'pveNodeSelector',
 184                             name: 'nodename',
 185                             selectCurNode: true,
 186                             fieldLabel: gettext('Node'),
 187                             allowBlank: false,
 188                             onlineValidator: true,
 189                             listeners: {
 190                                 change: function(f, value) {
 191                                     tmplstoragesel.setNodename(value);
 192                                     tmplsel.setStorage(undefined, value);
 193                                     networkpanel.setNodename(value);
 194                                     rootfspanel.setNodename(value);
 195                                 }
 196                             }
 197                         },
 198                         {
 199                             xtype: 'pveVMIDSelector',
 200                             name: 'vmid',
 201                             value: '',
 202                             loadNextFreeVMID: true,
 203                             validateExists: false
 204                         },
 205                         {
 206                             xtype: 'pvetextfield',
 207                             name: 'hostname',
 208                             vtype: 'DnsName',
 209                             value: '',
 210                             fieldLabel: gettext('Hostname'),
 211                             skipEmptyText: true,
 212                             allowBlank: true
 213                         }
 214                     ],
 215                     column2: column2,
 216                     onGetValues: function(values) {
 217                         delete values.confirmpw;
 218                         if (!values.pool) {
 219                             delete values.pool;
 220                         }
 221                         return values;
 222                     }
 223                 },
 224                 {
 225                     xtype: 'inputpanel',
 226                     title: gettext('Template'),
 227                     onlineHelp: 'chapter-pct.html#_container_images',
 228                     column1: [ tmplstoragesel, tmplsel]
 229                 },
 230                 rootfspanel,
 231                 {
 232                     xtype: 'pveLxcCPUInputPanel',
 233                     title: gettext('CPU'),
 234                     insideWizard: true
 235                 },
 236                 {
 237                     xtype: 'pveLxcMemoryInputPanel',
 238                     title: gettext('Memory'),
 239                     insideWizard: true
 240                 },
 241                 networkpanel,
 242                 {
 243                     xtype: 'pveLxcDNSInputPanel',
 244                     title: gettext('DNS'),
 245                     insideWizard: true
 246                 },
 247                 {
 248                     title: gettext('Confirm'),
 249                     layout: 'fit',
 250                     items: [
 251                         {
 252                             title: gettext('Settings'),
 253                             xtype: 'grid',
 254                             store: summarystore,
 255                             columns: [
 256                                 {header: 'Key', width: 150, dataIndex: 'key'},
 257                                 {header: 'Value', flex: 1, dataIndex: 'value'}
 258                             ]
 259                         }
 260                     ],
 261                     listeners: {
 262                         show: function(panel) {
 263                             var form = me.down('form').getForm();
 264                             var kv = me.getValues();
 265                             var data = [];
 266                             Ext.Object.each(kv, function(key, value) {
 267                                 if (key === 'delete' || key === 'tmplstorage') { // ignore
 268                                     return;
 269                                 }
 270                                 if (key === 'password') { // don't show pw
 271                                     return;
 272                                 }
 273                                 var html = Ext.htmlEncode(Ext.JSON.encode(value));
 274                                 data.push({ key: key, value: value });
 275                             });
 276                             summarystore.suspendEvents();
 277                             summarystore.removeAll();
 278                             summarystore.add(data);
 279                             summarystore.sort();
 280                             summarystore.resumeEvents();
 281                             summarystore.fireEvent('refresh');
 282                         }
 283                     },
 284                     onSubmit: function() {
 285                         var kv = me.getValues();
 286                         delete kv['delete'];
 287
 288                         var nodename = kv.nodename;
 289                         delete kv.nodename;
 290                         delete kv.tmplstorage;
 291
 292                         if (!kv['ssh-public-keys'].length) {
 293                             delete kv['ssh-public-keys'];
 294                         } else if (!kv.password.length) {
 295                             delete kv.password;
 296                         }
 297
 298                         PVE.Utils.API2Request({
 299                             url: '/nodes/' + nodename + '/lxc',
 300                             waitMsgTarget: me,
 301                             method: 'POST',
 302                             params: kv,
 303                             success: function(response, opts){
 304                                 var upid = response.result.data;
 305
 306                                 var win = Ext.create('PVE.window.TaskViewer', {
 307                                     upid: upid
 308                                 });
 309                                 win.show();
 310                                 me.close();
 311                             },
 312                             failure: function(response, opts) {
 313                                 Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 314                             }
 315                         });
 316                     }
 317                 }
 318             ]
 319         });
 320
 321         me.callParent();
 322     }
 323 });
 324
 325
 326