www/manager/openvz/CreateWizard.js

   1 /*jslint confusion: true */
   2 Ext.define('PVE.openvz.CreateWizard', {
   3     extend: 'PVE.window.Wizard',
   4
   5     initComponent: function() {
   6         var me = this;
   7
   8         var nextvmid = PVE.data.ResourceStore.findNextVMID();
   9
  10         var summarystore = Ext.create('Ext.data.Store', {
  11             model: 'KeyValue',
  12             sorters: [
  13                 {
  14                     property : 'key',
  15                     direction: 'ASC'
  16                 }
  17             ]
  18         });
  19
  20         var storagesel = Ext.create('PVE.form.StorageSelector', {
  21             name: 'storage',
  22             fieldLabel: gettext('Storage'),
  23             storageContent: 'rootdir',
  24             autoSelect: true,
  25             allowBlank: false
  26         });
  27
  28         var tmplsel = Ext.create('PVE.form.FileSelector', {
  29             name: 'ostemplate',
  30             storageContent: 'vztmpl',
  31             fieldLabel: gettext('Template'),
  32             allowBlank: false
  33         });
  34
  35         var tmplstoragesel = Ext.create('PVE.form.StorageSelector', {
  36             name: 'tmplstorage',
  37             fieldLabel: gettext('Storage'),
  38             storageContent: 'vztmpl',
  39             autoSelect: true,
  40             allowBlank: false,
  41             listeners: {
  42                 change: function(f, value) {
  43                     tmplsel.setStorage(value);
  44                 }
  45             }
  46         });
  47
  48         var bridgesel = Ext.create('PVE.form.BridgeSelector', {
  49             name: 'bridge',
  50             fieldLabel: 'Bridge',
  51             labelAlign: 'right',
  52             autoSelect: true,
  53             disabled: true,
  54             allowBlank: false
  55         });
  56
  57         Ext.applyIf(me, {
  58             subject: gettext('OpenVZ Container'),
  59             items: [
  60                 {
  61                     xtype: 'inputpanel',
  62                     title: gettext('General'),
  63                     column1: [
  64                         {
  65                             xtype: 'PVE.form.NodeSelector',
  66                             name: 'nodename',
  67                             fieldLabel: gettext('Node'),
  68                             allowBlank: false,
  69                             onlineValidator: true,
  70                             listeners: {
  71                                 change: function(f, value) {
  72                                     tmplstoragesel.setNodename(value);
  73                                     tmplsel.setStorage(undefined, value);
  74                                     bridgesel.setNodename(value);
  75                                     storagesel.setNodename(value);
  76                                 }
  77                             }
  78                         },
  79                         {
  80                             xtype: 'pveVMIDSelector',
  81                             name: 'vmid',
  82                             value: nextvmid,
  83                             validateExists: false
  84                         },
  85                         {
  86                             xtype: 'pvetextfield',
  87                             name: 'hostname',
  88                             value: '',
  89                             fieldLabel: 'Hostname',
  90                             skipEmptyText: true,
  91                             allowBlank: true
  92                         }
  93                     ],
  94                     column2: [
  95                         {
  96                             xtype: 'pvePoolSelector',
  97                             fieldLabel: gettext('Resource Pool'),
  98                             name: 'pool',
  99                             value: '',
 100                             allowBlank: true
 101                         },
 102                         storagesel,
 103                         {
 104                             xtype: 'textfield',
 105                             inputType: 'password',
 106                             name: 'password',
 107                             value: '',
 108                             fieldLabel: gettext('Password'),
 109                             allowBlank: false,
 110                             minLength: 5,
 111                             change: function(f, value) {
 112                                 if (!me.rendered) {
 113                                     return;
 114                                 }
 115                                 me.down('field[name=confirmpw]').validate();
 116                             }
 117                         },
 118                         {
 119                             xtype: 'textfield',
 120                             inputType: 'password',
 121                             name: 'confirmpw',
 122                             value: '',
 123                             fieldLabel: gettext('Confirm password'),
 124                             allowBlank: false,
 125                             validator: function(value) {
 126                                 var pw = me.down('field[name=password]').getValue();
 127                                 if (pw !== value) {
 128                                     return "Passowords does not match!";
 129                                 }
 130                                 return true;
 131                             }
 132                         }
 133                     ],
 134                     onGetValues: function(values) {
 135                         delete values.confirmpw;
 136                         if (!values.pool) {
 137                             delete values.pool;
 138                         }
 139                         return values;
 140                     }
 141                 },
 142                 {
 143                     xtype: 'inputpanel',
 144                     title: gettext('Template'),
 145                     column1: [ tmplstoragesel, tmplsel]
 146                 },
 147                 {
 148                     xtype: 'pveOpenVZResourceInputPanel',
 149                     title: gettext('Resources')
 150                 },
 151                 {
 152                     xtype: 'inputpanel',
 153                     title: gettext('Network'),
 154                     column1: [
 155                         {
 156                             xtype: 'radiofield',
 157                             name: 'networkmode',
 158                             inputValue: 'routed',
 159                             boxLabel: 'Routed mode (venet)',
 160                             checked: true,
 161                             listeners: {
 162                                 change: function(f, value) {
 163                                     if (!me.rendered) {
 164                                         return;
 165                                     }
 166                                     me.down('field[name=ip_address]').setDisabled(!value);
 167                                     me.down('field[name=ip_address]').validate();
 168                                 }
 169                             }
 170                         },
 171                         {
 172                             xtype: 'textfield',
 173                             name: 'ip_address',
 174                             vtype: 'IPAddress',
 175                             value: '',
 176                             fieldLabel: gettext('IP address'),
 177                             labelAlign: 'right',
 178                             allowBlank: false
 179                         }
 180                     ],
 181                     column2: [
 182                         {
 183                             xtype: 'radiofield',
 184                             name: 'networkmode',
 185                             inputValue: 'bridge',
 186                             boxLabel: 'Bridged mode',
 187                             checked: false,
 188                             listeners: {
 189                                 change: function(f, value) {
 190                                     if (!me.rendered) {
 191                                         return;
 192                                     }
 193                                     me.down('field[name=bridge]').setDisabled(!value);
 194                                     me.down('field[name=bridge]').validate();
 195                                 }
 196                             }
 197                         },
 198                         bridgesel
 199                     ],
 200                     onGetValues: function(values) {
 201                         if (values.networkmode === 'bridge') {
 202                             return { netif: 'ifname=eth0,bridge=' + values.bridge };
 203                         } else {
 204                             return { ip_address: values.ip_address };
 205                         }
 206                     }
 207                 },
 208                 {
 209                     xtype: 'inputpanel',
 210                     title: 'DNS',
 211                     column1: [
 212                         {
 213                             xtype: 'pvetextfield',
 214                             name: 'searchdomain',
 215                             skipEmptyText: true,
 216                             fieldLabel: 'DNS domain',
 217                             emptyText: 'use host settings',
 218                             allowBlank: true,
 219                             listeners: {
 220                                 change: function(f, value) {
 221                                     if (!me.rendered) {
 222                                         return;
 223                                     }
 224                                     var field = me.down('#dns1');
 225                                     field.setDisabled(!value);
 226                                     field.clearInvalid();
 227                                     field = me.down('#dns2');
 228                                     field.setDisabled(!value);
 229                                     field.clearInvalid();
 230                                 }
 231                             }
 232                         },
 233                         {
 234                             xtype: 'pvetextfield',
 235                             fieldLabel: gettext('DNS server') + " 1",
 236                             vtype: 'IPAddress',
 237                             allowBlank: true,
 238                             disabled: true,
 239                             name: 'nameserver',
 240                             itemId: 'dns1'
 241                         },
 242                         {
 243                             xtype: 'pvetextfield',
 244                             fieldLabel: gettext('DNS server') + " 2",
 245                             vtype: 'IPAddress',
 246                             skipEmptyText: true,
 247                             disabled: true,
 248                             name: 'nameserver',
 249                             itemId: 'dns2'
 250                         }
 251                     ]
 252                 },
 253                 {
 254                     title: gettext('Confirm'),
 255                     layout: 'fit',
 256                     items: [
 257                         {
 258                             title: gettext('Settings'),
 259                             xtype: 'grid',
 260                             store: summarystore,
 261                             columns: [
 262                                 {header: 'Key', width: 150, dataIndex: 'key'},
 263                                 {header: 'Value', flex: 1, dataIndex: 'value'}
 264                             ]
 265                         }
 266                     ],
 267                     listeners: {
 268                         show: function(panel) {
 269                             var form = me.down('form').getForm();
 270                             var kv = me.getValues();
 271                             var data = [];
 272                             Ext.Object.each(kv, function(key, value) {
 273                                 if (key === 'delete' || key === 'tmplstorage') { // ignore
 274                                     return;
 275                                 }
 276                                 if (key === 'password') { // don't show pw
 277                                     return;
 278                                 }
 279                                 var html = Ext.htmlEncode(Ext.JSON.encode(value));
 280                                 data.push({ key: key, value: value });
 281                             });
 282                             summarystore.suspendEvents();
 283                             summarystore.removeAll();
 284                             summarystore.add(data);
 285                             summarystore.sort();
 286                             summarystore.resumeEvents();
 287                             summarystore.fireEvent('datachanged', summarystore);
 288                         }
 289                     },
 290                     onSubmit: function() {
 291                         var kv = me.getValues();
 292                         delete kv['delete'];
 293
 294                         var nodename = kv.nodename;
 295                         delete kv.nodename;
 296                         delete kv.tmplstorage;
 297
 298                         PVE.Utils.API2Request({
 299                             url: '/nodes/' + nodename + '/openvz',
 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