www/manager6/lxc/Options.js

   1 /*jslint confusion: true */
   2 Ext.define('PVE.lxc.Options', {
   3     extend: 'Proxmox.grid.PendingObjectGrid',
   4     alias: ['widget.pveLxcOptions'],
   5
   6     onlineHelp: 'pct_options',
   7
   8     initComponent : function() {
   9         var me = this;
  10         var i;
  11
  12         var nodename = me.pveSelNode.data.node;
  13         if (!nodename) {
  14             throw "no node name specified";
  15         }
  16
  17         var vmid = me.pveSelNode.data.vmid;
  18         if (!vmid) {
  19             throw "no VM ID specified";
  20         }
  21
  22         var caps = Ext.state.Manager.get('GuiCap');
  23
  24         var rows = {
  25             onboot: {
  26                 header: gettext('Start at boot'),
  27                 defaultValue: '',
  28                 renderer: Proxmox.Utils.format_boolean,
  29                 editor: caps.vms['VM.Config.Options'] ? {
  30                     xtype: 'proxmoxWindowEdit',
  31                     subject: gettext('Start at boot'),
  32                     items: {
  33                         xtype: 'proxmoxcheckbox',
  34                         name: 'onboot',
  35                         uncheckedValue: 0,
  36                         defaultValue: 0,
  37                         fieldLabel: gettext('Start at boot')
  38                     }
  39                 } : undefined
  40             },
  41             startup: {
  42                 header: gettext('Start/Shutdown order'),
  43                 defaultValue: '',
  44                 renderer: PVE.Utils.render_kvm_startup,
  45                 editor: caps.vms['VM.Config.Options'] && caps.nodes['Sys.Modify'] ?
  46                     {
  47                         xtype: 'pveWindowStartupEdit',
  48                         onlineHelp: 'pct_startup_and_shutdown'
  49                     } : undefined
  50             },
  51             ostype: {
  52                 header: gettext('OS Type'),
  53                 defaultValue: Proxmox.Utils.unknownText
  54             },
  55             arch: {
  56                 header: gettext('Architecture'),
  57                 defaultValue: Proxmox.Utils.unknownText
  58             },
  59             console: {
  60                 header: '/dev/console',
  61                 defaultValue: 1,
  62                 renderer: Proxmox.Utils.format_enabled_toggle,
  63                 editor: caps.vms['VM.Config.Options'] ? {
  64                     xtype: 'proxmoxWindowEdit',
  65                     subject: '/dev/console',
  66                     items: {
  67                         xtype: 'proxmoxcheckbox',
  68                         name: 'console',
  69                         uncheckedValue: 0,
  70                         defaultValue: 1,
  71                         deleteDefaultValue: true,
  72                         checked: true,
  73                         fieldLabel: '/dev/console'
  74                     }
  75                 } : undefined
  76             },
  77             tty: {
  78                 header: gettext('TTY count'),
  79                 defaultValue: 2,
  80                 editor: caps.vms['VM.Config.Options'] ? {
  81                     xtype: 'proxmoxWindowEdit',
  82                     subject: gettext('TTY count'),
  83                     items: {
  84                         xtype: 'proxmoxintegerfield',
  85                         name: 'tty',
  86                         minValue: 0,
  87                         maxValue: 6,
  88                         value: 2,
  89                         fieldLabel: gettext('TTY count'),
  90                         emptyText: gettext('Default'),
  91                         deleteEmpty: true
  92                     }
  93                 } : undefined
  94             },
  95             cmode: {
  96                 header: gettext('Console mode'),
  97                 defaultValue: 'tty',
  98                 editor: caps.vms['VM.Config.Options'] ? {
  99                     xtype: 'proxmoxWindowEdit',
 100                     subject: gettext('Console mode'),
 101                     items: {
 102                         xtype: 'proxmoxKVComboBox',
 103                         name: 'cmode',
 104                         deleteEmpty: true,
 105                         value: '__default__',
 106                         comboItems: [
 107                             ['__default__', Proxmox.Utils.defaultText + " (tty)"],
 108                             ['tty', "/dev/tty[X]"],
 109                             ['console', "/dev/console"],
 110                             ['shell', "shell"]
 111                         ],
 112                         fieldLabel: gettext('Console mode')
 113                     }
 114                 } : undefined
 115             },
 116             protection: {
 117                 header: gettext('Protection'),
 118                 defaultValue: false,
 119                 renderer: Proxmox.Utils.format_boolean,
 120                 editor: caps.vms['VM.Config.Options'] ? {
 121                     xtype: 'proxmoxWindowEdit',
 122                     subject: gettext('Protection'),
 123                     items: {
 124                         xtype: 'proxmoxcheckbox',
 125                         name: 'protection',
 126                         uncheckedValue: 0,
 127                         defaultValue: 0,
 128                         deleteDefaultValue: true,
 129                         fieldLabel: gettext('Enabled')
 130                     }
 131                 } : undefined
 132             },
 133             unprivileged: {
 134                 header: gettext('Unprivileged container'),
 135                 renderer: Proxmox.Utils.format_boolean,
 136                 defaultValue: 0
 137             },
 138             features: {
 139                 header: gettext('Features'),
 140                 defaultValue: Proxmox.Utils.noneText,
 141                 editor: Proxmox.UserName === 'root@pam' ?
 142                     'PVE.lxc.FeaturesEdit' : undefined
 143             },
 144             hookscript: {
 145                 header: gettext('Hookscript')
 146             }
 147         };
 148
 149         var baseurl = 'nodes/' + nodename + '/lxc/' + vmid + '/config';
 150
 151         var sm = Ext.create('Ext.selection.RowModel', {});
 152
 153         var edit_btn = new Proxmox.button.Button({
 154             text: gettext('Edit'),
 155             disabled: true,
 156             selModel: sm,
 157             enableFn: function(rec) {
 158                 var rowdef = rows[rec.data.key];
 159                 return !!rowdef.editor;
 160             },
 161             handler: function() { me.run_editor(); }
 162         });
 163
 164         var revert_btn = new Proxmox.button.Button({
 165             text: gettext('Revert'),
 166             disabled: true,
 167             handler: function() {
 168                 var sm = me.getSelectionModel();
 169                 var rec = sm.getSelection()[0];
 170                 if (!rec) {
 171                     return;
 172                 }
 173
 174                 var rowdef = me.rows[rec.data.key] || {};
 175                 var keys = rowdef.multiKey ||  [ rec.data.key ];
 176                 var revert = keys.join(',');
 177
 178                 Proxmox.Utils.API2Request({
 179                     url: '/api2/extjs/' + baseurl,
 180                     waitMsgTarget: me,
 181                     method: 'PUT',
 182                     params: {
 183                         'revert': revert
 184                     },
 185                     callback: function() {
 186                         me.reload();
 187                     },
 188                     failure: function (response, opts) {
 189                         Ext.Msg.alert('Error',response.htmlStatus);
 190                     }
 191                 });
 192             }
 193         });
 194
 195         var set_button_status = function() {
 196             var sm = me.getSelectionModel();
 197             var rec = sm.getSelection()[0];
 198
 199             if (!rec) {
 200                 edit_btn.disable();
 201                 return;
 202             }
 203
 204             var key = rec.data.key;
 205             var pending = rec.data['delete'] || me.hasPendingChanges(key);
 206             var rowdef = rows[key];
 207
 208             edit_btn.setDisabled(!rowdef.editor);
 209             revert_btn.setDisabled(!pending);
 210         };
 211
 212
 213         Ext.apply(me, {
 214             url: "/api2/json/nodes/" + nodename + "/lxc/" + vmid + "/pending",
 215             selModel: sm,
 216             interval: 5000,
 217             tbar: [ edit_btn, revert_btn ],
 218             rows: rows,
 219             editorConfig: {
 220                 url: '/api2/extjs/' + baseurl
 221             },
 222             listeners: {
 223                 itemdblclick: me.run_editor,
 224                 selectionchange: set_button_status
 225             }
 226         });
 227
 228         me.callParent();
 229
 230         me.on('activate', me.rstore.startUpdate);
 231         me.on('destroy', me.rstore.stopUpdate);
 232         me.on('deactivate', me.rstore.stopUpdate);
 233
 234         me.mon(me.getStore(), 'datachanged', function() {
 235             set_button_status();
 236         });
 237
 238     }
 239 });
 240