www/manager6/lxc/CreateWizard.js

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