www/manager6/qemu/ProcessorEdit.js

   1 Ext.define('PVE.qemu.ProcessorInputPanel', {
   2     extend: 'Proxmox.panel.InputPanel',
   3     alias: 'widget.pveQemuProcessorPanel',
   4     onlineHelp: 'qm_cpu',
   5
   6     insideWizard: false,
   7
   8     viewModel: {
   9         data: {
  10             socketCount: 1,
  11             coreCount: 1,
  12             showCustomModelPermWarning: false,
  13         },
  14         formulas: {
  15             totalCoreCount: get => get('socketCount') * get('coreCount'),
  16         },
  17     },
  18
  19     controller: {
  20         xclass: 'Ext.app.ViewController',
  21     },
  22
  23     onGetValues: function(values) {
  24         var me = this;
  25
  26         if (Array.isArray(values.delete)) {
  27             values.delete = values.delete.join(',');
  28         }
  29
  30         PVE.Utils.delete_if_default(values, 'cpulimit', '0', me.insideWizard);
  31         PVE.Utils.delete_if_default(values, 'cpuunits', '1024', me.insideWizard);
  32
  33         // build the cpu options:
  34         me.cpu.cputype = values.cputype;
  35
  36         if (values.flags) {
  37             me.cpu.flags = values.flags;
  38         } else {
  39             delete me.cpu.flags;
  40         }
  41
  42         delete values.cputype;
  43         delete values.flags;
  44         var cpustring = PVE.Parser.printQemuCpu(me.cpu);
  45
  46         // remove cputype delete request:
  47         var del = values.delete;
  48         delete values.delete;
  49         if (del) {
  50             del = del.split(',');
  51             Ext.Array.remove(del, 'cputype');
  52         } else {
  53             del = [];
  54         }
  55
  56         if (cpustring) {
  57             values.cpu = cpustring;
  58         } else {
  59             del.push('cpu');
  60         }
  61
  62         var delarr = del.join(',');
  63         if (delarr) {
  64             values.delete = delarr;
  65         }
  66
  67         return values;
  68     },
  69
  70     setValues: function(values) {
  71         let me = this;
  72
  73         let type = values.cputype;
  74         let typeSelector = me.lookupReference('cputype');
  75         let typeStore = typeSelector.getStore();
  76         typeStore.on('load', (store, records, success) => {
  77             if (!success || !type || records.some(x => x.data.name === type)) {
  78                 return;
  79             }
  80
  81             // if we get here, a custom CPU model is selected for the VM but we
  82             // don't have permission to configure it - it will not be in the
  83             // list retrieved from the API, so add it manually to allow changing
  84             // other processor options
  85             typeStore.add({
  86                 name: type,
  87                 displayname: type.replace(/^custom-/, ''),
  88                 custom: 1,
  89                 vendor: gettext("Unknown"),
  90             });
  91             typeSelector.select(type);
  92         });
  93
  94         me.callParent([values]);
  95     },
  96
  97     cpu: {},
  98
  99     column1: [
 100         {
 101             xtype: 'proxmoxintegerfield',
 102             name: 'sockets',
 103             minValue: 1,
 104             maxValue: 4,
 105             value: '1',
 106             fieldLabel: gettext('Sockets'),
 107             allowBlank: false,
 108             bind: {
 109                 value: '{socketCount}',
 110             },
 111         },
 112         {
 113             xtype: 'proxmoxintegerfield',
 114             name: 'cores',
 115             minValue: 1,
 116             maxValue: 128,
 117             value: '1',
 118             fieldLabel: gettext('Cores'),
 119             allowBlank: false,
 120             bind: {
 121                 value: '{coreCount}',
 122             },
 123         },
 124     ],
 125
 126     column2: [
 127         {
 128             xtype: 'CPUModelSelector',
 129             name: 'cputype',
 130             reference: 'cputype',
 131             fieldLabel: gettext('Type'),
 132         },
 133         {
 134             xtype: 'displayfield',
 135             fieldLabel: gettext('Total cores'),
 136             name: 'totalcores',
 137             isFormField: false,
 138             bind: {
 139                 value: '{totalCoreCount}',
 140             },
 141         },
 142     ],
 143
 144     columnB: [
 145         {
 146             xtype: 'displayfield',
 147             userCls: 'pmx-hint',
 148             value: gettext('WARNING: You do not have permission to configure custom CPU types, if you change the type you will not be able to go back!'),
 149             hidden: true,
 150             bind: {
 151                 hidden: '{!showCustomModelPermWarning}',
 152             },
 153         },
 154     ],
 155
 156     advancedColumn1: [
 157         {
 158             xtype: 'proxmoxintegerfield',
 159             name: 'vcpus',
 160             minValue: 1,
 161             maxValue: 1,
 162             value: '',
 163             fieldLabel: gettext('VCPUs'),
 164             deleteEmpty: true,
 165             allowBlank: true,
 166             emptyText: '1',
 167             bind: {
 168                 emptyText: '{totalCoreCount}',
 169                 maxValue: '{totalCoreCount}',
 170             },
 171         },
 172         {
 173             xtype: 'numberfield',
 174             name: 'cpulimit',
 175             minValue: 0,
 176             maxValue: 128, // api maximum
 177             value: '',
 178             step: 1,
 179             fieldLabel: gettext('CPU limit'),
 180             allowBlank: true,
 181             emptyText: gettext('unlimited'),
 182         },
 183     ],
 184
 185     advancedColumn2: [
 186         {
 187             xtype: 'proxmoxintegerfield',
 188             name: 'cpuunits',
 189             fieldLabel: gettext('CPU units'),
 190             // FIXME: change to [1, 1000] once cgroup v1 support gets removed (PVE 8 ?)
 191             minValue: 2,
 192             maxValue: 262144,
 193             value: '',
 194             emptyText: '1024',
 195             deleteEmpty: true,
 196             allowBlank: true,
 197         },
 198         {
 199             xtype: 'proxmoxcheckbox',
 200             fieldLabel: gettext('Enable NUMA'),
 201             name: 'numa',
 202             uncheckedValue: 0,
 203         },
 204     ],
 205     advancedColumnB: [
 206         {
 207             xtype: 'label',
 208             text: 'Extra CPU Flags:',
 209         },
 210         {
 211             xtype: 'vmcpuflagselector',
 212             name: 'flags',
 213         },
 214     ],
 215 });
 216
 217 Ext.define('PVE.qemu.ProcessorEdit', {
 218     extend: 'Proxmox.window.Edit',
 219
 220     width: 700,
 221
 222     initComponent: function() {
 223         var me = this;
 224
 225         var ipanel = Ext.create('PVE.qemu.ProcessorInputPanel');
 226
 227         Ext.apply(me, {
 228             subject: gettext('Processors'),
 229             items: ipanel,
 230         });
 231
 232         me.callParent();
 233
 234         me.load({
 235             success: function(response, options) {
 236                 var data = response.result.data;
 237                 var value = data.cpu;
 238                 if (value) {
 239                     var cpu = PVE.Parser.parseQemuCpu(value);
 240                     ipanel.cpu = cpu;
 241                     data.cputype = cpu.cputype;
 242                     if (cpu.flags) {
 243                         data.flags = cpu.flags;
 244                     }
 245
 246                     let caps = Ext.state.Manager.get('GuiCap');
 247                     if (data.cputype.indexOf('custom-') === 0 &&
 248                         !caps.nodes['Sys.Audit']) {
 249                         let vm = ipanel.getViewModel();
 250                         vm.set("showCustomModelPermWarning", true);
 251                     }
 252                 }
 253                 me.setValues(data);
 254             },
 255         });
 256     },
 257 });