www/manager6/lxc/CreateWizard.js

   1 /*global
   2   FileReader
   3 */
   4
   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             isCreate: true,
  62             unused: false,
  63             confid: 'rootfs'
  64         });
  65
  66         var networkpanel = Ext.create('PVE.lxc.NetworkInputPanel', {
  67             title: gettext('Network'),
  68             insideWizard: true,
  69             dataCache: {},
  70             isCreate: true
  71         });
  72
  73         var passwordfield = Ext.createWidget('textfield', {
  74             inputType: 'password',
  75             name: 'password',
  76             value: '',
  77             fieldLabel: gettext('Password'),
  78             allowBlank: false,
  79             minLength: 5,
  80             change: function(f, value) {
  81                 if (!me.rendered) {
  82                     return;
  83                 }
  84                 me.down('field[name=confirmpw]').validate();
  85             }
  86         });
  87
  88         /*jslint confusion: true */
  89         /* the validator function can return either a string or a boolean */
  90         me.sshkeyfield = Ext.createWidget('pvetextfield', {
  91             name: 'ssh-public-keys',
  92             value: '',
  93             fieldLabel: gettext('SSH public key'),
  94             allowBlank: true,
  95             validator: function(value) {
  96                 if (value.length) {
  97                     var key = PVE.Parser.parseSSHKey(value);
  98                     if (!key) {
  99                         return "Failed to recognize ssh key";
 100                     }
 101                     me.down('field[name=password]').allowBlank = true;
 102                 } else {
 103                     me.down('field[name=password]').allowBlank = false;
 104                 }
 105                 me.down('field[name=password]').validate();
 106                 return true;
 107             },
 108             afterRender: function() {
 109                 if (!window.FileReader) {
 110                     // No FileReader support in this browser
 111                     return;
 112                 }
 113                 var cancel = function(ev) {
 114                     ev = ev.event;
 115                     if (ev.preventDefault) {
 116                         ev.preventDefault();
 117                     }
 118                 };
 119                 me.sshkeyfield.inputEl.on('dragover', cancel);
 120                 me.sshkeyfield.inputEl.on('dragenter', cancel);
 121                 me.sshkeyfield.inputEl.on('drop', function(ev) {
 122                     ev = ev.event;
 123                     if (ev.preventDefault) {
 124                         ev.preventDefault();
 125                     }
 126                     var files = ev.dataTransfer.files;
 127                     me.loadSSHKeyFromFile(files[0]);
 128                 });
 129             }
 130         });
 131
 132         var column2 = [
 133             {
 134                 xtype: 'pvePoolSelector',
 135                 fieldLabel: gettext('Resource Pool'),
 136                 name: 'pool',
 137                 value: '',
 138                 allowBlank: true
 139             },
 140             passwordfield,
 141             {
 142                 xtype: 'textfield',
 143                 inputType: 'password',
 144                 name: 'confirmpw',
 145                 value: '',
 146                 fieldLabel: gettext('Confirm password'),
 147                 allowBlank: true,
 148                 validator: function(value) {
 149                     var pw = me.down('field[name=password]').getValue();
 150                     if (pw !== value) {
 151                         return "Passwords does not match!";
 152                     }
 153                     return true;
 154                 }
 155             },
 156             me.sshkeyfield
 157         ];
 158         /*jslint confusion: false */
 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                     onlineHelp: 'pct_general',
 182                     column1: [
 183                         {
 184                             xtype: 'pveNodeSelector',
 185                             name: 'nodename',
 186                             selectCurNode: !me.nodename,
 187                             preferredValue: me.nodename,
 188                             fieldLabel: gettext('Node'),
 189                             allowBlank: false,
 190                             onlineValidator: true,
 191                             listeners: {
 192                                 change: function(f, value) {
 193                                     tmplstoragesel.setNodename(value);
 194                                     tmplsel.setStorage(undefined, value);
 195                                     networkpanel.setNodename(value);
 196                                     rootfspanel.setNodename(value);
 197                                 }
 198                             }
 199                         },
 200                         {
 201                             xtype: 'pveGuestIDSelector',
 202                             name: 'vmid', // backend only knows vmid
 203                             guestType: 'lxc',
 204                             value: '',
 205                             loadNextFreeID: true,
 206                             validateExists: false
 207                         },
 208                         {
 209                             xtype: 'pvetextfield',
 210                             name: 'hostname',
 211                             vtype: 'DnsName',
 212                             value: '',
 213                             fieldLabel: gettext('Hostname'),
 214                             skipEmptyText: true,
 215                             allowBlank: true
 216                         },
 217                         {
 218                             xtype: 'pvecheckbox',
 219                             name: 'unprivileged',
 220                             value: '',
 221                             fieldLabel: gettext('Unprivileged container')
 222                         }
 223                     ],
 224                     column2: column2,
 225                     onGetValues: function(values) {
 226                         delete values.confirmpw;
 227                         if (!values.pool) {
 228                             delete values.pool;
 229                         }
 230                         return values;
 231                     }
 232                 },
 233                 {
 234                     xtype: 'inputpanel',
 235                     title: gettext('Template'),
 236                     onlineHelp: 'pct_container_images',
 237                     column1: [ tmplstoragesel, tmplsel]
 238                 },
 239                 rootfspanel,
 240                 {
 241                     xtype: 'pveLxcCPUInputPanel',
 242                     title: gettext('CPU'),
 243                     insideWizard: true
 244                 },
 245                 {
 246                     xtype: 'pveLxcMemoryInputPanel',
 247                     title: gettext('Memory'),
 248                     insideWizard: true
 249                 },
 250                 networkpanel,
 251                 {
 252                     xtype: 'pveLxcDNSInputPanel',
 253                     title: gettext('DNS'),
 254                     insideWizard: true
 255                 },
 256                 {
 257                     title: gettext('Confirm'),
 258                     layout: 'fit',
 259                     items: [
 260                         {
 261                             xtype: 'grid',
 262                             store: summarystore,
 263                             columns: [
 264                                 {header: 'Key', width: 150, dataIndex: 'key'},
 265                                 {header: 'Value', flex: 1, dataIndex: 'value'}
 266                             ]
 267                         }
 268                     ],
 269                     listeners: {
 270                         show: function(panel) {
 271                             var form = me.down('form').getForm();
 272                             var kv = me.getValues();
 273                             var data = [];
 274                             Ext.Object.each(kv, function(key, value) {
 275                                 if (key === 'delete' || key === 'tmplstorage') { // ignore
 276                                     return;
 277                                 }
 278                                 if (key === 'password') { // don't show pw
 279                                     return;
 280                                 }
 281                                 var html = Ext.htmlEncode(Ext.JSON.encode(value));
 282                                 data.push({ key: key, value: value });
 283                             });
 284                             summarystore.suspendEvents();
 285                             summarystore.removeAll();
 286                             summarystore.add(data);
 287                             summarystore.sort();
 288                             summarystore.resumeEvents();
 289                             summarystore.fireEvent('refresh');
 290                         }
 291                     },
 292                     onSubmit: function() {
 293                         var kv = me.getValues();
 294                         delete kv['delete'];
 295
 296                         var nodename = kv.nodename;
 297                         delete kv.nodename;
 298                         delete kv.tmplstorage;
 299
 300                         if (!kv.password.length && kv['ssh-public-keys']) {
 301                             delete kv.password;
 302                         }
 303
 304                         PVE.Utils.API2Request({
 305                             url: '/nodes/' + nodename + '/lxc',
 306                             waitMsgTarget: me,
 307                             method: 'POST',
 308                             params: kv,
 309                             success: function(response, opts){
 310                                 var upid = response.result.data;
 311
 312                                 var win = Ext.create('PVE.window.TaskViewer', {
 313                                     upid: upid
 314                                 });
 315                                 win.show();
 316                                 me.close();
 317                             },
 318                             failure: function(response, opts) {
 319                                 Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 320                             }
 321                         });
 322                     }
 323                 }
 324             ]
 325         });
 326
 327         me.callParent();
 328     }
 329 });
 330
 331
 332