www/manager/lxc/Options.js

   1 /*jslint confusion: true */
   2 Ext.define('PVE.lxc.Options', {
   3     extend: 'PVE.grid.ObjectGrid',
   4     alias: ['widget.pveLxcOptions'],
   5
   6     initComponent : function() {
   7         var me = this;
   8         var i;
   9
  10         var nodename = me.pveSelNode.data.node;
  11         if (!nodename) {
  12             throw "no node name specified";
  13         }
  14
  15         var vmid = me.pveSelNode.data.vmid;
  16         if (!vmid) {
  17             throw "no VM ID specified";
  18         }
  19
  20         var caps = Ext.state.Manager.get('GuiCap');
  21
  22         var rows = {
  23             onboot: {
  24                 header: gettext('Start at boot'),
  25                 defaultValue: '',
  26                 renderer: PVE.Utils.format_boolean,
  27                 editor: caps.vms['VM.Config.Options'] ? {
  28                     xtype: 'pveWindowEdit',
  29                     subject: gettext('Start at boot'),
  30                     items: {
  31                         xtype: 'pvecheckbox',
  32                         name: 'onboot',
  33                         uncheckedValue: 0,
  34                         defaultValue: 0,
  35                         fieldLabel: gettext('Start at boot')
  36                     }
  37                 } : undefined
  38             },
  39             startup: {
  40                 header: gettext('Start/Shutdown order'),
  41                 defaultValue: '',
  42                 renderer: PVE.Utils.render_kvm_startup,
  43                 editor: caps.vms['VM.Config.Options'] && caps.nodes['Sys.Modify'] ?
  44                     'PVE.qemu.StartupEdit' : undefined
  45             },
  46             ostype: {
  47                 header: gettext('OS Type'),
  48                 defaultValue: PVE.Utils.unknownText
  49             },
  50             arch: {
  51                 header: gettext('Architecture'),
  52                 defaultValue: PVE.Utils.unknownText
  53             },
  54             console: {
  55                 header: gettext('Enable /dev/console'),
  56                 defaultValue: 1,
  57                 renderer: PVE.Utils.format_boolean,
  58                 editor: caps.vms['VM.Config.Options'] ? {
  59                     xtype: 'pveWindowEdit',
  60                     subject: gettext('Enable /dev/console'),
  61                     items: {
  62                         xtype: 'pvecheckbox',
  63                         name: 'console',
  64                         uncheckedValue: 0,
  65                         defaultValue: 1,
  66                         deleteDefaultValue: true,
  67                         checked: true,
  68                         fieldLabel: gettext('Enable /dev/console')
  69                     }
  70                 } : undefined
  71             },
  72             tty: {
  73                 header: gettext('TTY count'),
  74                 defaultValue: 2,
  75                 editor: caps.vms['VM.Config.Options'] ? {
  76                     xtype: 'pveWindowEdit',
  77                     subject: gettext('TTY count'),
  78                     items: {
  79                         xtype: 'numberfield',
  80                         name: 'tty',
  81                         decimalPrecision: 0,
  82                         minValue: 0,
  83                         maxValue: 6,
  84                         value: 2,
  85                         fieldLabel: gettext('TTY count'),
  86                         allowEmpty: gettext('Default'),
  87                         getSubmitData: function() {
  88                             var me = this;
  89                             var val = me.getSubmitValue();
  90                             if (val !== null && val !== '' && val !== '2') {
  91                                 return { tty: val };
  92                             } else {
  93                                 return { 'delete' : 'tty' };
  94                             }
  95                         }
  96
  97                     }
  98                 } : undefined
  99             },
 100             cmode: {
 101                 header: gettext('Console mode'),
 102                 defaultValue: 'tty',
 103                 editor: caps.vms['VM.Config.Options'] ? {
 104                     xtype: 'pveWindowEdit',
 105                     subject: gettext('Console mode'),
 106                     items: {
 107                         xtype: 'pveKVComboBox',
 108                         name: 'cmode',
 109                         deleteEmpty: true,
 110                         value: '',
 111                         data: [
 112                             ['', PVE.Utils.defaultText + " (tty)"],
 113                             ['tty', "/dev/tty[X]"],
 114                             ['console', "/dev/console"],
 115                             ['shell', "shell"]
 116                         ],
 117                         fieldLabel: gettext('Console mode')
 118                     }
 119                 } : undefined
 120             },
 121             protection: {
 122                 header: gettext('CT protection'),
 123                 defaultValue: false,
 124                 renderer: PVE.Utils.format_boolean,
 125                 editor: caps.vms['VM.Config.Options'] ? {
 126                     xtype: 'pveWindowEdit',
 127                     subject: gettext('CT protection'),
 128                     items: {
 129                         xtype: 'pvecheckbox',
 130                         name: 'protection',
 131                         uncheckedValue: 0,
 132                         defaultValue: 0,
 133                         deleteDefaultValue: true,
 134                         fieldLabel: gettext('Enabled')
 135                     }
 136                 } : undefined
 137             }
 138         };
 139
 140         var baseurl = 'nodes/' + nodename + '/lxc/' + vmid + '/config';
 141
 142         var reload = function() {
 143             me.rstore.load();
 144         };
 145
 146         var sm = Ext.create('Ext.selection.RowModel', {});
 147
 148         var run_editor = function() {
 149             var rec = sm.getSelection()[0];
 150             if (!rec) {
 151                 return;
 152             }
 153
 154             var rowdef = rows[rec.data.key];
 155             if (!rowdef.editor) {
 156                 return;
 157             }
 158
 159             var win;
 160             if (Ext.isString(rowdef.editor)) {
 161                 win = Ext.create(rowdef.editor, {
 162                     pveSelNode: me.pveSelNode,
 163                     confid: rec.data.key,
 164                     url: '/api2/extjs/' + baseurl
 165                 });
 166             } else {
 167                 var config = Ext.apply({
 168                     pveSelNode: me.pveSelNode,
 169                     confid: rec.data.key,
 170                     url: '/api2/extjs/' + baseurl
 171                 }, rowdef.editor);
 172                 win = Ext.createWidget(rowdef.editor.xtype, config);
 173                 win.load();
 174             }
 175
 176             win.show();
 177             win.on('destroy', reload);
 178         };
 179
 180         var edit_btn = new PVE.button.Button({
 181             text: gettext('Edit'),
 182             disabled: true,
 183             selModel: sm,
 184             enableFn: function(rec) {
 185                 var rowdef = rows[rec.data.key];
 186                 return !!rowdef.editor;
 187             },
 188             handler: run_editor
 189         });
 190
 191         Ext.applyIf(me, {
 192             url: "/api2/json/nodes/" + nodename + "/lxc/" + vmid + "/config",
 193             selModel: sm,
 194             cwidth1: 150,
 195             tbar: [ edit_btn ],
 196             rows: rows,
 197             listeners: {
 198                 itemdblclick: run_editor
 199             }
 200         });
 201
 202         me.callParent();
 203
 204         me.on('show', reload);
 205     }
 206 });
 207