www/manager6/lxc/CreateWizard.js

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