Ext.Object.each(netif, function(iface, data) {
var tmparray = [];
- Ext.Array.each(['ifname', 'mac', 'bridge', 'host_ifname' , 'host_mac', 'mac_filter', 'tag', 'firewall'], function(key) {
+ Ext.Array.each(['ifname', 'mac', 'bridge', 'host_ifname', 'host_mac', 'mac_filter', 'tag', 'firewall'], function(key) {
var value = data[key];
if (key === 'bridge'){
if(data.tag){
return {
type: m[1],
key: m[2],
- comment: m[3]
+ comment: m[3],
};
}
if (m[2].match(typere)) {
options: m[1],
type: m[2],
key: m[3],
- comment: m[4]
+ comment: m[4],
};
}
return null;
['pooltab', ''],
['kvmtab', ''],
['lxctab', ''],
- ['dctab', '']
+ ['dctab', ''],
],
hprefix: 'v1',
clog: 3,
storage: 2,
folder: 1,
- server: 0
+ server: 0,
},
decodeHToken: function(token) {
} else {
me.callParent(arguments);
}
- }
+ },
});
IP64AddressList: v => PVE.Utils.verify_ip64_address_list(v, false),
IP64AddressWithSuffixList: v => PVE.Utils.verify_ip64_address_list(v, true),
IP64AddressListText: gettext('Example') + ': 192.168.1.1,192.168.1.2',
- IP64AddressListMask: /[A-Fa-f0-9\,\:\.\;\ ]/
+ IP64AddressListMask: /[A-Fa-f0-9\,\:\.\;\ ]/,
});
Ext.define('PVE.form.field.Display', {
setSubmitValue: function(value) {
// do nothing, this is only to allow generalized bindings for the:
// `me.isCreate ? 'textfield' : 'displayfield'` cases we have.
- }
+ },
});
// avoid errors when running without development tools
if (!Ext.isDefined(Ext.global.console)) {
var console = {
- log: function() {}
+ log: function() {},
};
}
console.log("Starting PVE Manager");
Ext.Ajax.defaultHeaders = {
- 'Accept': 'application/json'
+ 'Accept': 'application/json',
};
Ext.define('PVE.Utils', { utilities: {
4: "warning",
5: "notice",
6: "info",
- 7: "debug"
+ 7: "debug",
},
support_level_hash: {
'c': gettext('Community'),
'b': gettext('Basic'),
's': gettext('Standard'),
- 'p': gettext('Premium')
+ 'p': gettext('Premium'),
},
noSubKeyHtml: 'You do not have a valid subscription for this server. Please visit <a target="_blank" href="https://www.proxmox.com/products/proxmox-ve/subscription-service-plans">www.proxmox.com</a> to get a list of available options.',
kvm_ostypes: {
'Linux': [
{ desc: '5.x - 2.6 Kernel', val: 'l26' },
- { desc: '2.4 Kernel', val: 'l24' }
+ { desc: '2.4 Kernel', val: 'l24' },
],
'Microsoft Windows': [
{ desc: '10/2016/2019', val: 'win10' },
{ desc: '7/2008r2', val: 'win7' },
{ desc: 'Vista/2008', val: 'w2k8' },
{ desc: 'XP/2003', val: 'wxp' },
- { desc: '2000', val: 'w2k' }
+ { desc: '2000', val: 'w2k' },
],
'Solaris Kernel': [
- { desc: '-', val: 'solaris'}
+ { desc: '-', val: 'solaris'},
],
'Other': [
- { desc: '-', val: 'other'}
- ]
+ { desc: '-', val: 'other'},
+ ],
},
get_health_icon: function(state, circle) {
'HEALTH_UPGRADE':'upgrade',
'HEALTH_OLD':'old',
'HEALTH_WARN':'warning',
- 'HEALTH_ERR':'critical'
+ 'HEALTH_ERR':'critical',
},
render_ceph_health: function(healthObj) {
var state = {
iconCls: PVE.Utils.get_health_icon(),
- text: ''
+ text: '',
};
if (!healthObj || !healthObj.status) {
sl: 'Slovenian',
sv: 'Swedish',
//th: 'Thai',
- tr: 'Turkish'
+ tr: 'Turkish',
},
kvm_vga_drivers: {
serial2: gettext('Serial terminal') + ' 2',
serial3: gettext('Serial terminal') + ' 3',
virtio: 'VirtIO-GPU',
- none: Proxmox.Utils.noneText
+ none: Proxmox.Utils.noneText,
},
render_kvm_language: function (value) {
'__default__': Proxmox.Utils.defaultText + ' (xterm.js)',
'vv': 'SPICE (remote-viewer)',
'html5': 'HTML5 (noVNC)',
- 'xtermjs': 'xterm.js'
+ 'xtermjs': 'xterm.js',
},
render_console_viewer: function(value) {
'vztmpl': gettext('Container template'),
'iso': gettext('ISO image'),
'rootdir': gettext('Container'),
- 'snippets': gettext('Snippets')
+ 'snippets': gettext('Snippets'),
},
volume_is_qemu_backup: function(volid, format) {
sdnvnetSchema: {
vnet: {
name: 'vnet',
- faIcon: 'folder'
+ faIcon: 'folder',
},
},
sdnzoneSchema: {
zone: {
name: 'zone',
- hideAdd: true
+ hideAdd: true,
},
simple: {
name: 'Simple',
ipanel: 'SimpleInputPanel',
- faIcon: 'th'
+ faIcon: 'th',
},
vlan: {
name: 'VLAN',
ipanel: 'VlanInputPanel',
- faIcon: 'th'
+ faIcon: 'th',
},
qinq: {
name: 'QinQ',
ipanel: 'QinQInputPanel',
- faIcon: 'th'
+ faIcon: 'th',
},
vxlan: {
name: 'VXLAN',
ipanel: 'VxlanInputPanel',
- faIcon: 'th'
+ faIcon: 'th',
},
evpn: {
name: 'EVPN',
ipanel: 'EvpnInputPanel',
- faIcon: 'th'
+ faIcon: 'th',
},
},
sdncontrollerSchema: {
controller: {
name: 'controller',
- hideAdd: true
+ hideAdd: true,
},
evpn: {
name: 'evpn',
ipanel: 'EvpnInputPanel',
- faIcon: 'crosshairs'
+ faIcon: 'crosshairs',
},
},
Ext.isNumber(data.id) &&
Ext.isNumber(data.lun)) {
return "CH " +
- Ext.String.leftPad(data.channel,2, '0') +
+ Ext.String.leftPad(data.channel, 2, '0') +
" ID " + data.id + " LUN " + data.lun;
}
- return data.volid.replace(/^.*?:(.*?\/)?/,'');
+ return data.volid.replace(/^.*?:(.*?\/)?/, '');
},
render_serverity: function (value) {
render_resource_type: function(value, metaData, record, rowIndex, colIndex, store) {
- var cls = PVE.Utils.get_object_icon_class(value,record.data);
+ var cls = PVE.Utils.get_object_icon_class(value, record.data);
var fa = '<i class="fa-fw x-grid-icon-custom ' + cls + '"></i> ';
return fa + value;
'2': gettext('Bad Request'),
'3': gettext('Configuration Unsupported'),
'4': gettext('Device Ineligible'),
- '5': gettext('Timeout')
+ '5': gettext('Timeout'),
};
return "U2F Error: " + ErrorNames[error] || Proxmox.Utils.unknownText;
},
vmname: vmname,
node: nodename,
resize: scaling,
- cmd: cmd
+ cmd: cmd,
});
var nw = window.open("?" + url, '_blank', "innerWidth=745,innerheight=427");
if (nw) {
var link = Ext.DomHelper.append(document.body, {
tag: 'a',
href: uri,
- css : 'display:none;visibility:hidden;height:0px;'
+ css : 'display:none;visibility:hidden;height:0px;',
});
// Note: we need to tell android the correct file name extension
encodeURIComponent(raw);
downloadWithName(url, "pve-spice.vv");
- }
+ },
});
},
xtermjs: !!conf.serial,
};
PVE.Utils.openDefaultConsoleWindow(consoles, 'kvm', vmid, nodename, vmname);
- }
+ },
});
} else if (record.data.type === 'lxc' && !record.data.template) {
PVE.Utils.openDefaultConsoleWindow(true, 'lxc', vmid, nodename, vmname);
if (template) {
if (type === 'qemu' || type == 'lxc') {
menu = Ext.create('PVE.menu.TemplateMenu', {
- pveSelNode: record
+ pveSelNode: record,
});
}
} else if (type === 'qemu' ||
type === 'node') {
menu = Ext.create('PVE.' + type + '.CmdMenu', {
pveSelNode: record,
- nodename: record.data.node
+ nodename: record.data.node,
});
} else {
return;
if (!container.down('pveCephInstallWindow')){
var isInstalled = msg.match(/not initialized/i) ? true : false;
var win = Ext.create('PVE.ceph.Install', {
- nodename: nodename
+ nodename: nodename,
});
win.getViewModel().set('isInstalled', isInstalled);
container.add(win);
cpu_vendor_map: {
'default': 'QEMU',
'AuthenticAMD': 'AMD',
- 'GenuineIntel': 'Intel'
+ 'GenuineIntel': 'Intel',
},
cpu_vendor_order: {
vzumount: ['CT', gettext('Unmount')],
zfscreate: [gettext('ZFS Storage'), gettext('Create')],
});
- }
+ },
});
PVE.Utils.cleanEmptyObjectKeys(queryDict);
var url = '/?' + Ext.Object.toQueryString(queryDict);
box.load(url);
- }
- }
+ },
+ },
});
me.callParent();
// reload IFrame content to forcibly reconnect VNC/xterm.js to VM
var box = this.down('[itemid=vncconsole]');
box.getWin().location.reload();
- }
+ },
});
me.login = null;
me.updateLoginData(data);
Proxmox.Utils.checked_command(function() {}); // display subscription status
- }
+ },
});
}
me.onLogin(null);
Ext.Ajax.request({
params: {
username: Proxmox.UserName,
- password: ticket
+ password: ticket,
},
url: '/api2/json/access/ticket',
method: 'POST',
success: function(response, opts) {
var obj = Ext.decode(response.responseText);
me.updateLoginData(obj.data);
- }
+ },
});
},
- interval: 15*60*1000
+ interval: 15*60*1000,
});
- }
+ },
});
Ext.define('PVE.StdWorkspace', {
success: function(response) {
PVE.VersionInfo = response.result.data;
me.updateVersionInfo();
- }
+ },
});
Proxmox.Utils.API2Request({
lxc: 'PVE.lxc.Config',
storage: 'PVE.storage.Browser',
sdn: 'PVE.sdn.Browser',
- pool: 'pvePoolConfig'
+ pool: 'pvePoolConfig',
};
var comp = {
xtype: tlckup[n.data.type || 'root'] ||
Ext.isDefined(n.data.groupbyid),
pveSelNode: n,
workspace: me,
- viewFilter: selview.getViewFilter()
+ viewFilter: selview.getViewFilter(),
};
PVE.curSelectedNode = n;
me.setContent(comp);
}
- }
- }
- }
+ },
+ },
+ },
});
selview.on('select', function(combo, records) {
handler: function() {
var wiz = Ext.create('PVE.qemu.CreateWizard', {});
wiz.show();
- }
+ },
});
var createCT = Ext.createWidget('button', {
handler: function() {
var wiz = Ext.create('PVE.lxc.CreateWizard', {});
wiz.show();
- }
+ },
});
sprovider.on('statechange', function(sp, key, value) {
region: 'north',
layout: {
type: 'hbox',
- align: 'middle'
+ align: 'middle',
},
baseCls: 'x-plain',
defaults: {
- baseCls: 'x-plain'
+ baseCls: 'x-plain',
},
border: false,
margin: '2 0 2 5',
{
minWidth: 150,
id: 'versioninfo',
- html: 'Virtual Environment'
+ html: 'Virtual Environment',
},
{
xtype: 'pveGlobalSearchField',
- tree: rtree
+ tree: rtree,
},
{
- flex: 1
+ flex: 1,
},
{
xtype: 'proxmoxHelpButton',
listenToGlobalEvent: false,
onlineHelp: 'pve_documentation_index',
text: gettext('Documentation'),
- margin: '0 5 0 0'
+ margin: '0 5 0 0',
},
createVM,
createCT,
style: {
// proxmox dark grey p light grey as border
backgroundColor: '#464d4d',
- borderColor: '#ABBABA'
+ borderColor: '#ABBABA',
},
iconCls: 'fa fa-user',
menu: [
handler: function() {
var win = Ext.create('PVE.window.Settings');
win.show();
- }
+ },
},
{
text: gettext('Password'),
iconCls: 'fa fa-fw fa-key',
handler: function() {
var win = Ext.create('Proxmox.window.PasswordEdit', {
- userid: Proxmox.UserName
+ userid: Proxmox.UserName,
});
win.show();
- }
+ },
},
{
text: 'TFA',
iconCls: 'fa fa-fw fa-lock',
handler: function(btn, event, rec) {
- var win = Ext.create('PVE.window.TFAEdit',{
- userid: Proxmox.UserName
+ var win = Ext.create('PVE.window.TFAEdit', {
+ userid: Proxmox.UserName,
});
win.show();
- }
+ },
},
{
iconCls: 'fa fa-language',
comp.getStore().loadData([], false);
}
});
- }
- }
- ]
- }
- ]
+ },
+ },
+ ],
+ },
+ ],
},
{
region: 'center',
layout: { type: 'card' },
border: false,
margin: '0 5 0 0',
- items: []
+ items: [],
},
{
region: 'west',
if (width > viewWidth - 100) {
panel.setWidth(viewWidth - 100);
}
- }
- }
+ },
+ },
},
{
xtype: 'pveStatusPanel',
if (height > (viewHeight - 150)) {
panel.setHeight(viewHeight - 150);
}
- }
- }
- }
- ]
+ },
+ },
+ },
+ ],
});
me.callParent();
});
}
});
- }
+ },
});
var me = this;
var consoles = {
spice: me.enableSpice,
- xtermjs: me.enableXtermjs
+ xtermjs: me.enableXtermjs,
};
PVE.Utils.openDefaultConsoleWindow(consoles, me.consoleType, me.vmid,
me.nodename, me.consoleName, me.cmd);
handler: function(button) {
var me = this.up('button');
PVE.Utils.openConsoleWindow(button.type, me.consoleType, me.vmid, me.nodename, me.consoleName, me.cmd);
- }
+ },
},
{
xterm: 'menuitem',
handler: function(button) {
var me = this.up('button');
PVE.Utils.openConsoleWindow(button.type, me.consoleType, me.vmid, me.nodename, me.consoleName, me.cmd);
- }
+ },
},
{
text: 'xterm.js',
handler: function(button) {
var me = this.up('button');
PVE.Utils.openConsoleWindow(button.type, me.consoleType, me.vmid, me.nodename, me.consoleName, me.cmd);
- }
- }
+ },
+ },
],
initComponent: function() {
}
me.callParent();
- }
+ },
});
selModel: view.getSelectionModel(),
method: 'PUT',
params: {
- 'revert': keys.join(',')
+ 'revert': keys.join(','),
},
callback: () => view.reload(),
failure: (response) => Ext.Msg.alert('Error', response.htmlStatus),
return;
}
me.realHandler(button, event, rec);
- }
+ },
});
} else {
me.realHandler(button, event, rec);
}
});
}
- }
+ },
});
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
});
cephRelease: 'octopus',
configuration: true,
isInstalled: false,
- }
+ },
},
cbindData: {
- nodename: undefined
+ nodename: undefined,
},
title: gettext('Setup'),
xtype: 'pveCephHighestVersionDisplay',
labelWidth: 180,
cbind:{
- nodename: '{nodename}'
+ nodename: '{nodename}',
},
gotNewestVersion: function(release, maxversiontext, maxversion) {
if (release === 'unknown') {
Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
}
this.up('pveCephInstallWizard').down('#next').setText(gettext('Next'));
- }
- }
+ },
+ },
},
{
title: gettext('Installation'),
xtype: 'panel',
layout: 'fit',
cbind:{
- nodename: '{nodename}'
+ nodename: '{nodename}',
},
viewModel: {}, // needed to inherit parent viewModel data
listeners: {
afterrender: function() {
var me = this;
if (this.getViewModel().get('isInstalled')) {
- this.mask("Ceph is already installed, click next to create your configuration.",['pve-static-mask']);
+ this.mask("Ceph is already installed, click next to create your configuration.", ['pve-static-mask']);
} else {
me.down('pveNoVncConsole').fireEvent('activate');
}
interval: 1000,
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + nodename + '/ceph/status'
+ url: '/api2/json/nodes/' + nodename + '/ceph/status',
},
listeners: {
load: function(rec, response, success, operation) {
me.down('textfield').setValue('success');
} else if (operation.error.statusText.match("not initialized", "i")) {
me.updateStore.stopUpdate();
- me.up('pveCephInstallWizard').getViewModel().set('configuration',false);
+ me.up('pveCephInstallWizard').getViewModel().set('configuration', false);
me.down('textfield').setValue('success');
} else if (operation.error.statusText.match("rados_connect failed", "i")) {
me.updateStore.stopUpdate();
- me.up('pveCephInstallWizard').getViewModel().set('configuration',true);
+ me.up('pveCephInstallWizard').getViewModel().set('configuration', true);
me.down('textfield').setValue('success');
} else if (!operation.error.statusText.match("not installed", "i")) {
Proxmox.Utils.setErrorMask(me, operation.error.statusText);
}
- }
- }
+ },
+ },
});
me.updateStore.startUpdate();
},
if (me.updateStore) {
me.updateStore.stopUpdate();
}
- }
+ },
},
items: [
{
value: '',
allowBlank: false,
submitValue: false,
- hidden: true
- }
- ]
+ hidden: true,
+ },
+ ],
},
{
xtype: 'inputpanel',
title: gettext('Configuration'),
onlineHelp: 'chapter_pveceph',
cbind: {
- nodename: '{nodename}'
+ nodename: '{nodename}',
},
viewModel: {
data: {
replicas: undefined,
- minreplicas: undefined
- }
+ minreplicas: undefined,
+ },
},
listeners: {
activate: function() {
},
beforeshow: function() {
if (this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
- this.mask("Configuration already initialized",['pve-static-mask']);
+ this.mask("Configuration already initialized", ['pve-static-mask']);
} else {
this.unmask();
}
},
deactivate: function() {
this.up('pveCephInstallWizard').down('#submit').setText(gettext('Finish'));
- }
+ },
},
column1: [
{
xtype: 'displayfield',
- value: gettext('Ceph cluster configuration') + ':'
+ value: gettext('Ceph cluster configuration') + ':',
},
{
xtype: 'proxmoxNetworkSelector',
value: '',
fieldLabel: 'Public Network IP/CIDR',
bind: {
- allowBlank: '{configuration}'
+ allowBlank: '{configuration}',
},
cbind: {
- nodename: '{nodename}'
- }
+ nodename: '{nodename}',
+ },
},
{
xtype: 'proxmoxNetworkSelector',
autoSelect: false,
emptyText: gettext('Same as Public Network'),
cbind: {
- nodename: '{nodename}'
- }
- }
+ nodename: '{nodename}',
+ },
+ },
// FIXME: add hint about cluster network and/or reference user to docs??
],
column2: [
{
xtype: 'displayfield',
- value: gettext('First Ceph monitor') + ':'
+ value: gettext('First Ceph monitor') + ':',
},
{
xtype: 'pveNodeSelector',
fieldLabel: gettext('Monitor node'),
name: 'mon-node',
selectCurNode: true,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'displayfield',
value: gettext('Additional monitors are recommended. They can be created at any time in the Monitor tab.'),
- userCls: 'pmx-hint'
- }
+ userCls: 'pmx-hint',
+ },
],
advancedColumn1: [
{
name: 'size',
fieldLabel: 'Number of replicas',
bind: {
- value: '{replicas}'
+ value: '{replicas}',
},
maxValue: 7,
minValue: 2,
- emptyText: '3'
+ emptyText: '3',
},
{
xtype: 'numberfield',
fieldLabel: 'Minimum replicas',
bind: {
maxValue: '{replicas}',
- value: '{minreplicas}'
+ value: '{minreplicas}',
},
minValue: 2,
maxValue: 3,
this.toggleSpinners();
this.validate();
},
- emptyText: '2'
- }
+ emptyText: '2',
+ },
],
onGetValues: function(values) {
['cluster-network', 'size', 'min_size'].forEach(function(field) {
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
} else {
me.up('pveCephInstallWizard').navigateNext();
}
- }
+ },
},
{
title: gettext('Success'),
if (this.onlineHelp) {
Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
}
- }
+ },
},
onSubmit: function() {
var wizard = this.up('pveCephInstallWizard');
wizard.close();
- }
- }
- ]
+ },
+ },
+ ],
});
border: false,
store: {
proxy: {
- type: 'proxmox'
- }
+ type: 'proxmox',
+ },
},
columns: [
text: 'Runtime Updatable',
hidden: true,
width: 80,
- renderer: Proxmox.Utils.format_boolean
+ renderer: Proxmox.Utils.format_boolean,
},
],
Proxmox.Utils.monStoreErrors(me, me.getStore());
me.getStore().load();
- }
+ },
});
Ext.define('PVE.node.CephConfig', {
extend: 'Ext.panel.Panel',
me.mon(win, 'cephInstallWindowClosed', function(){
me.load();
});
- }
+ },
);
},
success: function(response, opts) {
var data = response.result.data;
me.update(Ext.htmlEncode(data));
- }
+ },
});
},
listeners: {
activate: function() {
me.load();
- }
- }
+ },
+ },
});
me.callParent();
me.load();
- }
+ },
});
Ext.define('PVE.node.CephConfigCrush', {
items: [{
title: gettext('Configuration'),
xtype: 'pveNodeCephConfig',
- region: 'center'
+ region: 'center',
},
{
title: 'Crush Map', // do not localize
xtype: 'pveNodeCephCrushMap',
region: 'east',
split: true,
- width: '50%'
+ width: '50%',
},
{
title: gettext('Configuration Database'),
region: 'south',
split: true,
weight: -30,
- height: '50%'
+ height: '50%',
}],
initComponent: function() {
var me = this;
me.defaults = {
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
};
me.callParent();
- }
+ },
});
me.mon(win, 'cephInstallWindowClosed', function(){
me.load();
});
- }
+ },
);
},
success: function(response, opts) {
var data = response.result.data;
me.update(Ext.htmlEncode(data));
- }
+ },
});
},
listeners: {
activate: function() {
me.load();
- }
- }
+ },
+ },
});
me.callParent();
me.load();
- }
+ },
});
listeners: {
change: function(f, value) {
this.up('pveCephCreateFS').setFSName(value);
- }
+ },
},
submitValue: false, // already encoded in apicall URL
- emptyText: 'cephfs'
+ emptyText: 'cephfs',
},
{
xtype: 'proxmoxintegerfield',
emptyText: 128,
minValue: 8,
maxValue: 32768,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
tag: 'div',
'data-qtip': gettext('Add the new CephFS to the cluster storage configuration.'),
},
- }
+ },
],
initComponent : function() {
me.setFSName();
me.callParent();
- }
+ },
});
Ext.define('PVE.NodeCephFSPanel', {
defaults: {
border: false,
cbind: {
- nodename: '{nodename}'
- }
+ nodename: '{nodename}',
+ },
},
viewModel: {
parent: null,
data: {
cephfsConfigured: false,
- mdsCount: 0
+ mdsCount: 0,
},
formulas: {
canCreateFS: function(get) {
return (!get('cephfsConfigured') && get('mdsCount') > 0);
- }
- }
+ },
+ },
},
items: [
storeid: 'pve-ceph-fs',
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + view.nodename + '/ceph/fs'
+ url: '/api2/json/nodes/' + view.nodename + '/ceph/fs',
},
- model: 'pve-ceph-fs'
+ model: 'pve-ceph-fs',
});
view.setStore(Ext.create('Proxmox.data.DiffStore', {
rstore: view.rstore,
sorters: {
property: 'name',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
}));
var regex = new RegExp("not (installed|initialized)", "i");
PVE.Utils.handleStoreErrorOrMask(view, view.rstore, regex, function(me, error){
me.mon(win, 'cephInstallWindowClosed', function(){
me.rstore.startUpdate();
});
- }
+ },
);
});
view.rstore.on('load', this.onLoad, this);
listeners: {
destroy: function() {
view.rstore.startUpdate();
- }
- }
+ },
+ },
});
},
return;
}
vm.set('cephfsConfigured', true);
- }
+ },
},
tbar: [
{
handler: 'onCreate',
bind: {
// only one CephFS per Ceph cluster makes sense for now
- disabled: '{!canCreateFS}'
- }
- }
+ disabled: '{!canCreateFS}',
+ },
+ },
],
columns: [
{
header: gettext('Name'),
flex: 1,
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
header: 'Data Pool',
flex: 1,
- dataIndex: 'data_pool'
+ dataIndex: 'data_pool',
},
{
header: 'Metadata Pool',
flex: 1,
- dataIndex: 'metadata_pool'
- }
+ dataIndex: 'metadata_pool',
+ },
],
cbind: {
- nodename: '{nodename}'
- }
+ nodename: '{nodename}',
+ },
},
{
xtype: 'pveNodeCephServiceList',
vm.set('mdsCount', records.length);
},
cbind: {
- nodename: '{nodename}'
- }
- }
- ]
+ nodename: '{nodename}',
+ },
+ },
+ ],
}, function() {
Ext.define('pve-ceph-fs', {
extend: 'Ext.data.Model',
fields: [ 'name', 'data_pool', 'metadata_pool' ],
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/localhost/ceph/fs"
+ url: "/api2/json/nodes/localhost/ceph/fs",
},
- idProperty: 'name'
+ idProperty: 'name',
});
});
me.mon(win, 'cephInstallWindowClosed', function(){
me.loadTask.delay(200);
});
- }
+ },
);
if (!windowShow) {
Proxmox.Utils.setErrorMask(me, msg);
}
- }
+ },
});
defaults: {
border: false,
onlineHelp: 'chapter_pveceph',
- flex: 1
+ flex: 1,
},
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [
width: 70,
sortable: true,
renderer: Proxmox.Utils.format_boolean,
- dataIndex: 'quorum'
- }
+ dataIndex: 'quorum',
+ },
],
stateId: 'grid-ceph-monitor',
showCephInstallMask: true,
- title: gettext('Monitor')
+ title: gettext('Monitor'),
},
{
xtype: 'pveNodeCephServiceList',
type: 'mgr',
stateId: 'grid-ceph-manager',
cbind: { pveSelNode: '{pveSelNode}' },
- title: gettext('Manager')
- }
- ]
+ title: gettext('Manager'),
+ },
+ ],
});
xtype: 'textfield',
fieldLabel: gettext('Name'),
name: 'name',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
value: 3,
minValue: 1,
maxValue: 7,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
value: 2,
minValue: 1,
maxValue: 7,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'pveCephRuleSelector',
fieldLabel: 'Crush Rule', // do not localize
name: 'crush_rule',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxKVComboBox',
tag: 'div',
'data-qtip': gettext('Add the new pool to the cluster storage configuration.'),
},
- }
+ },
],
initComponent : function() {
var me = this;
Ext.apply(me, {
url: "/nodes/" + me.nodename + "/ceph/pools",
defaults: {
- nodename: me.nodename
- }
+ nodename: me.nodename,
+ },
});
me.callParent();
- }
+ },
});
Ext.define('PVE.node.CephPoolList', {
header: gettext('Name'),
width: 120,
sortable: true,
- dataIndex: 'pool_name'
+ dataIndex: 'pool_name',
},
{
header: gettext('Size') + '/min',
renderer: function(v, meta, rec) {
return v + '/' + rec.data.min_size;
},
- dataIndex: 'size'
+ dataIndex: 'size',
},
{
text: 'Placement Groups',
text: '# of PGs', // pg_num',
width: 150,
align: 'right',
- dataIndex: 'pg_num'
+ dataIndex: 'pg_num',
},
{
text: gettext('Autoscale'),
width: 140,
align: 'right',
- dataIndex: 'pg_autoscale_mode'
+ dataIndex: 'pg_autoscale_mode',
},
- ]
+ ],
},
{
text: 'CRUSH Rule',
text: 'ID',
align: 'right',
width: 50,
- dataIndex: 'crush_rule'
+ dataIndex: 'crush_rule',
},
{
text: gettext('Name'),
width: 150,
dataIndex: 'crush_rule_name',
},
- ]
+ ],
},
{
text: gettext('Used'),
align: 'right',
dataIndex: 'bytes_used',
summaryType: 'sum',
- summaryRenderer: PVE.Utils.render_size
- }
- ]
- }
+ summaryRenderer: PVE.Utils.render_size,
+ },
+ ],
+ },
],
initComponent: function() {
var me = this;
model: 'ceph-pool-list',
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/" + nodename + "/ceph/pools"
- }
+ url: "/api2/json/nodes/" + nodename + "/ceph/pools",
+ },
});
var store = Ext.create('Proxmox.data.DiffStore', { rstore: rstore });
me.mon(win, 'cephInstallWindowClosed', function(){
me.store.rstore.startUpdate();
});
- }
+ },
);
});
text: gettext('Create'),
handler: function() {
var win = Ext.create('PVE.CephCreatePool', {
- nodename: nodename
+ nodename: nodename,
});
win.show();
win.on('destroy', function() {
rstore.load();
});
- }
+ },
});
var destroy_btn = Ext.create('Proxmox.button.Button', {
showProgress: true,
url: base_url,
params: {
- remove_storages: 1
+ remove_storages: 1,
},
- item: { type: 'CephPool', id: rec.data.pool_name }
+ item: { type: 'CephPool', id: rec.data.pool_name },
}).show();
win.on('destroy', function() {
rstore.load();
});
- }
+ },
});
Ext.apply(me, {
listeners: {
activate: () => rstore.startUpdate(),
destroy: () => rstore.stopUpdate(),
- }
+ },
});
me.callParent();
- }
+ },
}, function() {
Ext.define('ceph-pool-list', {
{ name: 'bytes_used', type: 'integer'},
{ name: 'percent_used', type: 'number'},
{ name: 'crush_rule', type: 'integer'},
- { name: 'crush_rule_name', type: 'string'}
+ { name: 'crush_rule_name', type: 'string'},
],
- idProperty: 'pool_name'
+ idProperty: 'pool_name',
});
});
sorters: 'name',
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/ceph/rules'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/ceph/rules',
+ },
});
Ext.apply(me, {
- store: store
+ store: store,
});
me.callParent();
if (success && rec.length > 0) {
me.select(rec[0]);
}
- }
+ },
});
- }
+ },
});
change: function(f, value) {
var me = this.up('pveCephCreateService');
me.setNode(value);
- }
- }
- }
+ },
+ },
+ },
],
initComponent : function() {
me.setNode(me.nodename);
me.callParent();
- }
+ },
});
Ext.define('PVE.node.CephServiceList', {
storeid: 'ceph-versions-' + view.type + '-list' + view.nodename,
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/ceph/metadata?scope=versions"
- }
+ url: "/api2/json/cluster/ceph/metadata?scope=versions",
+ },
});
view.versionsstore.on('load', this.getMaxVersions, this);
model: 'ceph-service-list',
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/" + view.nodename + "/ceph/" + view.type
- }
+ url: "/api2/json/nodes/" + view.nodename + "/ceph/" + view.type,
+ },
});
view.setStore(Ext.create('Proxmox.data.DiffStore', {
rstore: view.rstore,
- sorters: [{ property: 'name' }]
+ sorters: [{ property: 'name' }],
}));
if (view.storeLoadCallback) {
me.mon(win, 'cephInstallWindowClosed', function(){
view.rstore.startUpdate();
});
- }
+ },
);
});
}
upid: upid,
taskDone: function() {
view.rstore.load();
- }
+ },
});
win.show();
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
onChangeService: function(btn) {
items: [{
xtype: 'proxmoxLogView',
url: url,
- log_select_timespan: 1
- }]
+ log_select_timespan: 1,
+ }],
});
win.show();
},
type: view.type,
taskDone: function() {
view.rstore.load();
- }
+ },
});
- }
+ },
},
tbar: [
return rec.data.state === 'stopped' ||
rec.data.state === 'unknown';
},
- handler: 'onChangeService'
+ handler: 'onChangeService',
},
{
xtype: 'proxmoxButton',
return rec.data.state !== 'stopped';
},
disabled: true,
- handler: 'onChangeService'
+ handler: 'onChangeService',
},
{
xtype: 'proxmoxButton',
enableFn: function(rec) {
return rec.data.state !== 'stopped';
},
- handler: 'onChangeService'
+ handler: 'onChangeService',
},
'-',
{
text: gettext('Create'),
reference: 'createButton',
- handler: 'onCreate'
+ handler: 'onCreate',
},
{
text: gettext('Destroy'),
upid: upid,
taskDone: function() {
view.rstore.load();
- }
+ },
});
win.show();
- }
+ },
},
'-',
{
xtype: 'proxmoxButton',
text: gettext('Syslog'),
disabled: true,
- handler: 'showSyslog'
- }
+ handler: 'showSyslog',
+ },
],
columns: [
renderer: function(v) {
return this.type + '.' + v;
},
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
header: gettext('Host'),
renderer: function(v) {
return v || Proxmox.Utils.unknownText;
},
- dataIndex: 'host'
+ dataIndex: 'host',
},
{
header: gettext('Status'),
flex: 1,
sortable: false,
- dataIndex: 'state'
+ dataIndex: 'state',
},
{
header: gettext('Address'),
renderer: function(v) {
return v || Proxmox.Utils.unknownText;
},
- dataIndex: 'addr'
+ dataIndex: 'addr',
},
{
header: gettext('Version'),
sortable: true,
dataIndex: 'version',
renderer: 'render_version',
- }
+ },
],
initComponent: function() {
}
me.callParent();
- }
+ },
}, function() {
'ceph_version', 'ceph_version_short',
{ type: 'string', name: 'version', calculate: function(data) {
return PVE.Utils.parse_ceph_version(data);
- } }
+ } },
],
- idProperty: 'name'
+ idProperty: 'name',
});
});
layout: {
type: 'hbox',
- align: 'stretch'
+ align: 'stretch',
},
bodyPadding: '0 5 20',
defaults: {
xtype: 'box',
style: {
- 'text-align':'center'
- }
+ 'text-align':'center',
+ },
},
items: [
flex: 1,
xtype: 'pveCephServiceList',
itemId: 'mons',
- title: gettext('Monitors')
+ title: gettext('Monitors'),
},
{
flex: 1,
xtype: 'pveCephServiceList',
itemId: 'mgrs',
- title: gettext('Managers')
+ title: gettext('Managers'),
},
{
flex: 1,
xtype: 'pveCephServiceList',
itemId: 'mdss',
- title: gettext('Meta Data Servers')
- }
+ title: gettext('Meta Data Servers'),
+ },
],
updateAll: function(metadata, status) {
'HEALTH_WARN': 2,
'HEALTH_UPGRADE': 3,
'HEALTH_OLD': 4,
- 'HEALTH_OK': 5
+ 'HEALTH_OK': 5,
};
var healthmap = [
'HEALTH_UNKNOWN',
'HEALTH_WARN',
'HEALTH_UPGRADE',
'HEALTH_OLD',
- 'HEALTH_OK'
+ 'HEALTH_OK',
];
var reduceFn = function(first, second) {
return first + '\n' + second.message;
if (!monmessages[monid]) {
monmessages[monid] = {
worstSeverity: healthstates.HEALTH_OK,
- messages: []
+ messages: [],
};
}
monmessages[monid].messages.push(
PVE.Utils.get_ceph_icon_html(value.severity, true) +
- Ext.Array.reduce(value.detail, reduceFn, '')
+ Ext.Array.reduce(value.detail, reduceFn, ''),
);
if (healthstates[value.severity] < monmessages[monid].worstSeverity) {
monmessages[monid].worstSeverity = healthstates[value.severity];
}
return mds;
- }
+ },
};
for (let type of ['mon', 'mgr', 'mds']) {
host: host,
version: PVE.Utils.parse_ceph_version(metadata[type][id]),
service: metadata[type][id].service,
- addr: metadata[type][id].addr || metadata[type][id].addrs || Proxmox.Utils.unknownText
+ addr: metadata[type][id].addr || metadata[type][id].addrs || Proxmox.Utils.unknownText,
};
result.statuses = [
gettext('Host') + ": " + result.host,
- gettext('Address') + ": " + result.addr
+ gettext('Address') + ": " + result.addr,
];
if (checks[type]) {
if (result.service && !result.version) {
result.messages.push(
PVE.Utils.get_ceph_icon_html('HEALTH_UNKNOWN', true) +
- gettext('Stopped')
+ gettext('Stopped'),
);
result.health = healthstates.HEALTH_UNKNOWN;
}
}
result.messages.push(
PVE.Utils.get_ceph_icon_html('HEALTH_OLD', true) +
- gettext('A newer version was installed but old version still running, please restart')
+ gettext('A newer version was installed but old version still running, please restart'),
);
} else {
if (result.health > healthstates.HEALTH_UPGRADE) {
}
result.messages.push(
PVE.Utils.get_ceph_icon_html('HEALTH_UPGRADE', true) +
- gettext('Other cluster members use a newer version of this service, please upgrade and restart')
+ gettext('Other cluster members use a newer version of this service, please upgrade and restart'),
);
}
}
me.getComponent('mons').updateAll(Object.values(me.mon));
me.getComponent('mgrs').updateAll(Object.values(me.mgr));
me.getComponent('mdss').updateAll(Object.values(me.mds));
- }
+ },
});
Ext.define('PVE.ceph.ServiceList', {
xtype: 'pveCephServiceList',
style: {
- 'text-align':'center'
+ 'text-align':'center',
},
defaults: {
xtype: 'box',
style: {
- 'text-align':'center'
- }
+ 'text-align':'center',
+ },
},
items: [
{
itemId: 'title',
data: {
- title: ''
+ title: '',
},
- tpl: '<h3>{title}</h3>'
- }
+ tpl: '<h3>{title}</h3>',
+ },
],
updateAll: function(list) {
// we can add it at the service+1 position (because of the title)
service = me.insert(i+1, {
xtype: 'pveCephServiceWidget',
- itemId: list[i].id
+ itemId: list[i].id,
});
if (!me.ids) {
me.ids = [];
var me = this;
me.callParent();
me.getComponent('title').update({
- title: me.title
+ title: me.title,
});
- }
+ },
});
Ext.define('PVE.ceph.ServiceWidget', {
title: '0',
health: 'HEALTH_ERR',
text: '',
- iconCls: PVE.Utils.get_health_icon()
+ iconCls: PVE.Utils.get_health_icon(),
},
tpl: [
'{title}: ',
- '<i class="fa fa-fw {iconCls}"></i>'
+ '<i class="fa fa-fw {iconCls}"></i>',
],
updateService: function(title, text, health) {
health: health,
text: text,
title: title,
- iconCls: PVE.Utils.get_health_icon(PVE.Utils.map_ceph_health[health])
+ iconCls: PVE.Utils.get_health_icon(PVE.Utils.map_ceph_health[health]),
}));
if (me.tooltip) {
trackMouse: true,
dismissDelay: 0,
renderTo: Ext.getBody(),
- html: me.data.text
+ html: me.data.text,
});
}
me.tooltip.show();
- }
+ },
},
mouseleave: {
element: 'el',
me.tooltip.destroy();
delete me.tooltip;
}
- }
- }
- }
+ },
+ },
+ },
});
bodyPadding: 5,
layout: {
- type: 'column'
+ type: 'column',
},
defaults: {
- padding: 5
+ padding: 5,
},
items: [
responsiveConfig: {
'width < 1900': {
minHeight: 230,
- columnWidth: 1
+ columnWidth: 1,
},
'width >= 1900': {
minHeight: 500,
- columnWidth: 0.5
- }
+ columnWidth: 0.5,
+ },
},
layout: {
type: 'hbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [
{
flex: 1,
itemId: 'overallhealth',
xtype: 'pveHealthWidget',
- title: gettext('Status')
+ title: gettext('Status'),
},
{
itemId: 'versioninfo',
style: {
'text-align': 'center',
},
- }
+ },
],
},
{
return '<i class="fa fa-fw ' + classes + '"></i>';
},
sorter: {
- sorterFn: function(a,b) {
+ sorterFn: function(a, b) {
var healthArr = ['HEALTH_ERR', 'HEALTH_WARN', 'HEALTH_OK'];
return healthArr.indexOf(b.data.severity) - healthArr.indexOf(a.data.severity);
- }
- }
+ },
+ },
},
{
dataIndex: 'summary',
header: gettext('Summary'),
- flex: 1
+ flex: 1,
},
{
xtype: 'actioncolumn',
width: 650,
height: 400,
layout: {
- type: 'fit'
+ type: 'fit',
},
items: [{
scrollable: true,
xtype: 'box',
html: [
'<span>' + Ext.htmlEncode(record.data.summary) + '</span>',
- '<pre>' + Ext.htmlEncode(record.data.detail) + '</pre>'
- ]
- }]
+ '<pre>' + Ext.htmlEncode(record.data.detail) + '</pre>',
+ ],
+ }],
});
win.show();
- }
- }
- ]
- }
- ]
- }
- ]
+ },
+ },
+ ],
+ },
+ ],
+ },
+ ],
},
{
xtype: 'pveCephStatusDetail',
responsiveConfig: {
'width < 1900': {
columnWidth: 1,
- minHeight: 250
+ minHeight: 250,
},
'width >= 1900': {
columnWidth: 0.5,
- minHeight: 300
- }
+ minHeight: 300,
+ },
},
- title: gettext('Status')
+ title: gettext('Status'),
},
{
title: gettext('Services'),
plugins: 'responsive',
layout: {
type: 'hbox',
- align: 'stretch'
+ align: 'stretch',
},
responsiveConfig: {
'width < 1900': {
columnWidth: 1,
- minHeight: 200
+ minHeight: 200,
},
'width >= 1900': {
columnWidth: 0.5,
- minHeight: 200
- }
- }
+ minHeight: 200,
+ },
+ },
},
{
xtype: 'panel',
bodyPadding: 5,
layout: {
type: 'hbox',
- align: 'center'
+ align: 'center',
},
items: [
{
{
xtype: 'proxmoxGauge',
itemId: 'space',
- title: gettext('Usage')
+ title: gettext('Usage'),
},
{
flex: 1,
xtype: 'progressbar',
itemId: 'recoveryprogress',
},
- ]
+ ],
},
- ]
+ ],
},
{
flex: 2,
xtype: 'container',
defaults: {
padding: 0,
- height: 100
+ height: 100,
},
items: [
{
itemId: 'reads',
xtype: 'pveRunningChart',
title: gettext('Reads'),
- renderer: PVE.Utils.render_bandwidth
+ renderer: PVE.Utils.render_bandwidth,
},
{
itemId: 'writes',
xtype: 'pveRunningChart',
title: gettext('Writes'),
- renderer: PVE.Utils.render_bandwidth
+ renderer: PVE.Utils.render_bandwidth,
},
{
itemId: 'readiops',
xtype: 'pveRunningChart',
title: 'IOPS: ' + gettext('Reads'),
- renderer: Ext.util.Format.numberRenderer('0,000')
+ renderer: Ext.util.Format.numberRenderer('0,000'),
},
{
itemId: 'writeiops',
xtype: 'pveRunningChart',
title: 'IOPS: ' + gettext('Writes'),
- renderer: Ext.util.Format.numberRenderer('0,000')
+ renderer: Ext.util.Format.numberRenderer('0,000'),
},
- ]
- }
- ]
- }
+ ],
+ },
+ ],
+ },
],
generateCheckData: function(health) {
function(first, second) {
return first + '\n' + second.message;
},
- ''
+ '',
),
- severity: checks[key].severity
+ severity: checks[key].severity,
});
});
var text = Ext.String.format(gettext('{0} of {1}'),
PVE.Utils.render_size(used),
- PVE.Utils.render_size(total)
+ PVE.Utils.render_size(total),
);
// update the usage widget
interval: 5000,
proxy: {
type: 'proxmox',
- url: baseurl + '/status'
- }
+ url: baseurl + '/status',
+ },
});
me.metadatastore = Ext.create('Proxmox.data.UpdateStore', {
interval: 15*1000,
proxy: {
type: 'proxmox',
- url: '/api2/json/cluster/ceph/metadata'
- }
+ url: '/api2/json/cluster/ceph/metadata',
+ },
});
// save references for the updatefunction
me.mon(win, 'cephInstallWindowClosed', function(){
me.store.startUpdate();
});
- }
+ },
);
});
me.on('destroy', me.metadatastore.stopUpdate);
me.store.startUpdate();
me.metadatastore.startUpdate();
- }
+ },
});
layout: {
type: 'hbox',
- align: 'stretch'
+ align: 'stretch',
},
bodyPadding: '0 5',
defaults: {
xtype: 'box',
style: {
- 'text-align':'center'
- }
+ 'text-align':'center',
+ },
},
items: [{
upout: 0,
downin: 0,
downout: 0,
- oldosds: []
+ oldosds: [],
},
tpl: [
'<h3>' + 'OSDs' + '</h3>',
'<div style="clear:both"></div>',
'</tpl>',
'</div>',
- '</tpl>'
- ]
+ '</tpl>',
+ ],
},
{
flex: 1,
'#CFCFCF',
'#21BF4B',
'#FFCC00',
- '#FF6C59'
+ '#FF6C59',
],
store: { },
series: [
state.state_name + ': ' + state.count.toString();
});
tooltip.setHtml(html);
- }
+ },
},
subStyle: {
- strokeStyle: false
- }
- }
- ]
+ strokeStyle: false,
+ },
+ },
+ ],
},
{
flex: 1.6,
maxHeight: 250,
scrollable: true,
data: {
- states: []
+ states: [],
},
tpl: [
'<h3>' + 'PGs' + '</h3>',
'<div class="left-aligned"><i class ="fa fa-circle {cls}"></i> {state_name}:</div>',
'<div class="right-aligned">{count}</div><br />',
'<div style="clear:both"></div>',
- '</tpl>'
- ]
+ '</tpl>',
+ ],
}],
// similar to mgr dashboard
recovery_unfound: 3,
snaptrim_error: 3,
stale: 3,
- undersized: 3
+ undersized: 3,
},
statecategories: [
text: gettext('Unknown'),
count: 0,
states: [],
- cls: 'faded'
+ cls: 'faded',
},
{
text: gettext('Clean'),
- cls: 'good'
+ cls: 'good',
},
{
text: gettext('Working'),
- cls: 'warning'
+ cls: 'warning',
},
{
text: gettext('Error'),
- cls: 'critical'
- }
+ cls: 'critical',
+ },
],
updateAll: function(metadata, status) {
if (version != maxversion) {
oldosds.push({
id: osd.id,
- version: version
+ version: version,
});
}
});
// update PGs sorted
var pgmap = status.pgmap || {};
var pgs_by_state = pgmap.pgs_by_state || [];
- pgs_by_state.sort(function(a,b){
+ pgs_by_state.sort(function(a, b){
return (a.state_name < b.state_name)?-1:(a.state_name === b.state_name)?0:1;
});
if (key === 'OSD_DOWN') {
found = value.summary.message.match(downinregex);
if (found !== null) {
- downin_osds = parseInt(found[1],10);
+ downin_osds = parseInt(found[1], 10);
}
}
});
upout: upout_osds,
downin: downin_osds,
downout: downout_osds,
- oldosds: oldosds
+ oldosds: oldosds,
};
var osdcomponent = me.getComponent('osds');
osdcomponent.update(Ext.apply(osdcomponent.data, osds));
me.suspendLayout = false;
me.updateLayout();
- }
+ },
});
maxfiles.reset();
}
maxfiles.setDisabled(!hasBackups);
- }
- }
- }
+ },
+ },
+ },
});
renderer: PVE.Utils.render_resource_type,
sortable: true,
hideable: false,
- width: 100
+ width: 100,
},
id: {
header: 'ID',
type: 'string',
hidden: true,
sortable: true,
- width: 80
+ width: 80,
},
running: {
header: gettext('Online'),
convert: function(value, record) {
var info = record.data;
return (Ext.isNumeric(info.uptime) && (info.uptime > 0));
- }
+ },
},
text: {
header: gettext('Description'),
}
return text;
- }
+ },
},
vmid: {
header: 'VMID',
type: 'integer',
hidden: true,
sortable: true,
- width: 80
+ width: 80,
},
name: {
header: gettext('Name'),
hidden: true,
sortable: true,
- type: 'string'
+ type: 'string',
},
disk: {
header: gettext('Disk usage'),
renderer: PVE.Utils.render_disk_usage,
sortable: true,
width: 100,
- hidden: true
+ hidden: true,
},
diskuse: {
header: gettext('Disk usage') + " %",
renderer: PVE.Utils.render_disk_usage_percent,
width: 100,
calculate: PVE.Utils.calculate_disk_usage,
- sortType: 'asFloat'
+ sortType: 'asFloat',
},
maxdisk: {
header: gettext('Disk size'),
renderer: PVE.Utils.render_size,
sortable: true,
hidden: true,
- width: 100
+ width: 100,
},
mem: {
header: gettext('Memory usage'),
renderer: PVE.Utils.render_mem_usage,
sortable: true,
hidden: true,
- width: 100
+ width: 100,
},
memuse: {
header: gettext('Memory usage') + " %",
calculate: PVE.Utils.calculate_mem_usage,
sortType: 'asFloat',
sortable: true,
- width: 100
+ width: 100,
},
maxmem: {
header: gettext('Memory size'),
renderer: PVE.Utils.render_size,
hidden: true,
sortable: true,
- width: 100
+ width: 100,
},
cpu: {
header: gettext('CPU usage'),
type: 'float',
renderer: PVE.Utils.render_cpu,
sortable: true,
- width: 100
+ width: 100,
},
maxcpu: {
header: gettext('maxcpu'),
type: 'integer',
hidden: true,
sortable: true,
- width: 60
+ width: 60,
},
diskread: {
header: gettext('Total Disk Read'),
hidden: true,
sortable: true,
renderer: Proxmox.Utils.format_size,
- width: 100
+ width: 100,
},
diskwrite: {
header: gettext('Total Disk Write'),
hidden: true,
sortable: true,
renderer: Proxmox.Utils.format_size,
- width: 100
+ width: 100,
},
netin: {
header: gettext('Total NetIn'),
hidden: true,
sortable: true,
renderer: Proxmox.Utils.format_size,
- width: 100
+ width: 100,
},
netout: {
header: gettext('Total NetOut'),
hidden: true,
sortable: true,
renderer: Proxmox.Utils.format_size,
- width: 100
+ width: 100,
},
template: {
header: gettext('Template'),
type: 'integer',
hidden: true,
sortable: true,
- width: 60
+ width: 60,
},
uptime: {
header: gettext('Uptime'),
type: 'integer',
renderer: Proxmox.Utils.render_uptime,
sortable: true,
- width: 110
+ width: 110,
},
node: {
header: gettext('Node'),
type: 'string',
hidden: true,
sortable: true,
- width: 110
+ width: 110,
},
storage: {
header: gettext('Storage'),
type: 'string',
hidden: true,
sortable: true,
- width: 110
+ width: 110,
},
pool: {
header: gettext('Pool'),
type: 'string',
hidden: true,
sortable: true,
- width: 110
+ width: 110,
},
hastate: {
header: gettext('HA State'),
type: 'string',
defaultValue: 'unmanaged',
hidden: true,
- sortable: true
+ sortable: true,
},
status: {
header: gettext('Status'),
type: 'string',
hidden: true,
sortable: true,
- width: 110
+ width: 110,
},
lock: {
header: gettext('Lock'),
type: 'string',
hidden: true,
sortable: true,
- width: 110
- }
+ width: 110,
+ },
};
var fields = [];
fields: fields,
proxy: {
type: 'proxmox',
- url: '/api2/json/cluster/resources'
- }
+ url: '/api2/json/cluster/resources',
+ },
});
Ext.define('PVETree', {
extend: "Ext.data.Model",
fields: fields,
- proxy: { type: 'memory' }
+ proxy: { type: 'memory' },
});
Ext.apply(config, {
});
return res;
},
- fieldNames: fieldNames
+ fieldNames: fieldNames,
});
me.callParent([config]);
- }
+ },
});
// percentage
convert: function(value) {
return value*100;
- }
+ },
},
{
name:'iowait',
// percentage
convert: function(value) {
return value*100;
- }
+ },
},
'loadavg',
'maxcpu',
'rootused',
'swaptotal',
'swapused',
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
- ]
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
+ ],
});
Ext.define('pve-rrd-guest', {
// percentage
convert: function(value) {
return value*100;
- }
+ },
},
'maxcpu',
'netin',
'maxdisk',
'diskread',
'diskwrite',
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
- ]
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
+ ],
});
Ext.define('pve-rrd-storage', {
fields: [
'used',
'total',
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
- ]
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
+ ],
});
name: 'path',
value: me.path,
allowBlank: false,
- fieldLabel: gettext('Path')
- }
+ fieldLabel: gettext('Path'),
+ },
];
if (me.aclType === 'group') {
items.push({
xtype: 'pveGroupSelector',
name: 'groups',
- fieldLabel: gettext('Group')
+ fieldLabel: gettext('Group'),
});
} else if (me.aclType === 'user') {
me.subject = gettext("User Permission");
items.push({
xtype: 'pveUserSelector',
name: 'users',
- fieldLabel: gettext('User')
+ fieldLabel: gettext('User'),
});
} else if (me.aclType === 'token') {
me.subject = gettext("API Token Permission");
items.push({
xtype: 'pveTokenSelector',
name: 'tokens',
- fieldLabel: gettext('API Token')
+ fieldLabel: gettext('API Token'),
});
} else {
throw "unknown ACL type";
xtype: 'pmxRoleSelector',
name: 'roles',
value: 'NoAccess',
- fieldLabel: gettext('Role')
+ fieldLabel: gettext('Role'),
});
if (!me.path) {
name: 'propagate',
checked: true,
uncheckedValue: 0,
- fieldLabel: gettext('Propagate')
+ fieldLabel: gettext('Propagate'),
});
}
var ipanel = Ext.create('Proxmox.panel.InputPanel', {
items: items,
- onlineHelp: 'pveum_permission_management'
+ onlineHelp: 'pveum_permission_management',
});
Ext.apply(me, {
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
- }
+ },
});
Ext.define('PVE.dc.ACLView', {
initComponent : function() {
var me = this;
- var store = Ext.create('Ext.data.Store',{
+ var store = Ext.create('Ext.data.Store', {
model: 'pve-acl',
proxy: {
type: 'proxmox',
- url: "/api2/json/access/acl"
+ url: "/api2/json/access/acl",
},
sorters: {
property: 'path',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
if (me.path) {
- store.addFilter(Ext.create('Ext.util.Filter',{
+ store.addFilter(Ext.create('Ext.util.Filter', {
filterFn: function(item) {
if (item.data.path === me.path) {
return true;
}
- }
+ },
}));
}
flex: 1,
sortable: true,
renderer: render_ugid,
- dataIndex: 'ugid'
+ dataIndex: 'ugid',
},
{
header: gettext('Role'),
flex: 1,
sortable: true,
- dataIndex: 'roleid'
- }
+ dataIndex: 'roleid',
+ },
];
if (!me.path) {
header: gettext('Path'),
flex: 1,
sortable: true,
- dataIndex: 'path'
+ dataIndex: 'path',
});
columns.push({
header: gettext('Propagate'),
width: 80,
sortable: true,
- dataIndex: 'propagate'
+ dataIndex: 'propagate',
});
}
var params = {
'delete': 1,
path: rec.data.path,
- roles: rec.data.roleid
+ roles: rec.data.roleid,
};
if (rec.data.type === 'group') {
params.groups = rec.data.ugid;
},
failure: function (response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
});
Proxmox.Utils.monStoreErrors(me, store);
text: gettext('Group Permission'),
iconCls: 'fa fa-fw fa-group',
handler: function() {
- var win = Ext.create('PVE.dc.ACLAdd',{
+ var win = Ext.create('PVE.dc.ACLAdd', {
aclType: 'group',
- path: me.path
+ path: me.path,
});
win.on('destroy', reload);
win.show();
- }
+ },
},
{
text: gettext('User Permission'),
iconCls: 'fa fa-fw fa-user',
handler: function() {
- var win = Ext.create('PVE.dc.ACLAdd',{
+ var win = Ext.create('PVE.dc.ACLAdd', {
aclType: 'user',
- path: me.path
+ path: me.path,
});
win.on('destroy', reload);
win.show();
- }
+ },
},
{
text: gettext('API Token Permission'),
iconCls: 'fa fa-fw fa-user-o',
handler: function() {
- var win = Ext.create('PVE.dc.ACLAdd',{
+ var win = Ext.create('PVE.dc.ACLAdd', {
aclType: 'token',
- path: me.path
+ path: me.path,
});
win.on('destroy', reload);
win.show();
- }
- }
- ]
- }
+ },
+ },
+ ],
+ },
},
- remove_btn
+ remove_btn,
],
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: columns,
listeners: {
- activate: reload
- }
+ activate: reload,
+ },
});
me.callParent();
- }
+ },
}, function() {
Ext.define('pve-acl', {
'path', 'type', 'ugid', 'roleid',
{
name: 'propagate',
- type: 'boolean'
- }
- ]
+ type: 'boolean',
+ },
+ ],
});
});
}
var vmidField = Ext.create('Ext.form.field.Hidden', {
- name: 'vmid'
+ name: 'vmid',
});
// 'value' can be assigned a string or an array
['include', gettext('Include selected VMs')],
['all', gettext('All')],
['exclude', gettext('Exclude selected VMs')],
- ['pool', gettext('Pool based')]
+ ['pool', gettext('Pool based')],
],
fieldLabel: gettext('Selection mode'),
name: 'selMode',
- value: ''
+ value: '',
});
var sm = Ext.create('Ext.selection.CheckboxModel', {
vmidField.suspendEvent('change');
vmidField.setValue(sel);
vmidField.resumeEvent('change');
- }
- }
+ },
+ },
});
var storagesel = Ext.create('PVE.form.StorageSelector', {
} else if (!compressionSelector.getEditable()) {
compressionSelector.setDisabled(false);
}
- }
- }
+ },
+ },
});
var store = new Ext.data.Store({
model: 'PVEResources',
sorters: {
property: 'vmid',
- order: 'ASC'
- }
+ order: 'ASC',
+ },
});
var vmgrid = Ext.createWidget('grid', {
{
header: 'ID',
dataIndex: 'vmid',
- width: 60
+ width: 60,
},
{
header: gettext('Node'),
- dataIndex: 'node'
+ dataIndex: 'node',
},
{
header: gettext('Status'),
} else {
return Proxmox.Utils.stoppedText;
}
- }
+ },
},
{
header: gettext('Name'),
dataIndex: 'name',
- flex: 1
+ flex: 1,
},
{
header: gettext('Type'),
- dataIndex: 'type'
- }
- ]
+ dataIndex: 'type',
+ },
+ ],
});
var selectPoolMembers = function(poolid) {
{
id: 'poolFilter',
property: 'pool',
- value: poolid
- }
+ value: poolid,
+ },
]);
sm.selectAll(true);
};
listeners: {
change: function( selpool, newValue, oldValue) {
selectPoolMembers(newValue);
- }
- }
+ },
+ },
});
var nodesel = Ext.create('PVE.form.NodeSelector', {
if (mode === 'pool') {
selectPoolMembers(selPool.value);
}
- }
- }
+ },
+ },
});
var column1 = [
fieldLabel: gettext('Day of week'),
multiSelect: true,
value: ['sat'],
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'timefield',
format: 'H:i',
formatText: 'HH:MM',
value: '00:00',
- allowBlank: false
+ allowBlank: false,
},
selModeField,
- selPool
+ selPool,
];
var column2 = [
{
xtype: 'textfield',
fieldLabel: gettext('Send email to'),
- name: 'mailto'
+ name: 'mailto',
},
{
xtype: 'pveEmailNotificationSelector',
fieldLabel: gettext('Email notification'),
name: 'mailnotification',
deleteEmpty: me.isCreate ? false : true,
- value: me.isCreate ? 'always' : ''
+ value: me.isCreate ? 'always' : '',
},
{
xtype: 'pveCompressionSelector',
fieldLabel: gettext('Compression'),
name: 'compress',
deleteEmpty: me.isCreate ? false : true,
- value: 'zstd'
+ value: 'zstd',
},
{
xtype: 'pveBackupModeSelector',
fieldLabel: gettext('Mode'),
value: 'snapshot',
- name: 'mode'
+ name: 'mode',
},
{
xtype: 'proxmoxcheckbox',
name: 'enabled',
uncheckedValue: 0,
defaultValue: 1,
- checked: true
+ checked: true,
},
- vmidField
+ vmidField,
];
var ipanel = Ext.create('Proxmox.panel.InputPanel', {
delete values.pool;
}
return values;
- }
+ },
});
var update_vmid_selection = function(list, mode) {
} else {
update_vmid_selection(list, mode);
}
- }
+ },
});
};
subject: gettext("Backup Job"),
url: url,
method: method,
- items: [ ipanel, vmgrid ]
+ items: [ ipanel, vmgrid ],
});
me.callParent();
}
me.setValues(data);
- }
+ },
});
}
reload();
- }
+ },
});
scope: this,
callback: function(panel) {
panel.collapseAll();
- }
+ },
},
],
} else {
return txt + 'question-circle';
}
- }
- }
+ },
+ },
],
header: {
items: [{
});
return match;
});
- }
- }
- }
+ },
+ },
+ },
]},
});
me.callParent();
me.reload();
- }
+ },
});
Ext.define('PVE.dc.BackupInfo', {
name: 'pool',
fieldLabel: gettext('Pool to backup'),
xtype: 'displayfield',
- }
+ },
],
column2: [
{
me.callParent();
me.setValues(me.record);
- }
+ },
});
});
return match;
});
- }
- }
- }
+ },
+ },
+ },
],
viewConfig: {
stripeRows: true,
model: 'pve-cluster-backup',
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/backup"
- }
+ url: "/api2/json/cluster/backup",
+ },
});
var not_backed_store = new Ext.data.Store({
}
var win = Ext.create('PVE.dc.BackupEdit', {
- jobid: rec.data.id
+ jobid: rec.data.id,
});
win.on('destroy', reload);
win.show();
region: 'center',
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [infoview, disktree],
- }]
+ }],
}).show();
};
errors.push(node + ': ' + response.htmlStatus);
postRequest();
},
- success: postRequest
+ success: postRequest,
}));
};
region: 'center',
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [backedinfo],
- }]
+ }],
}).show();
};
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
var run_btn = new Proxmox.button.Button({
return;
}
run_backup_now(rec.data);
- }
+ },
});
- }
+ },
});
var remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
baseurl: '/cluster/backup',
callback: function() {
reload();
- }
+ },
});
var detail_btn = new Proxmox.button.Button({
stateful: true,
stateId: 'grid-dc-backup',
viewConfig: {
- trackOver: false
+ trackOver: false,
},
tbar: [
{
text: gettext('Add'),
handler: function() {
- var win = Ext.create('PVE.dc.BackupEdit',{});
+ var win = Ext.create('PVE.dc.BackupEdit', {});
win.on('destroy', reload);
win.show();
- }
+ },
},
'-',
remove_btn,
sortable: true,
disabled: true,
disabledCls: 'x-item-enabled',
- stopSelection: false
+ stopSelection: false,
},
{
header: gettext('Node'),
return value;
}
return me.allText;
- }
+ },
},
{
header: gettext('Day of week'),
width: 200,
sortable: false,
dataIndex: 'dow',
- renderer: PVE.Utils.render_backup_days_of_week
+ renderer: PVE.Utils.render_backup_days_of_week,
},
{
header: gettext('Start Time'),
width: 60,
sortable: true,
- dataIndex: 'starttime'
+ dataIndex: 'starttime',
},
{
header: gettext('Storage'),
width: 100,
sortable: true,
- dataIndex: 'storage'
+ dataIndex: 'storage',
},
{
header: gettext('Selection'),
flex: 1,
sortable: false,
dataIndex: 'vmid',
- renderer: PVE.Utils.render_backup_selection
- }
+ renderer: PVE.Utils.render_backup_selection,
+ },
],
listeners: {
activate: reload,
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
- }
+ },
}, function() {
Ext.define('pve-cluster-backup', {
'storage', 'node', 'vmid', 'exclude',
'mailto', 'pool', 'compress', 'mode',
{ name: 'enabled', type: 'boolean' },
- { name: 'all', type: 'boolean' }
- ]
+ { name: 'all', type: 'boolean' },
+ ],
});
});
extend: 'Ext.data.Model',
fields: [
'node', { type: 'integer', name: 'nodeid' }, 'ring0_addr', 'ring1_addr',
- { type: 'integer', name: 'quorum_votes' }
+ { type: 'integer', name: 'quorum_votes' },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/config/nodes"
+ url: "/api2/json/cluster/config/nodes",
},
- idProperty: 'nodeid'
+ idProperty: 'nodeid',
});
Ext.define('pve-cluster-info', {
extend: 'Ext.data.Model',
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/config/join"
- }
+ url: "/api2/json/cluster/config/join",
+ },
});
Ext.define('PVE.ClusterAdministration', {
preferred_node: {
name: '',
fp: '',
- addr: ''
+ addr: '',
},
isInCluster: false,
- nodecount: 0
- }
+ nodecount: 0,
+ },
},
items: [
autoStart: true,
interval: 15 * 1000,
storeid: 'pve-cluster-info',
- model: 'pve-cluster-info'
+ model: 'pve-cluster-info',
});
view.store.on('load', this.onLoad, this);
view.on('destroy', view.store.stopUpdate);
vm.set('preferred_node', {
name: '',
addr: '',
- fp: ''
+ fp: '',
});
return;
}
addr: nodeinfo.pve_addr,
peerLinks: links,
ring_addr: ring_addr,
- fp: nodeinfo.pve_fp
+ fp: nodeinfo.pve_fp,
});
},
listeners: {
destroy: function() {
view.store.startUpdate();
- }
- }
+ },
+ },
});
},
fingerprint: vm.get('preferred_node.fp'),
peerLinks: vm.get('preferred_node.peerLinks'),
ring_addr: vm.get('preferred_node.ring_addr'),
- totem: vm.get('totem')
- }
+ totem: vm.get('totem'),
+ },
});
win.show();
},
listeners: {
destroy: function() {
view.store.startUpdate();
- }
- }
+ },
+ },
});
- }
+ },
},
tbar: [
{
reference: 'createButton',
handler: 'onCreate',
bind: {
- disabled: '{isInCluster}'
- }
+ disabled: '{isInCluster}',
+ },
},
{
text: gettext('Join Information'),
reference: 'addButton',
handler: 'onClusterInfo',
bind: {
- disabled: '{!isInCluster}'
- }
+ disabled: '{!isInCluster}',
+ },
},
{
text: gettext('Join Cluster'),
reference: 'joinButton',
handler: 'onJoin',
bind: {
- disabled: '{isInCluster}'
- }
- }
+ disabled: '{isInCluster}',
+ },
+ },
],
layout: 'hbox',
bodyPadding: 5,
fieldLabel: gettext('Cluster Name'),
bind: {
value: '{totem.cluster_name}',
- hidden: '{!isInCluster}'
+ hidden: '{!isInCluster}',
},
- flex: 1
+ flex: 1,
},
{
xtype: 'displayfield',
fieldLabel: gettext('Config Version'),
bind: {
value: '{totem.config_version}',
- hidden: '{!isInCluster}'
+ hidden: '{!isInCluster}',
},
- flex: 1
+ flex: 1,
},
{
xtype: 'displayfield',
labelWidth: 120,
bind: {
value: '{nodecount}',
- hidden: '{!isInCluster}'
+ hidden: '{!isInCluster}',
},
- flex: 1
+ flex: 1,
},
{
xtype: 'displayfield',
value: gettext('Standalone node - no cluster defined'),
bind: {
- hidden: '{isInCluster}'
+ hidden: '{isInCluster}',
},
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
},
{
xtype: 'grid',
interval: 5 * 1000,
autoStart: true,
storeid: 'pve-cluster-nodes',
- model: 'pve-cluster-nodes'
+ model: 'pve-cluster-nodes',
});
view.setStore(Ext.create('Proxmox.data.DiffStore', {
rstore: view.rstore,
sorters: {
property: 'nodeid',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
}));
Proxmox.Utils.monStoreErrors(view, view.rstore);
view.rstore.on('load', this.onLoad, this);
return;
}
view.columns[linkIndex+linknum].setHidden(false);
- }
+ },
);
- }
+ },
},
columns: {
items: [
{
header: gettext('Nodename'),
hidden: false,
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
header: gettext('ID'),
width: 100,
flex: 0,
hidden: false,
- dataIndex: 'nodeid'
+ dataIndex: 'nodeid',
},
{
header: gettext('Votes'),
width: 100,
flex: 0,
hidden: false,
- dataIndex: 'quorum_votes'
+ dataIndex: 'quorum_votes',
},
{
header: Ext.String.format(gettext('Link {0}'), 0),
dataIndex: 'ring0_addr',
- linkNumber: 0
+ linkNumber: 0,
},
{
header: Ext.String.format(gettext('Link {0}'), 1),
dataIndex: 'ring1_addr',
- linkNumber: 1
+ linkNumber: 1,
},
{
header: Ext.String.format(gettext('Link {0}'), 2),
dataIndex: 'ring2_addr',
- linkNumber: 2
+ linkNumber: 2,
},
{
header: Ext.String.format(gettext('Link {0}'), 3),
dataIndex: 'ring3_addr',
- linkNumber: 3
+ linkNumber: 3,
},
{
header: Ext.String.format(gettext('Link {0}'), 4),
dataIndex: 'ring4_addr',
- linkNumber: 4
+ linkNumber: 4,
},
{
header: Ext.String.format(gettext('Link {0}'), 5),
dataIndex: 'ring5_addr',
- linkNumber: 5
+ linkNumber: 5,
},
{
header: Ext.String.format(gettext('Link {0}'), 6),
dataIndex: 'ring6_addr',
- linkNumber: 6
+ linkNumber: 6,
},
{
header: Ext.String.format(gettext('Link {0}'), 7),
dataIndex: 'ring7_addr',
- linkNumber: 7
- }
+ linkNumber: 7,
+ },
],
defaults: {
flex: 1,
hidden: true,
- minWidth: 150
- }
- }
- }
- ]
+ minWidth: 150,
+ },
+ },
+ },
+ ],
});
fieldLabel: gettext('Cluster Name'),
allowBlank: false,
maxLength: 15,
- name: 'clustername'
+ name: 'clustername',
},
{
xtype: 'fieldcontainer',
{
xtype: 'pveCorosyncLinkEditor',
infoText: gettext("Multiple links are used as failover, lower numbers have higher priority."),
- name: 'links'
+ name: 'links',
},
- ]
- }]
- }
+ ],
+ }],
+ },
});
Ext.define('PVE.ClusterInfoWindow', {
joinInfo: {
ipAddress: undefined,
fingerprint: undefined,
- totem: {}
+ totem: {},
},
items: [
xtype: 'component',
border: false,
padding: '10 10 10 10',
- html: gettext("Copy the Join Information here and use it on the node you want to add.")
+ html: gettext("Copy the Join Information here and use it on the node you want to add."),
},
{
xtype: 'container',
var jsons = Ext.JSON.encode(field.joinInfo);
var base64s = Ext.util.Base64.encode(jsons);
field.setValue(base64s);
- }
- }
- }
- ]
- }
+ },
+ },
+ },
+ ],
+ },
],
dockedItems: [{
dock: 'bottom',
el.select();
document.execCommand("copy");
},
- text: gettext('Copy Information')
- }]
- }]
+ text: gettext('Copy Information'),
+ }],
+ }],
});
Ext.define('PVE.ClusterJoinNodeWindow', {
info: {
fp: '',
ip: '',
- clusterName: ''
+ clusterName: '',
},
hasAssistedInfo: false,
},
'#': {
close: function() {
delete PVE.Utils.silenceAuthFailures;
- }
+ },
},
'proxmoxcheckbox[name=assistedEntry]': {
- change: 'onInputTypeChange'
+ change: 'onInputTypeChange',
},
'textarea[name=serializedinfo]': {
change: 'recomputeSerializedInfo',
- enable: 'resetField'
+ enable: 'resetField',
},
'textfield': {
- disable: 'resetField'
- }
+ disable: 'resetField',
+ },
},
resetField: function(field) {
field.reset();
let info = {
fp: '',
ip: '',
- clusterName: ''
+ clusterName: '',
};
if (!(joinInfo && joinInfo.totem)) {
number: linkNumber,
value: '',
text: peerLink ? Ext.String.format(gettext("peer's link address: {0}"), peerLink) : '',
- allowBlank: false
+ allowBlank: false,
};
});
info = {
ip: joinInfo.ipAddress,
fp: joinInfo.fingerprint,
- clusterName: joinInfo.totem.cluster_name
+ clusterName: joinInfo.totem.cluster_name,
};
field.valid = true;
vm.set('hasAssistedInfo', true);
}
vm.set('info', info);
- }
+ },
},
submit: function() {
Ext.Msg.show({
title: gettext('Join Task Finished'),
icon: Ext.Msg.INFO,
- msg: txt
+ msg: txt,
});
}
},
value: true,
autoEl: {
tag: 'div',
- 'data-qtip': gettext('Select if join information should be extracted from pasted cluster information, deselect for manual entering')
+ 'data-qtip': gettext('Select if join information should be extracted from pasted cluster information, deselect for manual entering'),
},
- boxLabel: gettext('Assisted join: Paste encoded cluster join information and enter password.')
+ boxLabel: gettext('Assisted join: Paste encoded cluster join information and enter password.'),
},
{
xtype: 'textarea',
},
bind: {
disabled: '{!assistedEntry.checked}',
- hidden: '{!assistedEntry.checked}'
+ hidden: '{!assistedEntry.checked}',
},
- value: ''
+ value: '',
},
{
xtype: 'panel',
width: 776,
layout: {
type: 'hbox',
- align: 'center'
+ align: 'center',
},
bind: {
hidden: '{!showClusterFields}',
value: '{info.ip}',
readOnly: '{assistedEntry.checked}',
},
- name: 'hostname'
+ name: 'hostname',
},
{
xtype: 'textfield',
emptyText: gettext("Peer's root password"),
fieldLabel: gettext('Password'),
allowBlank: false,
- name: 'password'
+ name: 'password',
},
- ]
+ ],
},
{
xtype: 'textfield',
readOnly: '{assistedEntry.checked}',
hidden: '{!showClusterFields}',
},
- name: 'fingerprint'
+ name: 'fingerprint',
},
{
xtype: 'fieldcontainer',
xtype: 'pveCorosyncLinkEditor',
itemId: 'linkEditor',
reference: 'linkEditor',
- allowNumberEdit: false
+ allowNumberEdit: false,
},
- ]
- }]
+ ],
+ }],
});
Ext.apply(me, {
title: gettext("Datacenter"),
- hstateid: 'dctab'
+ hstateid: 'dctab',
});
if (caps.dc['Sys.Audit']) {
title: gettext('Summary'),
xtype: 'pveDcSummary',
iconCls: 'fa fa-book',
- itemId: 'summary'
+ itemId: 'summary',
},
{
title: gettext('Cluster'),
xtype: 'pveClusterAdministration',
iconCls: 'fa fa-server',
- itemId: 'cluster'
+ itemId: 'cluster',
},
{
title: 'Ceph',
itemId: 'ceph',
iconCls: 'fa fa-ceph',
- xtype: 'pveNodeCephStatus'
+ xtype: 'pveNodeCephStatus',
},
{
xtype: 'pveDcOptionView',
title: gettext('Options'),
iconCls: 'fa fa-gear',
- itemId: 'options'
+ itemId: 'options',
});
}
xtype: 'pveStorageView',
title: gettext('Storage'),
iconCls: 'fa fa-database',
- itemId: 'storage'
+ itemId: 'storage',
});
}
xtype: 'pveDcBackupView',
iconCls: 'fa fa-floppy-o',
title: gettext('Backup'),
- itemId: 'backup'
+ itemId: 'backup',
},
{
xtype: 'pveReplicaView',
iconCls: 'fa fa-retweet',
title: gettext('Replication'),
- itemId: 'replication'
+ itemId: 'replication',
},
{
xtype: 'pveACLView',
title: gettext('Permissions'),
iconCls: 'fa fa-unlock',
itemId: 'permissions',
- expandedOnInit: true
+ expandedOnInit: true,
});
}
groups: ['permissions'],
iconCls: 'fa fa-user',
title: gettext('Users'),
- itemId: 'users'
+ itemId: 'users',
});
me.items.push({
groups: ['permissions'],
iconCls: 'fa fa-user-o',
title: gettext('API Tokens'),
- itemId: 'apitokens'
+ itemId: 'apitokens',
});
if (caps.dc['Sys.Audit']) {
title: gettext('Groups'),
iconCls: 'fa fa-users',
groups: ['permissions'],
- itemId: 'groups'
+ itemId: 'groups',
},
{
xtype: 'pvePoolView',
title: gettext('Pools'),
iconCls: 'fa fa-tags',
groups: ['permissions'],
- itemId: 'pools'
+ itemId: 'pools',
},
{
xtype: 'pveRoleView',
title: gettext('Roles'),
iconCls: 'fa fa-male',
groups: ['permissions'],
- itemId: 'roles'
+ itemId: 'roles',
},
{
xtype: 'pveAuthView',
title: gettext('Authentication'),
groups: ['permissions'],
iconCls: 'fa fa-key',
- itemId: 'domains'
+ itemId: 'domains',
},
{
xtype: 'pveHAStatus',
title: 'HA',
iconCls: 'fa fa-heartbeat',
- itemId: 'ha'
+ itemId: 'ha',
},
{
title: gettext('Groups'),
groups: ['ha'],
xtype: 'pveHAGroupsView',
iconCls: 'fa fa-object-group',
- itemId: 'ha-groups'
+ itemId: 'ha-groups',
},
{
title: gettext('Fencing'),
groups: ['ha'],
iconCls: 'fa fa-bolt',
xtype: 'pveFencingView',
- itemId: 'ha-fencing'
+ itemId: 'ha-fencing',
});
if (PVE.SDNInfo || PVE.SDNInfo === undefined) {
me.items.push({
iconCls: 'fa fa-sdn',
hidden: true,
itemId: 'sdn',
- expandedOnInit: true
+ expandedOnInit: true,
},
{
xtype: 'pveSDNControllerView',
title: gettext('Controllers'),
hidden: true,
iconCls: 'fa fa-crosshairs',
- itemId: 'sdncontroller'
+ itemId: 'sdncontroller',
},
{
xtype: 'pveSDNZoneView',
title: gettext('Zones'),
hidden: true,
iconCls: 'fa fa-th',
- itemId: 'sdnzone'
+ itemId: 'sdnzone',
},
{
xtype: 'pveSDNVnetView',
title: gettext('Vnets'),
hidden: true,
iconCls: 'fa fa-network-wired',
- itemId: 'sdnvnet'
+ itemId: 'sdnvnet',
});
}
xtype: 'pveACMEClusterView',
title: 'ACME',
iconCls: 'fa fa-certificate',
- itemId: 'acme'
+ itemId: 'acme',
});
}
base_url: '/cluster/firewall/rules',
list_refs_url: '/cluster/firewall/refs',
iconCls: 'fa fa-shield',
- itemId: 'firewall'
+ itemId: 'firewall',
},
{
xtype: 'pveFirewallOptions',
base_url: '/cluster/firewall/options',
onlineHelp: 'pve_firewall_cluster_wide_setup',
fwtype: 'dc',
- itemId: 'firewall-options'
+ itemId: 'firewall-options',
},
{
xtype: 'pveSecurityGroups',
title: gettext('Security Group'),
groups: ['firewall'],
iconCls: 'fa fa-group',
- itemId: 'firewall-sg'
+ itemId: 'firewall-sg',
},
{
xtype: 'pveFirewallAliases',
groups: ['firewall'],
iconCls: 'fa fa-external-link',
base_url: '/cluster/firewall/aliases',
- itemId: 'firewall-aliases'
+ itemId: 'firewall-aliases',
},
{
xtype: 'pveIPSet',
iconCls: 'fa fa-list-ol',
base_url: '/cluster/firewall/ipset',
list_refs_url: '/cluster/firewall/refs',
- itemId: 'firewall-ipset'
+ itemId: 'firewall-ipset',
},
{
xtype: 'pveMetricServerView',
xtype: 'pveDcSupport',
title: gettext('Support'),
itemId: 'support',
- iconCls: 'fa fa-comments-o'
+ iconCls: 'fa fa-comments-o',
});
}
me.callParent();
- }
+ },
});
view.remove(this);
me.updateDeleteButtonState();
- }
+ },
});
view.add(linkSelector);
// all numbers in use, this should never happen since add button is
// disabled automatically
return 0;
- }
+ },
});
Ext.define('PVE.form.CorosyncLinkSelector', {
fieldLabel: 'Link',
cbind: {
hidden: '{allowNumberEdit}',
- value: '{initNumber}'
+ value: '{initNumber}',
},
width: 45,
labelWidth: 30,
cbind: {
maxValue: '{maxLinkNumber}',
hidden: '{!allowNumberEdit}',
- value: '{initNumber}'
+ value: '{initNumber}',
},
width: 80,
labelWidth: 30,
let linkNumber = numSelect.getValue();
me.name = 'link' + linkNumber;
return me.getValue();
- }
+ },
},
{
xtype: 'button',
iconCls: 'fa fa-trash-o',
cls: 'removeLinkBtn',
cbind: {
- hidden: '{!allowNumberEdit}'
+ hidden: '{!allowNumberEdit}',
},
handler: function() {
let me = this;
if (parent.removeBtnHandler !== undefined) {
parent.removeBtnHandler();
}
- }
+ },
},
{
xtype: 'label',
cls: 'x-form-item-label-default',
cbind: {
- text: '{text}'
- }
- }
+ text: '{text}',
+ },
+ },
],
initComponent: function() {
numSelect.validator = this.createNoDuplicatesValidator(
'numberfield',
- gettext("Duplicate link number not allowed.")
+ gettext("Duplicate link number not allowed."),
);
netSelect.validator = this.createNoDuplicatesValidator(
'proxmoxNetworkSelector',
- gettext("Duplicate link address not allowed.")
+ gettext("Duplicate link address not allowed."),
);
},
return err || true;
};
- }
+ },
});
Ext.define('PVE.form.CorosyncLinkEditor', {
maxLinkCount: 8,
networks: null,
allowNumberEdit: true,
- infoText: ''
+ infoText: '',
},
formulas: {
addDisabled: function(get) {
},
dockHidden: function(get) {
return !(get('allowNumberEdit') || get('infoText'));
- }
- }
+ },
+ },
},
dockedItems: [{
border: false,
padding: '6 0 6 0',
bind: {
- hidden: '{dockHidden}'
+ hidden: '{dockHidden}',
},
items: [
{
text: gettext('Add'),
bind: {
disabled: '{addDisabled}',
- hidden: '{!allowNumberEdit}'
+ hidden: '{!allowNumberEdit}',
},
- handler: 'addEmptyLink'
+ handler: 'addEmptyLink',
},
{
xtype: 'label',
bind: {
- text: '{infoText}'
- }
- }
- ]
+ text: '{infoText}',
+ },
+ },
+ ],
}],
setInfoText: function(text) {
let me = this;
let vm = me.up('pveCorosyncLinkEditor').getViewModel();
return vm.get('linkCount') > 0;
- }
+ },
}],
initComponent: function() {
if (vm.get('allowNumberEdit')) {
controller.addLinkIfEmpty();
}
- }
+ },
});
- }
+ },
});
fieldLabel: gettext('Name'),
name: 'groupid',
value: me.groupid,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
fieldLabel: gettext('Comment'),
name: 'comment',
- allowBlank: true
- }
- ]
+ allowBlank: true,
+ },
+ ],
});
me.callParent();
if (!me.isCreate) {
me.load();
}
- }
+ },
});
model: 'pve-groups',
sorters: {
property: 'groupid',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var reload = function() {
callback: function() {
reload();
},
- baseurl: '/access/groups/'
+ baseurl: '/access/groups/',
});
var run_editor = function() {
return;
}
- var win = Ext.create('PVE.dc.GroupEdit',{
- groupid: rec.data.groupid
+ var win = Ext.create('PVE.dc.GroupEdit', {
+ groupid: rec.data.groupid,
});
win.on('destroy', reload);
win.show();
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
var tbar = [
var win = Ext.create('PVE.dc.GroupEdit', {});
win.on('destroy', reload);
win.show();
- }
+ },
},
- edit_btn, remove_btn
+ edit_btn, remove_btn,
];
Proxmox.Utils.monStoreErrors(me, store);
selModel: sm,
tbar: tbar,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
header: gettext('Name'),
width: 200,
sortable: true,
- dataIndex: 'groupid'
+ dataIndex: 'groupid',
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
- flex: 1
+ flex: 1,
},
{
header: gettext('Users'),
sortable: false,
dataIndex: 'users',
renderer: Ext.String.htmlEncode,
- flex: 1
- }
+ flex: 1,
+ },
],
listeners: {
activate: reload,
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
- }
+ },
});
columns: 2,
tableAttrs: {
style: {
- width: '100%'
- }
- }
+ width: '100%',
+ },
+ },
},
bodyPadding: '0 20 20 20',
padding: '0 50 0 50',
style: {
'text-align':'center',
- 'line-height':'1.2'
- }
+ 'line-height':'1.2',
+ },
},
items: [{
itemId: 'qemu',
running: 0,
paused: 0,
stopped: 0,
- template: 0
+ template: 0,
},
tpl: [
'<h3>' + gettext("Virtual Machines") + '</h3>',
gettext('Templates'),
'</div>',
'<div class="right-aligned">{template}</div>',
- '</tpl>'
- ]
- },{
+ '</tpl>',
+ ],
+ }, {
itemId: 'lxc',
data: {
running: 0,
paused: 0,
stopped: 0,
- template: 0
+ template: 0,
},
tpl: [
'<h3>' + gettext("LXC Container") + '</h3>',
gettext('Templates'),
'</div>',
'<div class="right-aligned">{template}</div>',
- '</tpl>'
- ]
- },{
+ '</tpl>',
+ ],
+ }, {
itemId: 'error',
colspan: 2,
data: {
- num: 0
+ num: 0,
},
columnWidth: 1,
padding: '10 250 0 250',
gettext('Error'),
'</div>',
'<div class="right-aligned">{num}</div>',
- '</tpl>'
- ]
+ '</tpl>',
+ ],
}],
updateValues: function(qemu, lxc, error) {
me.getComponent('qemu').update(qemu);
me.getComponent('lxc').update(lxc);
me.getComponent('error').update({num: error});
- }
+ },
});
height: 250,
layout: {
type: 'hbox',
- align: 'stretch'
+ align: 'stretch',
},
defaults: {
flex: 1,
xtype: 'box',
style: {
- 'text-align':'center'
- }
+ 'text-align':'center',
+ },
},
nodeList: [],
var cluster = {
iconCls: PVE.Utils.get_health_icon('good', true),
- text: gettext("Standalone node - no cluster defined")
+ text: gettext("Standalone node - no cluster defined"),
};
var nodes = {
online: 0,
- offline: 0
+ offline: 0,
};
// by default we have one node
destroy: function() {
var me = this;
me.cephstore.stopUpdate();
- }
+ },
},
items: [
{
itemId: 'clusterstatus',
xtype: 'pveHealthWidget',
- title: gettext('Status')
+ title: gettext('Status'),
},
{
itemId: 'nodestatus',
data: {
online: 0,
- offline: 0
+ offline: 0,
},
tpl: [
'<h3>' + gettext('Nodes') + '</h3><br />',
gettext('Offline'),
'</div>',
'<div class="right-aligned">{offline}</div>',
- '</div>'
- ]
+ '</div>',
+ ],
},
{
itemId: 'ceph',
click: function() {
var sp = Ext.state.Manager.getProvider();
sp.set('dctab', {value:'ceph'}, true);
- }
- }
- }
+ },
+ },
+ },
],
initComponent: function() {
storeid: 'pve-cluster-ceph',
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodeList[me.nodeIndex].node + '/ceph/status'
- }
+ url: '/api2/json/nodes/' + me.nodeList[me.nodeIndex].node + '/ceph/status',
+ },
});
me.callParent();
me.mon(me.cephstore, 'load', me.updateCeph, me);
me.cephstore.startUpdate();
- }
+ },
});
model: 'proxmox-cluster-log',
proxy: {
type: 'proxmox',
- url: '/api2/json/cluster/log'
- }
+ url: '/api2/json/cluster/log',
+ },
});
var store = Ext.create('Proxmox.data.DiffStore', {
rstore: logstore,
- appendAtStart: true
+ appendAtStart: true,
});
Ext.apply(me, {
if (pri && pri <= 3) {
return "proxmox-invalid-row";
}
- }
+ },
},
sortableColumns: false,
columns: [
width: 150,
renderer: function(value) {
return Ext.Date.format(value, "M d H:i:s");
- }
+ },
},
{
header: gettext("Node"),
dataIndex: 'node',
- width: 150
+ width: 150,
},
{
header: gettext("Service"),
dataIndex: 'tag',
- width: 100
+ width: 100,
},
{
header: "PID",
dataIndex: 'pid',
- width: 100
+ width: 100,
},
{
header: gettext("User name"),
dataIndex: 'user',
renderer: Ext.String.htmlEncode,
- width: 150
+ width: 150,
},
{
header: gettext("Severity"),
dataIndex: 'pri',
renderer: PVE.Utils.render_serverity,
- width: 100
+ width: 100,
},
{
header: gettext("Message"),
dataIndex: 'msg',
renderer: Ext.String.htmlEncode,
- flex: 1
- }
+ flex: 1,
+ },
],
listeners: {
activate: () => logstore.startUpdate(),
deactivate: () => logstore.stopUpdate(),
destroy: () => logstore.stopUpdate(),
- }
+ },
});
me.callParent();
- }
+ },
});
header: gettext('Name'),
flex: 1,
sortable: true,
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
header: 'ID',
width: 40,
sortable: true,
- dataIndex: 'nodeid'
+ dataIndex: 'nodeid',
},
{
header: gettext('Online'),
renderer: function(value) {
var cls = (value)?'good':'critical';
return '<i class="fa ' + PVE.Utils.get_health_icon(cls) + '"><i/>';
- }
+ },
},
{
header: gettext('Support'),
width: 100,
sortable: true,
dataIndex: 'level',
- renderer: PVE.Utils.render_support_level
+ renderer: PVE.Utils.render_support_level,
},
{
header: gettext('Server Address'),
width: 115,
sortable: true,
- dataIndex: 'ip'
+ dataIndex: 'ip',
},
{
header: gettext('CPU usage'),
tdCls: 'x-progressbar-default-cell',
xtype: 'widgetcolumn',
widget: {
- xtype: 'pveProgressBar'
- }
+ xtype: 'pveProgressBar',
+ },
},
{
header: gettext('Memory usage'),
dataIndex: 'memoryusage',
xtype: 'widgetcolumn',
widget: {
- xtype: 'pveProgressBar'
- }
+ xtype: 'pveProgressBar',
+ },
},
{
header: gettext('Uptime'),
sortable: true,
dataIndex: 'uptime',
align: 'right',
- renderer: Proxmox.Utils.render_uptime
- }
+ renderer: Proxmox.Utils.render_uptime,
+ },
],
stateful: true,
var me = this.up('grid');
var height = Math.max(me.getHeight()-50, 250);
me.setHeight(height);
- }
+ },
},
{
type: 'down',
var me = this.up('grid');
var height = me.getHeight()+50;
me.setHeight(height);
- }
- }
- ]
+ },
+ },
+ ],
}, function() {
Ext.define('pve-dc-nodes', {
extend: 'Ext.data.Model',
fields: [ 'id', 'type', 'name', 'nodeid', 'ip', 'level', 'local', 'online'],
- idProperty: 'id'
+ idProperty: 'id',
});
});
-Ext.define('PVE.widget.ProgressBar',{
+Ext.define('PVE.widget.ProgressBar', {
extend: 'Ext.Progress',
alias: 'widget.pveProgressBar',
animate: true,
textTpl: [
- '{percent}%'
+ '{percent}%',
],
setValue: function(value){
} else if (value > 0.59) {
me.addCls('warning');
}
- }
+ },
});
subject: text,
onlineHelp: opts.onlineHelp,
fieldDefaults: {
- labelWidth: opts.labelWidth || 100
+ labelWidth: opts.labelWidth || 100,
},
setValues: function(values) {
var edit_value = values[name];
ret_val[name] = PVE.Parser.printPropertyString(values);
return ret_val;
},
- items: opts.items
- }]
- } : undefined
+ items: opts.items,
+ }],
+ } : undefined,
};
},
renderer: PVE.Utils.render_kvm_language,
comboItems: PVE.Utils.kvm_keymap_array(),
defaultValue: '__default__',
- deleteEmpty: true
+ deleteEmpty: true,
});
me.add_text_row('http_proxy', gettext('HTTP proxy'), {
defaultValue: Proxmox.Utils.noneText,
vtype: 'HttpProxy',
- deleteEmpty: true
+ deleteEmpty: true,
});
me.add_combobox_row('console', gettext('Console Viewer'), {
renderer: PVE.Utils.render_console_viewer,
comboItems: PVE.Utils.console_viewer_array(),
defaultValue: '__default__',
- deleteEmpty: true
+ deleteEmpty: true,
});
me.add_text_row('email_from', gettext('Email from address'), {
deleteEmpty: true,
vtype: 'proxmoxMail',
- defaultValue: 'root@$hostname'
+ defaultValue: 'root@$hostname',
});
me.add_text_row('mac_prefix', gettext('MAC address prefix'), {
deleteEmpty: true,
vtype: 'MacPrefix',
- defaultValue: Proxmox.Utils.noneText
+ defaultValue: Proxmox.Utils.noneText,
});
me.add_inputpanel_row('migration', gettext('Migration Settings'), {
renderer: PVE.Utils.render_dc_ha_opts,
value: null,
emptyText: Proxmox.Utils.defaultText,
autoSelect: false,
- skipEmptyText: true
- }]
+ skipEmptyText: true,
+ }],
});
me.add_inputpanel_row('ha', gettext('HA Settings'), {
renderer: PVE.Utils.render_dc_ha_opts,
['freeze', 'freeze'],
['failover', 'failover'],
['migrate', 'migrate'],
- ['conditional', 'conditional']
+ ['conditional', 'conditional'],
],
- defaultValue: '__default__'
- }]
+ defaultValue: '__default__',
+ }],
});
me.add_inputpanel_row('u2f', gettext('U2F Settings'), {
renderer: PVE.Utils.render_dc_ha_opts,
xtype: 'displayfield',
userCls: 'pmx-hint',
value: gettext('NOTE: Changing an AppID breaks existing U2F registrations!'),
- }]
+ }],
});
me.add_inputpanel_row('bwlimit', gettext('Bandwidth Limits'), {
renderer: me.render_bwlimits,
fieldLabel: gettext('Disk Move'),
emptyText: gettext('default'),
backendUnit: "KiB",
- }]
+ }],
});
me.add_integer_row('max_workers', gettext('Maximal Workers/bulk-action'), {
deleteEmpty: true,
xtype: 'proxmoxButton',
disabled: true,
handler: function() { me.run_editor(); },
- selModel: me.selModel
+ selModel: me.selModel,
}],
url: "/api2/json/cluster/options",
editorConfig: {
- url: "/api2/extjs/cluster/options"
+ url: "/api2/extjs/cluster/options",
},
interval: 5000,
cwidth1: 200,
listeners: {
- itemdblclick: me.run_editor
- }
+ itemdblclick: me.run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
model: 'pve-pools',
sorters: {
property: 'poolid',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var reload = function() {
baseurl: '/pools/',
callback: function () {
reload();
- }
+ },
});
var run_editor = function() {
return;
}
- var win = Ext.create('PVE.dc.PoolEdit',{
- poolid: rec.data.poolid
+ var win = Ext.create('PVE.dc.PoolEdit', {
+ poolid: rec.data.poolid,
});
win.on('destroy', reload);
win.show();
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
var tbar = [
var win = Ext.create('PVE.dc.PoolEdit', {});
win.on('destroy', reload);
win.show();
- }
+ },
},
- edit_btn, remove_btn
+ edit_btn, remove_btn,
];
Proxmox.Utils.monStoreErrors(me, store);
selModel: sm,
tbar: tbar,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
header: gettext('Name'),
width: 200,
sortable: true,
- dataIndex: 'poolid'
+ dataIndex: 'poolid',
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
- flex: 1
- }
+ flex: 1,
+ },
],
listeners: {
activate: reload,
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
- }
+ },
});
name: 'roleid',
value: me.roleid,
allowBlank: false,
- fieldLabel: gettext('Name')
+ fieldLabel: gettext('Name'),
},
{
xtype: 'pvePrivilegesSelector',
name: 'privs',
value: me.privs,
allowBlank: false,
- fieldLabel: gettext('Privileges')
- }
- ]
+ fieldLabel: gettext('Privileges'),
+ },
+ ],
});
me.callParent();
me.setValues({
privs: keys,
- roleid: me.roleid
+ roleid: me.roleid,
});
- }
+ },
});
}
- }
+ },
});
model: 'pmx-roles',
sorters: {
property: 'roleid',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var render_privs = function(value, metaData) {
return;
}
- var win = Ext.create('PVE.dc.RoleEdit',{
+ var win = Ext.create('PVE.dc.RoleEdit', {
roleid: rec.data.roleid,
- privs: rec.data.privs
+ privs: rec.data.privs,
});
win.on('destroy', reload);
win.show();
selModel: sm,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
width: 65,
sortable: true,
dataIndex: 'special',
- renderer: Proxmox.Utils.format_boolean
+ renderer: Proxmox.Utils.format_boolean,
},
{
header: gettext('Name'),
width: 150,
sortable: true,
- dataIndex: 'roleid'
+ dataIndex: 'roleid',
},
{
itemid: 'privs',
sortable: false,
renderer: render_privs,
dataIndex: 'privs',
- flex: 1
- }
+ flex: 1,
+ },
],
listeners: {
activate: function() {
store.load();
},
- itemdblclick: run_editor
+ itemdblclick: run_editor,
},
tbar: [
{
var win = Ext.create('PVE.dc.RoleEdit', {});
win.on('destroy', reload);
win.show();
- }
+ },
},
{
xtype: 'proxmoxButton',
},
baseurl: '/access/roles/',
enableFn: (rec) => !rec.data.special,
- }
- ]
+ },
+ ],
});
me.callParent();
- }
+ },
});
extend: 'Ext.data.Model',
fields: [ 'group', 'comment', 'digest' ],
- idProperty: 'group'
+ idProperty: 'group',
});
Ext.define('PVE.SecurityGroupEdit', {
name: 'group',
value: me.group_name || '',
fieldLabel: gettext('Name'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
name: 'comment',
value: me.group_comment || '',
- fieldLabel: gettext('Comment')
- }
+ fieldLabel: gettext('Comment'),
+ },
];
if (me.isCreate) {
items.push({
xtype: 'hiddenfield',
name: 'rename',
- value: me.group_name
+ value: me.group_name,
});
}
var ipanel = Ext.create('Proxmox.panel.InputPanel', {
// InputPanel does not have a 'create' property, does it need a 'isCreate'
isCreate: me.isCreate,
- items: items
+ items: items,
});
Ext.apply(me, {
subject: subject,
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
- }
+ },
});
Ext.define('PVE.SecurityGroupList', {
model: 'pve-security-groups',
proxy: {
type: 'proxmox',
- url: '/api2/json' + me.base_url
+ url: '/api2/json' + me.base_url,
},
sorters: {
property: 'group',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var sm = Ext.create('Ext.selection.RowModel', {});
var win = Ext.create('PVE.SecurityGroupEdit', {
digest: rec.data.digest,
group_name: rec.data.group,
- group_comment: rec.data.comment
+ group_comment: rec.data.comment,
});
win.show();
win.on('destroy', reload);
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
me.addBtn = new Proxmox.button.Button({
var win = Ext.create('PVE.SecurityGroupEdit', {});
win.show();
win.on('destroy', reload);
- }
+ },
});
me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton', {
},
callback: function() {
reload();
- }
+ },
});
Ext.apply(me, {
selModel: sm,
columns: [
{ header: gettext('Group'), dataIndex: 'group', width: '100' },
- { header: gettext('Comment'), dataIndex: 'comment', renderer: Ext.String.htmlEncode, flex: 1 }
+ { header: gettext('Comment'), dataIndex: 'comment', renderer: Ext.String.htmlEncode, flex: 1 },
],
listeners: {
itemdblclick: run_editor,
deselect: function() {
me.rule_panel.setBaseUrl(undefined);
},
- show: reload
- }
+ show: reload,
+ },
});
me.callParent();
store.load();
- }
+ },
});
Ext.define('PVE.SecurityGroups', {
allow_groups: false,
list_refs_url: '/cluster/firewall/refs',
tbar_prefix: '<b>' + gettext('Rules') + ':</b>',
- border: false
+ border: false,
});
var sglist = Ext.createWidget('pveSecurityGroupList', {
rule_panel: rule_panel,
width: '25%',
border: false,
- split: true
+ split: true,
});
listeners: {
show: function() {
sglist.fireEvent('show', sglist);
- }
- }
+ },
+ },
});
me.callParent();
- }
+ },
});
canDoBackups: schema.backups,
autoShow: true,
listeners: {
- destroy: this.reloadStore
- }
+ destroy: this.reloadStore,
+ },
});
},
model: 'pve-storage',
proxy: {
type: 'proxmox',
- url: "/api2/json/storage"
+ url: "/api2/json/storage",
},
sorters: {
property: 'storage',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var reload = function() {
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
var remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/storage/',
- callback: reload
+ callback: reload,
});
// else we cannot dynamically generate the add menu handlers
addMenuItems.push({
text: PVE.Utils.format_storage_type(type),
iconCls: 'fa fa-fw fa-' + storage.faIcon,
- handler: addHandleGenerator(type)
+ handler: addHandleGenerator(type),
});
}
reloadStore: reload,
selModel: sm,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
tbar: [
{
text: gettext('Add'),
menu: new Ext.menu.Menu({
- items: addMenuItems
- })
+ items: addMenuItems,
+ }),
},
remove_btn,
- edit_btn
+ edit_btn,
],
columns: [
{
header: 'ID',
flex: 2,
sortable: true,
- dataIndex: 'storage'
+ dataIndex: 'storage',
},
{
header: gettext('Type'),
flex: 1,
sortable: true,
dataIndex: 'type',
- renderer: PVE.Utils.format_storage_type
+ renderer: PVE.Utils.format_storage_type,
},
{
header: gettext('Content'),
flex: 3,
sortable: true,
dataIndex: 'content',
- renderer: PVE.Utils.format_content_types
+ renderer: PVE.Utils.format_content_types,
},
{
header: gettext('Path') + '/' + gettext('Target'),
return record.data.target;
}
return value;
- }
+ },
},
{
header: gettext('Shared'),
flex: 1,
sortable: true,
dataIndex: 'shared',
- renderer: Proxmox.Utils.format_boolean
+ renderer: Proxmox.Utils.format_boolean,
},
{
header: gettext('Enabled'),
flex: 1,
sortable: true,
dataIndex: 'disable',
- renderer: Proxmox.Utils.format_neg_boolean
+ renderer: Proxmox.Utils.format_neg_boolean,
},
{
header: gettext('Bandwidth Limit'),
flex: 2,
sortable: true,
- dataIndex: 'bwlimit'
- }
+ dataIndex: 'bwlimit',
+ },
],
listeners: {
activate: reload,
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
- }
+ },
}, function() {
Ext.define('pve-storage', {
fields: [
'path', 'type', 'content', 'server', 'portal', 'target', 'export', 'storage',
{ name: 'shared', type: 'boolean'},
- { name: 'disable', type: 'boolean'}
+ { name: 'disable', type: 'boolean'},
],
- idProperty: 'storage'
+ idProperty: 'storage',
});
});
layout: 'hbox',
defaults: {
xtype: 'proxmoxGauge',
- flex: 1
+ flex: 1,
},
items:[
{
title: gettext('CPU'),
- itemId: 'cpu'
+ itemId: 'cpu',
},
{
title: gettext('Memory'),
- itemId: 'memory'
+ itemId: 'memory',
},
{
title: gettext('Storage'),
- itemId: 'storage'
- }
- ]
+ itemId: 'storage',
+ },
+ ],
},
{
itemId: 'nodeview',
xtype: 'pveDcNodeView',
- height: 250
+ height: 250,
},
{
title: gettext('Subscriptions'),
if (this.component.userCls === 'pointer') {
window.open('https://www.proxmox.com/en/proxmox-ve/pricing', '_blank');
}
- }
- }
- }
- ]
- }
+ },
+ },
+ },
+ ],
+ },
],
listeners: {
model: 'pve-dc-nodes',
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/status"
- }
+ url: "/api2/json/cluster/status",
+ },
});
var gridstore = Ext.create('Proxmox.data.DiffStore', {
rstore: rstore,
filters: {
property: 'type',
- value: 'node'
+ value: 'node',
},
sorters: {
property: 'id',
- direction: 'ASC'
- }
+ direction: 'ASC',
+ },
});
me.callParent();
running: 0,
paused: 0,
stopped: 0,
- template: 0
+ template: 0,
};
var lxc = {
running: 0,
paused: 0,
stopped: 0,
- template: 0
+ template: 0,
};
var error = 0;
text = Ext.String.format(gettext('{0} of {1}'), PVE.Utils.render_size(used), PVE.Utils.render_size(total));
storagestat.updateValue((used/total), text);
- gueststatus.updateValues(qemu,lxc,error);
+ gueststatus.updateValues(qemu, lxc, error);
me.suspendLayout = false;
me.updateLayout(true);
var data = {
title: Proxmox.Utils.unknownText,
text: Proxmox.Utils.unknownText,
- iconCls: PVE.Utils.get_health_icon(undefined, true)
+ iconCls: PVE.Utils.get_health_icon(undefined, true),
};
if (level === '') {
data = {
title: gettext('No Subscription'),
iconCls: PVE.Utils.get_health_icon('critical', true),
- text: gettext('You have at least one node without subscription.')
+ text: gettext('You have at least one node without subscription.'),
};
subs.setUserCls('pointer');
} else if (mixed) {
data = {
title: gettext('Mixed Subscriptions'),
iconCls: PVE.Utils.get_health_icon('warning', true),
- text: gettext('Warning: Your subscription levels are not the same.')
+ text: gettext('Warning: Your subscription levels are not the same.'),
};
subs.setUserCls('pointer');
} else if (level) {
data = {
title: PVE.Utils.render_support_level(level),
iconCls: PVE.Utils.get_health_icon('good', true),
- text: gettext('Your subscription status is valid.')
+ text: gettext('Your subscription status is valid.'),
};
subs.setUserCls('');
}
});
rstore.startUpdate();
- }
+ },
});
} else {
me.updateInactive(data);
}
- }
+ },
});
};
autoScroll: true,
bodyStyle: 'padding:10px',
listeners: {
- activate: reload
- }
+ activate: reload,
+ },
});
me.callParent();
- }
+ },
});
reference: 'defaulthint',
value: gettext('Default sync options can be set by editing the realm.'),
userCls: 'pmx-hint',
- hidden: true
+ hidden: true,
},
],
}],
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
updateQrCode: function() {
'&period=' + values.step +
'&digits=' + values.digits +
'&algorithm=' + algorithm +
- '&issuer=' + encodeURIComponent(values.issuer)
+ '&issuer=' + encodeURIComponent(values.issuer),
);
me.lookup('challenge').setVisible(true);
showError: function(error) {
Ext.Msg.alert(
gettext('Error'),
- PVE.Utils.render_u2f_error(error)
+ PVE.Utils.render_u2f_error(error),
);
},
var msg = Ext.Msg.show({
title: 'U2F: '+gettext('Setup'),
message: gettext('Please press the button on your U2F Device'),
- buttons: []
+ buttons: [],
});
Ext.Function.defer(function() {
u2f.register(data.appId, [data], [], function(data) {
var params = {
userid: me.userid,
action: 'confirm',
- response: JSON.stringify(data)
+ response: JSON.stringify(data),
};
if (Proxmox.UserName !== 'root@pam') {
params.password = me.lookup('password').value;
Ext.Msg.show({
title: gettext('Success'),
message: gettext('U2F Device successfully connected.'),
- buttons: Ext.Msg.OK
+ buttons: Ext.Msg.OK,
});
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
selectedTab: function(get) {
return (get('tfa_type') || 'totp') + '-panel';
},
- }
+ },
},
afterLoading: function(realm_tfa_type, user_tfa_type) {
gettext('Error'),
Ext.String.format(
gettext("Custom 2nd factor configuration is not supported on realms with '{0}' TFA."),
- realm_tfa_type
- )
+ realm_tfa_type,
+ ),
);
}
},
change: function() {
var me = this.getView();
me.updateQrCode();
- }
+ },
},
'field': {
validitychange: function(field, valid) {
var challenge = me.lookup('challenge');
var password = me.lookup('password');
viewModel.set('valid', form.isValid() && challenge.isValid() && password.isValid());
- }
+ },
},
'#': {
show: function() {
failure: function(response, opts) {
me.close();
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
me.qrdiv = document.createElement('center');
me.qrcode = new QRCode(me.qrdiv, {
width: 256,
height: 256,
- correctLevel: QRCode.CorrectLevel.M
+ correctLevel: QRCode.CorrectLevel.M,
});
me.down('#qrbox').getEl().appendChild(me.qrdiv);
me.lookup('password').setVisible(false);
me.lookup('password').setDisabled(true);
}
- }
+ },
},
'#tfatabs': {
tabchange: function(panel, newcard) {
var viewmodel = this.getViewModel();
viewmodel.set('in_totp_tab', newcard.itemId === 'totp-panel');
- }
- }
+ },
+ },
},
applySettings: function() {
config: PVE.Parser.printPropertyString({
type: 'oath',
digits: values.digits,
- step: values.step
+ step: values.step,
}),
// this is used to verify that the client generates the correct codes:
- response: me.lookup('challenge').value
+ response: me.lookup('challenge').value,
};
if (Proxmox.UserName !== 'root@pam') {
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
var values = me.lookup('totp_form').getValues();
var params = {
userid: me.getView().userid,
- action: 'delete'
+ action: 'delete',
};
if (Proxmox.UserName !== 'root@pam') {
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
var params = {
userid: me.getView().userid,
- action: 'new'
+ action: 'new',
};
if (Proxmox.UserName !== 'root@pam') {
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
},
items: [
tfa_type: 'totp',
border: false,
bind: {
- disabled: '{!canSetupTOTP}'
+ disabled: '{!canSetupTOTP}',
},
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [
{
reference: 'totp_form',
fieldDefaults: {
anchor: '100%',
- padding: '0 5'
+ padding: '0 5',
},
items: [
{
fieldLabel: gettext('User name'),
renderer: Ext.String.htmlEncode,
cbind: {
- value: '{userid}'
- }
+ value: '{userid}',
+ },
},
{
layout: 'hbox',
bind: {
value: "{secret}",
},
- flex: 4
+ flex: 4,
},
{
xtype: 'button',
text: gettext('Randomize'),
reference: 'randomize_button',
handler: 'randomizeSecret',
- flex: 1
- }]
+ flex: 1,
+ }],
},
{
xtype: 'numberfield',
hidden: true,
value: 30,
minValue: 10,
- qrupdate: true
+ qrupdate: true,
},
{
xtype: 'numberfield',
hidden: true,
minValue: 6,
maxValue: 8,
- qrupdate: true
+ qrupdate: true,
},
{
xtype: 'textfield',
fieldLabel: gettext('Issuer Name'),
name: 'issuer',
value: 'Proxmox Web UI',
- qrupdate: true
- }
- ]
+ qrupdate: true,
+ },
+ ],
},
{
xtype: 'box',
'background-color': 'white',
padding: '5px',
width: '266px',
- height: '266px'
- }
+ height: '266px',
+ },
},
{
xtype: 'textfield',
visible: '{showTOTPVerifiction}',
},
padding: '0 5',
- emptyText: gettext('Scan QR code and enter TOTP auth. code to verify')
- }
- ]
+ emptyText: gettext('Scan QR code and enter TOTP auth. code to verify'),
+ },
+ ],
},
{
title: 'U2F',
padding: '5 5',
layout: {
type: 'vbox',
- align: 'middle'
+ align: 'middle',
},
bind: {
- disabled: '{!canSetupU2F}'
+ disabled: '{!canSetupU2F}',
},
items: [
{
xtype: 'label',
width: 500,
- text: gettext('To register a U2F device, connect the device, then click the button and follow the instructions.')
- }
- ]
- }
- ]
+ text: gettext('To register a U2F device, connect the device, then click the button and follow the instructions.'),
+ },
+ ],
+ },
+ ],
},
{
xtype: 'textfield',
allowBlank: false,
validateBlank: true,
padding: '0 0 5 5',
- emptyText: gettext('verify current password')
- }
+ emptyText: gettext('verify current password'),
+ },
],
buttons: [
{
- xtype: 'proxmoxHelpButton'
+ xtype: 'proxmoxHelpButton',
},
'->',
{
handler: 'applySettings',
bind: {
hidden: '{!in_totp_tab}',
- disabled: '{!valid}'
- }
+ disabled: '{!valid}',
+ },
},
{
xtype: 'button',
handler: 'startU2FRegistration',
bind: {
hidden: '{in_totp_tab}',
- disabled: '{tfa_type}'
- }
+ disabled: '{tfa_type}',
+ },
},
{
text: gettext('Delete'),
disabled: true,
handler: 'deleteTFA',
bind: {
- disabled: '{!canDeleteTFA}'
- }
- }
+ disabled: '{!canDeleteTFA}',
+ },
+ },
],
initComponent: function() {
me.callParent();
Ext.GlobalEvents.fireEvent('proxmoxShowHelp', 'pveum_tfa_auth');
- }
+ },
});
model: 'proxmox-tasks',
proxy: {
type: 'proxmox',
- url: '/api2/json/cluster/tasks'
- }
+ url: '/api2/json/cluster/tasks',
+ },
});
var store = Ext.create('Proxmox.data.DiffStore', {
sorters: [
{
property : 'pid',
- direction: 'DESC'
+ direction: 'DESC',
},
{
property : 'starttime',
- direction: 'DESC'
- }
- ]
+ direction: 'DESC',
+ },
+ ],
});
if (status && status != 'OK') {
return "proxmox-invalid-row";
}
- }
+ },
},
sortableColumns: false,
columns: [
width: 150,
renderer: function(value) {
return Ext.Date.format(value, "M d H:i:s");
- }
+ },
},
{
header: gettext("End Time"),
return "";
}
return Ext.Date.format(value, "M d H:i:s");
- }
+ },
},
{
header: gettext("Node"),
dataIndex: 'node',
- width: 100
+ width: 100,
},
{
header: gettext("User name"),
dataIndex: 'user',
renderer: Ext.String.htmlEncode,
- width: 150
+ width: 150,
},
{
header: gettext("Description"),
dataIndex: 'upid',
flex: 1,
- renderer: Proxmox.Utils.render_upid
+ renderer: Proxmox.Utils.render_upid,
},
{
header: gettext("Status"),
}
// metaData.attr = 'style="color:red;"';
return Proxmox.Utils.errorText + ': ' + value;
- }
- }
+ },
+ },
],
listeners: {
itemdblclick: run_task_viewer,
show: () => taskstore.startUpdate(),
destroy: () => taskstore.stopUpdate(),
- }
+ },
});
me.callParent();
- }
+ },
});
submitValue: false,
disabled: true,
hidden: true,
- validator: validate_pw
+ validator: validate_pw,
});
pwfield = Ext.createWidget('textfield', {
name: 'password',
disabled: true,
hidden: true,
- validator: validate_pw
+ validator: validate_pw,
});
var update_passwd_field = function(realm) {
value: me.userid,
renderer: Ext.String.htmlEncode,
allowBlank: false,
- submitValue: me.isCreate ? true : false
+ submitValue: me.isCreate ? true : false,
},
pwfield, verifypw,
{
name: 'groups',
multiSelect: true,
allowBlank: true,
- fieldLabel: gettext('Group')
+ fieldLabel: gettext('Group'),
},
{
xtype: 'pmxExpireDate',
name: 'enable',
uncheckedValue: 0,
defaultValue: 1,
- checked: true
- }
+ checked: true,
+ },
];
var column2 = [
{
xtype: 'textfield',
name: 'firstname',
- fieldLabel: gettext('First Name')
+ fieldLabel: gettext('First Name'),
},
{
xtype: 'textfield',
name: 'lastname',
- fieldLabel: gettext('Last Name')
+ fieldLabel: gettext('Last Name'),
},
{
xtype: 'textfield',
name: 'email',
fieldLabel: gettext('E-Mail'),
- vtype: 'proxmoxMail'
- }
+ vtype: 'proxmoxMail',
+ },
];
if (me.isCreate) {
- column1.splice(1,0,{
+ column1.splice(1, 0, {
xtype: 'pmxRealmComboBox',
name: 'realm',
fieldLabel: gettext('Realm'),
change: function(combo, newValue){
realm = newValue;
update_passwd_field(realm);
- }
+ },
},
- submitValue: false
+ submitValue: false,
});
}
{
xtype: 'textfield',
name: 'comment',
- fieldLabel: gettext('Comment')
- }
+ fieldLabel: gettext('Comment'),
+ },
],
advancedItems: [
{
xtype: 'textfield',
name: 'keys',
- fieldLabel: gettext('Key IDs')
- }
+ fieldLabel: gettext('Key IDs'),
+ },
],
onGetValues: function(values) {
if (realm) {
}
return values;
- }
+ },
});
Ext.applyIf(me, {
url: url,
method: method,
fieldDefaults: {
- labelWidth: 110 // for spanish translation
+ labelWidth: 110, // for spanish translation
},
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
me.down('[name="keys"]').setDisabled(1);
}
}
- }
+ },
});
}
- }
+ },
});
model: 'pve-users',
sorters: {
property: 'userid',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var reload = function() {
},
callback: function() {
reload();
- }
+ },
});
var run_editor = function() {
return;
}
- var win = Ext.create('PVE.dc.UserEdit',{
- userid: rec.data.userid
+ var win = Ext.create('PVE.dc.UserEdit', {
+ userid: rec.data.userid,
});
win.on('destroy', reload);
win.show();
return !!caps.access['User.Modify'];
},
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
var pwchange_btn = new Proxmox.button.Button({
selModel: sm,
handler: function(btn, event, rec) {
var win = Ext.create('Proxmox.window.PasswordEdit', {
- userid: rec.data.userid
+ userid: rec.data.userid,
});
win.on('destroy', reload);
win.show();
- }
+ },
});
var tfachange_btn = new Proxmox.button.Button({
handler: function(btn, event, rec) {
var d = rec.data;
var tfa_type = PVE.Parser.parseTfaType(d.keys);
- var win = Ext.create('PVE.window.TFAEdit',{
+ var win = Ext.create('PVE.window.TFAEdit', {
tfa_type: tfa_type,
- userid: d.userid
+ userid: d.userid,
});
win.on('destroy', reload);
win.show();
- }
+ },
});
var perm_btn = new Proxmox.button.Button({
selModel: sm,
handler: function(btn, event, rec) {
var win = Ext.create('PVE.dc.PermissionView', {
- userid: rec.data.userid
+ userid: rec.data.userid,
});
win.show();
- }
+ },
});
var tbar = [
text: gettext('Add'),
disabled: !caps.access['User.Modify'],
handler: function() {
- var win = Ext.create('PVE.dc.UserEdit',{
+ var win = Ext.create('PVE.dc.UserEdit', {
});
win.on('destroy', reload);
win.show();
- }
+ },
},
- edit_btn, remove_btn, pwchange_btn, tfachange_btn, perm_btn
+ edit_btn, remove_btn, pwchange_btn, tfachange_btn, perm_btn,
];
var render_username = function(userid) {
selModel: sm,
tbar: tbar,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
width: 200,
sortable: true,
renderer: render_username,
- dataIndex: 'userid'
+ dataIndex: 'userid',
},
{
header: gettext('Realm'),
width: 100,
sortable: true,
renderer: render_realm,
- dataIndex: 'userid'
+ dataIndex: 'userid',
},
{
header: gettext('Enabled'),
width: 80,
sortable: true,
renderer: Proxmox.Utils.format_boolean,
- dataIndex: 'enable'
+ dataIndex: 'enable',
},
{
header: gettext('Expire'),
width: 80,
sortable: true,
renderer: Proxmox.Utils.format_expire,
- dataIndex: 'expire'
+ dataIndex: 'expire',
},
{
header: gettext('Name'),
width: 150,
sortable: true,
renderer: PVE.Utils.render_full_name,
- dataIndex: 'firstname'
+ dataIndex: 'firstname',
},
{
header: 'TFA',
return tfa_type;
}
},
- dataIndex: 'keys'
+ dataIndex: 'keys',
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
- flex: 1
- }
+ flex: 1,
+ },
],
listeners: {
activate: reload,
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
Proxmox.Utils.monStoreErrors(me, store);
- }
+ },
});
isEmpty: function() {
return this.getStore().getData().length === 0;
- }
+ },
});
bind: {
disabled: '{!enabled.checked}',
},
- disabled: true
+ disabled: true,
},
{
xtype: 'displayfield',
['virtio', 'VirtIO'],
['isa', 'ISA'],
],
- }
+ },
],
onGetValues: function(values) {
setValues: function(values) {
let res = PVE.Parser.parsePropertyString(values.agent, 'enabled');
this.callParent([res]);
- }
+ },
});
comboItems: [
['snapshot', gettext('Snapshot')],
['suspend', gettext('Suspend')],
- ['stop', gettext('Stop')]
- ]
+ ['stop', gettext('Stop')],
+ ],
});
},
formulas: {
unitlabel: (get) => get('unit') + '/s',
- }
+ },
},
emptyText: '',
layout: 'hbox',
defaults: {
- hideLabel: true
+ hideLabel: true,
},
units: {
comboItems: [
['__default__', gettext('Default')],
[1, gettext('Yes')],
- [0, gettext('No')]
- ]
+ [0, gettext('No')],
+ ],
});
sorters: [
{
property : 'iface',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
valueField: 'iface',
displayField: 'iface',
header: gettext('Bridge'),
dataIndex: 'iface',
hideable: false,
- width: 100
+ width: 100,
},
{
header: gettext('Active'),
width: 60,
dataIndex: 'active',
- renderer: Proxmox.Utils.format_boolean
+ renderer: Proxmox.Utils.format_boolean,
},
{
header: gettext('Comment'),
dataIndex: 'comments',
renderer: Ext.String.htmlEncode,
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
},
setNodename: function(nodename) {
me.store.setProxy({
type: 'proxmox',
url: '/api2/json/nodes/' + me.nodename + '/network?type=' +
- me.bridgeType
+ me.bridgeType,
});
me.store.load();
me.callParent();
me.setNodename(nodename);
- }
+ },
});
me.comboItems.push(['scsi', 'SCSI']);
me.callParent();
- }
+ },
});
{name: 'name'},
{name: 'vendor'},
{name: 'custom'},
- {name: 'displayname'}
- ]
+ {name: 'displayname'},
+ ],
});
Ext.define('PVE.form.CPUModelSelector', {
dataIndex: 'displayname',
hideable: false,
sortable: true,
- flex: 3
+ flex: 3,
},
{
header: gettext('Vendor'),
dataIndex: 'vendor',
hideable: false,
sortable: true,
- flex: 2
- }
+ flex: 2,
+ },
],
- width: 360
+ width: 360,
},
store: {
model: 'PVE.data.CPUModel',
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/localhost/cpu'
+ url: '/api2/json/nodes/localhost/cpu',
},
sorters: [
{
// Within same vendor, sort alphabetically
return a.name.localeCompare(b.name);
},
- direction: 'ASC'
- }
+ direction: 'ASC',
+ },
],
listeners: {
load: function(store, records, success) {
store.sort();
}
- }
- }
- }
+ },
+ },
+ },
});
['writethrough', 'Write through'],
['writeback', 'Write back'],
['unsafe', 'Write back (' + gettext('unsafe') + ')'],
- ['none', gettext('No cache')]
- ]
+ ['none', gettext('No cache')],
+ ],
});
{ value: '2,22:30', text: gettext("Every day") + " 02:30, 22:30"},
{ value: 'mon..fri', text: gettext("Monday to Friday") + " 00:00"},
{ value: 'mon..fri */1:00', text: gettext("Monday to Friday") + ': ' + gettext("hourly")},
- { value: 'sun 01:00', text: gettext("Sunday") + " 01:00"}
- ]
+ { value: 'sun 01:00', text: gettext("Sunday") + " 01:00"},
+ ],
},
tpl: [
'<ul class="x-list-plain"><tpl for=".">',
'<li role="option" class="x-boundlist-item">{text}</li>',
- '</tpl></ul>'
+ '</tpl></ul>',
],
displayTpl: [
'<tpl for=".">',
'{value}',
- '</tpl>'
- ]
+ '</tpl>',
+ ],
});
sorters: 'name',
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/ceph/pools'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/ceph/pools',
+ },
});
Ext.apply(me, {
- store: store
+ store: store,
});
me.callParent();
if (success && rec.length > 0) {
me.select(rec[0]);
}
- }
+ },
});
- }
+ },
});
['lzo', 'LZO (' + gettext('fast') + ')'],
['gzip', 'GZIP (' + gettext('good') + ')'],
['zstd', 'ZSTD (' + gettext('fast and good') + ')'],
- ]
+ ],
});
});
me.callParent();
- }
+ },
});
fieldLabel: gettext('Bus/Device'),
layout: 'hbox',
defaults: {
- hideLabel: true
+ hideLabel: true,
},
items: [
{
var field = me.down('field[name=deviceid]');
field.setMaxValue(PVE.Utils.diskControllerMaxIDs[value]);
field.validate();
- }
- }
+ },
+ },
},
{
xtype: 'proxmoxintegerfield',
return "This device is already in use.";
}
return true;
- }
- }
- ]
+ },
+ },
+ ],
});
me.callParent();
- }
+ },
});
['thu', Ext.util.Format.htmlDecode(Ext.Date.dayNames[4])],
['fri', Ext.util.Format.htmlDecode(Ext.Date.dayNames[5])],
['sat', Ext.util.Format.htmlDecode(Ext.Date.dayNames[6])],
- ['sun', Ext.util.Format.htmlDecode(Ext.Date.dayNames[0])]
+ ['sun', Ext.util.Format.htmlDecode(Ext.Date.dayNames[0])],
];
this.callParent();
- }
+ },
});
comboItems: [
['raw', gettext('Raw disk image') + ' (raw)'],
['qcow2', gettext('QEMU image format') + ' (qcow2)'],
- ['vmdk', gettext('VMware image format') + ' (vmdk)']
- ]
+ ['vmdk', gettext('VMware image format') + ' (vmdk)'],
+ ],
});
layout: 'fit',
defaults: {
- margin: '0 0 5 0'
+ margin: '0 0 5 0',
},
// the fieldLabel for the storageselector
listeners: {
change: {
fn: me.changeStorage,
- scope: me
- }
- }
+ scope: me,
+ },
+ },
},
{
xtype: 'pveFileSelector',
fieldLabel: gettext('Disk image'),
nodename: me.nodename,
disabled: true,
- hidden: true
+ hidden: true,
},
{
xtype: 'numberfield',
maxValue: 128*1024,
decimalPrecision: 3,
value: me.defaultSize,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'pveDiskFormatSelector',
disabled: true,
hidden: me.storageContent === 'rootdir',
value: 'qcow2',
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
// use it to disable the children but not ourself
me.disabled = false;
me.callParent();
- }
+ },
});
alias: ['widget.pveEmailNotificationSelector'],
comboItems: [
['always', gettext('Always')],
- ['failure', gettext('On failure only')]
- ]
+ ['failure', gettext('On failure only')],
+ ],
});
if (!me.disabled) {
me.setStorage(me.storage, me.nodename);
}
- }
+ },
},
setStorage: function(storage, nodename) {
me.store.setProxy({
type: 'proxmox',
- url: url
+ url: url,
});
me.store.removeAll();
},
store: {
- model: 'pve-storage-content'
+ model: 'pve-storage-content',
},
allowBlank: false,
header: gettext('Name'),
dataIndex: 'text',
hideable: false,
- flex: 1
+ flex: 1,
},
{
header: gettext('Format'),
width: 60,
- dataIndex: 'format'
+ dataIndex: 'format',
},
{
header: gettext('Size'),
width: 100,
dataIndex: 'size',
- renderer: Proxmox.Utils.format_size
- }
- ]
- }
+ renderer: Proxmox.Utils.format_size,
+ },
+ ],
+ },
});
comboItems: [
['ACCEPT', 'ACCEPT'],
['REJECT', 'REJECT'],
- [ 'DROP', 'DROP']
- ]
+ [ 'DROP', 'DROP'],
+ ],
});
scrollable: {
xtype: 'scroller',
y: true,
- x:false
+ x:false,
},
store: {
model: 'PVEResources',
proxy:{
type: 'proxmox',
- url: '/api2/extjs/cluster/resources'
- }
+ url: '/api2/extjs/cluster/resources',
+ },
},
plugins: {
ptype: 'bufferedrenderer',
trailingBufferZone: 20,
- leadingBufferZone: 20
+ leadingBufferZone: 20,
},
hideMe: function() {
},
/* because of lint */
focusleave: {
- fn: 'hideMe'
+ fn: 'hideMe',
},
- focusenter: 'setFocus'
+ focusenter: 'setFocus',
},
columns: [
text: gettext('Type'),
dataIndex: 'type',
width: 100,
- renderer: PVE.Utils.render_resource_type
+ renderer: PVE.Utils.render_resource_type,
},
{
text: gettext('Description'),
flex: 1,
- dataIndex: 'text'
+ dataIndex: 'text',
},
{
text: gettext('Node'),
- dataIndex: 'node'
+ dataIndex: 'node',
},
{
text: gettext('Pool'),
- dataIndex: 'pool'
- }
- ]
+ dataIndex: 'pool',
+ },
+ ],
},
customFilter: function(item) {
var me = this;
var match = 0;
var fieldArr = [];
- var i,j, fields;
+ var i, j, fields;
// different types of objects have different fields to search
// for example, a node will never have a pool and vice versa
listeners: {
change: {
fn: 'updateFilter',
- buffer: 250
+ buffer: 250,
},
specialkey: 'onKey',
focusenter: 'loadValues',
focusleave: {
fn: 'hideGrid',
- delay: 100
- }
+ delay: 100,
+ },
},
toggleFocus: function() {
ctrl: true,
shift: true,
fn: me.toggleFocus,
- scope: me
- },{
+ scope: me,
+ }, {
key:' ',
ctrl: true,
fn: me.toggleFocus,
- scope: me
- }]
+ scope: me,
+ }],
});
// always select first item and
me.grid.getSelectionModel().select(0);
me.grid.store.sort({
property: 'relevance',
- direction: 'DESC'
+ direction: 'DESC',
});
});
- }
+ },
});
fields: [ 'groupid', 'comment', 'users' ],
proxy: {
type: 'proxmox',
- url: "/api2/json/access/groups"
+ url: "/api2/json/access/groups",
},
- idProperty: 'groupid'
+ idProperty: 'groupid',
});
Ext.define('PVE.form.GroupSelector', {
header: gettext('Group'),
sortable: true,
dataIndex: 'groupid',
- flex: 1
+ flex: 1,
},
{
header: gettext('Comment'),
sortable: false,
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
- flex: 1
+ flex: 1,
},
{
header: gettext('Users'),
sortable: false,
dataIndex: 'users',
renderer: Ext.String.htmlEncode,
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
},
initComponent: function() {
var store = new Ext.data.Store({
model: 'pve-groups',
sorters: [{
- property: 'groupid'
- }]
+ property: 'groupid',
+ }],
});
Ext.apply(me, {
- store: store
+ store: store,
});
me.callParent();
store.load();
- }
+ },
});
failure: function(response, opts) {
me.exists = true;
me.validate();
- }
+ },
});
- }
- }
+ },
+ },
});
me.callParent();
method: 'GET',
success: function(response, opts) {
me.setRawValue(response.result.data);
- }
+ },
});
}
- }
+ },
});
defaults: {
name: 'hotplugCbGroup',
- submitValue: false
+ submitValue: false,
},
items: [
{
boxLabel: gettext('Disk'),
inputValue: 'disk',
- checked: true
+ checked: true,
},
{
boxLabel: gettext('Network'),
inputValue: 'network',
- checked: true
+ checked: true,
},
{
boxLabel: 'USB',
inputValue: 'usb',
- checked: true
+ checked: true,
},
{
boxLabel: gettext('Memory'),
- inputValue: 'memory'
+ inputValue: 'memory',
},
{
boxLabel: gettext('CPU'),
- inputValue: 'cpu'
- }
+ inputValue: 'cpu',
+ },
],
setValue: function(value) {
} else {
return { 'hotplug': data.join(',') };
}
- }
+ },
});
dataIndex: 'p',
hideable: false,
sortable: false,
- width: 100
+ width: 100,
},
{
header: gettext('Number'),
dataIndex: 'n',
hideable: false,
sortable: false,
- width: 50
+ width: 50,
},
{
header: gettext('Description'),
dataIndex: 'd',
hideable: false,
sortable: false,
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
},
store: {
fields: [ 'p', 'd', 'n'],
{ p: 'hip', n: 139, d: 'Host Identity Protocol' },
{ p: 'shim6', n: 140, d: 'Shim6 Protocol [RFC5533]' },
{ p: 'wesp', n: 141, d: 'Wrapped Encapsulating Security Payload' },
- { p: 'rohc', n: 142, d: 'Robust Header Compression' }
- ]
- }
+ { p: 'rohc', n: 142, d: 'Robust Header Compression' },
+ ],
+ },
});
idProperty: 'ref',
proxy: {
type: 'proxmox',
- url: url
+ url: url,
},
sorters: {
property: 'ref',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var disable_query_for_ips = function(f, value) {
header: gettext('Type'),
dataIndex: 'type',
hideable: false,
- width: 60
+ width: 60,
});
}
header: gettext('Name'),
dataIndex: 'ref',
hideable: false,
- width: 140
+ width: 140,
},
{
header: gettext('Comment'),
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
- flex: 1
- }
+ flex: 1,
+ },
);
Ext.apply(me, {
store: store,
- listConfig: { columns: columns }
+ listConfig: { columns: columns },
});
me.on('change', disable_query_for_ips);
me.callParent();
- }
+ },
});
xtype: 'pveMDevSelector',
store: {
- fields: [ 'type','available', 'description' ],
+ fields: [ 'type', 'available', 'description' ],
filterOnLoad: true,
sorters: [
{
property : 'type',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
autoSelect: false,
valueField: 'type',
{
header: gettext('Type'),
dataIndex: 'type',
- flex: 1
+ flex: 1,
},
{
header: gettext('Available'),
dataIndex: 'available',
- width: 80
+ width: 80,
},
{
header: gettext('Description'),
}
return value.split('\n').join('<br>');
- }
- }
- ]
+ },
+ },
+ ],
},
setPciID: function(pciid, force) {
var me = this;
me.store.setProxy({
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/hardware/pci/' + me.pciid + '/mdev'
+ url: '/api2/json/nodes/' + me.nodename + '/hardware/pci/' + me.pciid + '/mdev',
});
me.store.load();
},
if (me.pciid) {
me.setPciID(me.pciid, true);
}
- }
+ },
});
}
me.callParent();
- }
+ },
});
['e1000', 'Intel E1000'],
['virtio', 'VirtIO (' + gettext('paravirtualized') + ')'],
['rtl8139', 'Realtek RTL8139'],
- ['vmxnet3', 'VMware vmxnet3']
- ]
+ ['vmxnet3', 'VMware vmxnet3'],
+ ],
});
fields: [ 'node', 'cpu', 'maxcpu', 'mem', 'maxmem', 'uptime' ],
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes'
+ url: '/api2/json/nodes',
},
sorters: [
{
property : 'node',
- direction: 'ASC'
+ direction: 'ASC',
},
{
property : 'mem',
- direction: 'DESC'
- }
- ]
+ direction: 'DESC',
+ },
+ ],
},
listConfig: {
dataIndex: 'node',
sortable: true,
hideable: false,
- flex: 1
+ flex: 1,
},
{
header: gettext('Memory usage') + " %",
renderer: PVE.Utils.render_mem_usage_percent,
sortable: true,
width: 100,
- dataIndex: 'mem'
+ dataIndex: 'mem',
},
{
header: gettext('CPU usage'),
renderer: PVE.Utils.render_cpu,
sortable: true,
width: 100,
- dataIndex: 'cpu'
- }
- ]
+ dataIndex: 'cpu',
+ },
+ ],
},
validator: function(value) {
} else {
return true;
}
- }
+ },
}));
me.mon(me.getStore(), 'load', function(){
me.isValid();
});
- }
+ },
});
xtype: 'pvePCISelector',
store: {
- fields: [ 'id','vendor_name', 'device_name', 'vendor', 'device', 'iommugroup', 'mdev' ],
+ fields: [ 'id', 'vendor_name', 'device_name', 'vendor', 'device', 'iommugroup', 'mdev' ],
filterOnLoad: true,
sorters: [
{
property : 'id',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
autoSelect: false,
{
header: 'ID',
dataIndex: 'id',
- width: 100
+ width: 100,
},
{
header: gettext('IOMMU Group'),
dataIndex: 'iommugroup',
- width: 50
+ width: 50,
},
{
header: gettext('Vendor'),
dataIndex: 'vendor_name',
- flex: 2
+ flex: 2,
},
{
header: gettext('Device'),
dataIndex: 'device_name',
- flex: 6
+ flex: 6,
},
{
header: gettext('Mediated Devices'),
flex: 1,
renderer: function(val) {
return Proxmox.Utils.format_boolean(!!val);
- }
- }
- ]
+ },
+ },
+ ],
},
setNodename: function(nodename) {
me.store.setProxy({
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/hardware/pci'
+ url: '/api2/json/nodes/' + me.nodename + '/hardware/pci',
});
me.store.load();
}
me.setNodename(nodename);
- }
+ },
});
queryMode: 'local',
store: {
- type: 'pvePermPath'
- }
+ type: 'pvePermPath',
+ },
});
var store = new Ext.data.Store({
model: 'pve-pools',
- sorters: 'poolid'
+ sorters: 'poolid',
});
Ext.apply(me, {
header: gettext('Pool'),
sortable: true,
dataIndex: 'poolid',
- flex: 1
+ flex: 1,
},
{
header: gettext('Comment'),
sortable: false,
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
- flex: 1
- }
- ]
- }
+ flex: 1,
+ },
+ ],
+ },
});
me.callParent();
store.load();
- }
+ },
}, function() {
fields: [ 'poolid', 'comment' ],
proxy: {
type: 'proxmox',
- url: "/api2/json/pools"
+ url: "/api2/json/pools",
},
- idProperty: 'poolid'
+ idProperty: 'poolid',
});
});
me.store.sort({
property: 'key',
- direction: 'ASC'
+ direction: 'ASC',
});
},
failure: function (response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
});
me.comboItems = [
['__default__', PVE.Utils.render_qemu_bios('')],
['seabios', PVE.Utils.render_qemu_bios('seabios')],
- ['ovmf', PVE.Utils.render_qemu_bios('ovmf')]
+ ['ovmf', PVE.Utils.render_qemu_bios('ovmf')],
];
me.callParent();
- }
+ },
});
model: 'pve-sdn-controller',
sorters: {
property: 'controller',
- order: 'DESC'
+ order: 'DESC',
},
});
header: gettext('Controller'),
sortable: true,
dataIndex: 'controller',
- flex: 1
+ flex: 1,
},
- ]
- }
+ ],
+ },
});
me.callParent();
store.load();
- }
+ },
}, function() {
fields: [ 'controller' ],
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/sdn/controllers"
+ url: "/api2/json/cluster/sdn/controllers",
},
- idProperty: 'controller'
+ idProperty: 'controller',
});
});
model: 'pve-sdn-zone',
sorters: {
property: 'zone',
- order: 'DESC'
+ order: 'DESC',
},
});
header: gettext('Zone'),
sortable: true,
dataIndex: 'zone',
- flex: 1
+ flex: 1,
},
- ]
- }
+ ],
+ },
});
me.callParent();
store.load();
- }
+ },
}, function() {
fields: [ 'zone' ],
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/sdn/zones"
+ url: "/api2/json/cluster/sdn/zones",
},
- idProperty: 'zone'
+ idProperty: 'zone',
});
});
['megasas', PVE.Utils.render_scsihw('megasas')],
['virtio-scsi-pci', PVE.Utils.render_scsihw('virtio-scsi-pci')],
['virtio-scsi-single', PVE.Utils.render_scsihw('virtio-scsi-single')],
- ['pvscsi', PVE.Utils.render_scsihw('pvscsi')]
- ]
+ ['pvscsi', PVE.Utils.render_scsihw('pvscsi')],
+ ],
});
idProperty: 'group',
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/firewall/groups"
+ url: "/api2/json/cluster/firewall/groups",
},
sorters: {
property: 'group',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
Ext.apply(me, {
header: gettext('Security Group'),
dataIndex: 'group',
hideable: false,
- width: 100
+ width: 100,
},
{
header: gettext('Comment'),
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
- flex: 1
- }
- ]
- }
+ flex: 1,
+ },
+ ],
+ },
});
me.callParent();
- }
+ },
});
me.store.setProxy({
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/' + me.guestType + '/' + me.vmid +'/snapshot'
+ url: '/api2/json/nodes/' + me.nodename + '/' + me.guestType + '/' + me.vmid +'/snapshot',
});
me.store.load();
var store = Ext.create('Ext.data.Store', {
fields: [ 'name'],
- filterOnLoad: true
+ filterOnLoad: true,
});
Ext.apply(me, {
header: gettext('Snapshot'),
dataIndex: 'name',
hideable: false,
- flex: 1
- }
- ]
- }
+ flex: 1,
+ },
+ ],
+ },
});
me.callParent();
me.loadStore(me.nodename, me.vmid);
- }
+ },
});
value: gettext('Make sure the SPICE WebDav daemon is installed in the VM.'),
bind: {
hidden: '{!foldersharing.checked}',
- }
- }
+ },
+ },
],
onGetValues: function(values) {
header: gettext('Name'),
dataIndex: 'storage',
hideable: false,
- flex: 1
+ flex: 1,
},
{
header: gettext('Type'),
width: 75,
- dataIndex: 'type'
+ dataIndex: 'type',
},
{
header: gettext('Avail'),
width: 90,
dataIndex: 'avail',
- renderer: Proxmox.Utils.format_size
+ renderer: Proxmox.Utils.format_size,
},
{
header: gettext('Capacity'),
width: 90,
dataIndex: 'total',
- renderer: Proxmox.Utils.format_size
- }
- ]
+ renderer: Proxmox.Utils.format_size,
+ },
+ ],
},
reloadStorageList: function() {
}
var params = {
- format: 1
+ format: 1,
};
var url = '/api2/json/nodes/' + me.nodename + '/storage';
if (me.storageContent) {
me.store.setProxy({
type: 'proxmox',
url: url,
- extraParams: params
+ extraParams: params,
});
me.store.load();
model: 'pve-storage-status',
sorters: {
property: 'storage',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
Ext.apply(me, {
- store: store
+ store: store,
});
me.callParent();
if (nodename) {
me.setNodename(nodename);
}
- }
+ },
}, function() {
Ext.define('pve-storage-status', {
extend: 'Ext.data.Model',
fields: [ 'storage', 'active', 'type', 'avail', 'total' ],
- idProperty: 'storage'
+ idProperty: 'storage',
});
});
sortable: true,
dataIndex: 'id',
renderer: Ext.String.htmlEncode,
- flex: 1
+ flex: 1,
},
{
header: gettext('Comment'),
sortable: false,
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
},
}, function() {
Ext.define('pve-tokens', {
fields: [
'id', 'userid', 'tokenid', 'comment',
{ type: 'boolean', name: 'privsep' },
- { type: 'date', dateFormat: 'timestamp', name: 'expire' }
+ { type: 'date', dateFormat: 'timestamp', name: 'expire' },
],
- idProperty: 'id'
+ idProperty: 'id',
});
});
filters: [
function (item) {
return !!item.data.usbpath && !!item.data.prodid && item.data['class'] != 9;
- }
- ]
+ },
+ ],
});
let emptyText = '';
if (me.type === 'device') {
header: (me.type === 'device')?gettext('Device'):gettext('Port'),
sortable: true,
dataIndex: 'usbid',
- width: 80
+ width: 80,
},
{
header: gettext('Manufacturer'),
sortable: true,
dataIndex: 'manufacturer',
- width: 150
+ width: 150,
},
{
header: gettext('Product'),
sortable: true,
dataIndex: 'product',
- flex: 1
+ flex: 1,
},
{
header: gettext('Speed'),
"1.5": "USB 1.x",
};
return speed_map[value] || value + " Mbps";
- }
- }
- ]
+ },
+ },
+ ],
},
});
me.callParent();
store.load();
- }
+ },
}, function() {
return val;
}
return data.get('vendid') + ':' + data.get('prodid');
- }
+ },
},
'speed', 'product', 'manufacturer', 'vendid', 'prodid', 'usbpath',
- { name: 'port' , type: 'number' },
- { name: 'level' , type: 'number' },
- { name: 'class' , type: 'number' },
- { name: 'devnum' , type: 'number' },
- { name: 'busnum' , type: 'number' },
+ { name: 'port', type: 'number' },
+ { name: 'level', type: 'number' },
+ { name: 'class', type: 'number' },
+ { name: 'devnum', type: 'number' },
+ { name: 'busnum', type: 'number' },
{
name: 'product_and_id',
type: 'string',
return res;
},
},
- ]
+ ],
});
Ext.define('pve-usb-port', {
fields: [
{
name: 'usbid',
- convert: function(val,data) {
+ convert: function(val, data) {
if (val) {
return val;
}
return data.get('busnum') + '-' + data.get('usbpath');
- }
+ },
},
'speed', 'product', 'manufacturer', 'vendid', 'prodid', 'usbpath',
- { name: 'port' , type: 'number' },
- { name: 'level' , type: 'number' },
- { name: 'class' , type: 'number' },
- { name: 'devnum' , type: 'number' },
- { name: 'busnum' , type: 'number' },
+ { name: 'port', type: 'number' },
+ { name: 'level', type: 'number' },
+ { name: 'class', type: 'number' },
+ { name: 'devnum', type: 'number' },
+ { name: 'busnum', type: 'number' },
{
name: 'product_and_id',
type: 'string',
return res;
},
},
- ]
+ ],
});
});
var store = new Ext.data.Store({
model: 'pve-users',
sorters: [{
- property: 'userid'
- }]
+ property: 'userid',
+ }],
});
Ext.apply(me, {
sortable: true,
dataIndex: 'userid',
renderer: Ext.String.htmlEncode,
- flex: 1
+ flex: 1,
},
{
header: gettext('Name'),
sortable: true,
renderer: PVE.Utils.render_full_name,
dataIndex: 'firstname',
- flex: 1
+ flex: 1,
},
{
header: gettext('Comment'),
sortable: false,
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
- flex: 1
- }
- ]
- }
+ flex: 1,
+ },
+ ],
+ },
});
me.callParent();
store.load({ params: { enabled: 1 }});
- }
+ },
}, function() {
Ext.define('pve-users', {
extend: 'Ext.data.Model',
fields: [
- 'userid', 'firstname', 'lastname' , 'email', 'comment',
+ 'userid', 'firstname', 'lastname', 'email', 'comment',
{ type: 'boolean', name: 'enable' },
- { type: 'date', dateFormat: 'timestamp', name: 'expire' }
+ { type: 'date', dateFormat: 'timestamp', name: 'expire' },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/access/users"
+ url: "/api2/json/access/users",
},
- idProperty: 'userid'
+ idProperty: 'userid',
});
});
Ext.apply(me, {
minValue: 1,
- maxValue: 4094
+ maxValue: 4094,
});
me.callParent();
- }
+ },
});
alias: 'widget.vmcpuflagselector',
mixins: {
- field: 'Ext.form.field.Field'
+ field: 'Ext.form.field.Field',
},
disableSelection: true,
{ flag: 'pdpe1gb', desc: 'Allow guest OS to use 1GB size pages, if host HW supports it' },
{ flag: 'hv-tlbflush', desc: 'Improve performance in overcommitted Windows guests. May lead to guest bluescreens on old CPUs.' },
{ flag: 'hv-evmcs', desc: 'Improve performance for nested virtualization. Only supported on Intel CPUs.' },
- { flag: 'aes', desc: 'Activate AES instruction set for HW acceleration.' }
+ { flag: 'aes', desc: 'Activate AES instruction set for HW acceleration.' },
],
listeners: {
update: function() {
this.commitChanges();
- }
- }
+ },
+ },
},
getValue: function() {
default: return 'Unknown';
}
},
- width: 65
+ width: 65,
},
{
xtype: 'widgetcolumn',
view.dirty = view.getValue() !== view.originalValue;
view.checkDirty();
//view.checkChange();
- }
+ },
},
items: [
{
boxLabel: '-',
boxLabelAlign: 'before',
- inputValue: '-'
+ inputValue: '-',
},
{
checked: true,
- inputValue: '='
+ inputValue: '=',
},
{
boxLabel: '+',
- inputValue: '+'
- }
- ]
- }
+ inputValue: '+',
+ },
+ ],
+ },
},
{
dataIndex: 'flag',
- width: 100
+ width: 100,
},
{
dataIndex: 'desc',
cellWrap: true,
- flex: 1
- }
+ flex: 1,
+ },
],
initComponent: function() {
me.value = me.originalValue = '';
me.callParent(arguments);
- }
+ },
});
alias: 'widget.vmselector',
mixins: {
- field: 'Ext.form.field.Field'
+ field: 'Ext.form.field.Field',
},
allowBlank: true,
sorters: 'vmid',
filters: [{
property: 'type',
- value: /lxc|qemu/
- }]
+ value: /lxc|qemu/,
+ }],
},
columns: [
{
dataIndex: 'vmid',
width: 80,
filter: {
- type: 'number'
- }
+ type: 'number',
+ },
},
{
header: gettext('Node'),
- dataIndex: 'node'
+ dataIndex: 'node',
},
{
header: gettext('Status'),
dataIndex: 'status',
filter: {
- type: 'list'
- }
+ type: 'list',
+ },
},
{
header: gettext('Name'),
dataIndex: 'name',
flex: 1,
filter: {
- type: 'string'
- }
+ type: 'string',
+ },
},
{
header: gettext('Pool'),
dataIndex: 'pool',
filter: {
- type: 'list'
- }
+ type: 'list',
+ },
},
{
header: gettext('Type'),
store: {
data: [
{id: 'qemu', text: gettext('Virtual Machine')},
- {id: 'lxc', text: gettext('LXC Container')}
+ {id: 'lxc', text: gettext('LXC Container')},
],
// due to EXTJS-18711
// we have to do a static list via a store
// but to avoid creating an object,
// we have to have a pseudo un function
- un: function(){}
- }
- }
+ un: function(){},
+ },
+ },
},
{
header: 'HA ' + gettext('Status'),
dataIndex: 'hastate',
flex: 1,
filter: {
- type: 'list'
- }
- }
+ type: 'list',
+ },
+ },
],
selModel: {
selType: 'checkboxmodel',
- mode: 'SIMPLE'
+ mode: 'SIMPLE',
},
checkChangeEvents: [
'selectionchange',
- 'change'
+ 'change',
],
listeners: {
selectionchange: function() {
// to trigger validity and error checks
this.checkChange();
- }
+ },
},
getValue: function() {
var store = me.getStore();
value.forEach(function(item) {
- var rec = store.findRecord('vmid',item, 0, false, true, true);
+ var rec = store.findRecord('vmid', item, 0, false, true, true);
console.log(store);
if (rec) {
var me = this;
if (me.allowBlank === false &&
me.getSelectionModel().getCount() === 0) {
- me.addBodyCls(['x-form-trigger-wrap-default','x-form-trigger-wrap-invalid']);
+ me.addBodyCls(['x-form-trigger-wrap-default', 'x-form-trigger-wrap-invalid']);
return [gettext('No VM selected')];
}
- me.removeBodyCls(['x-form-trigger-wrap-default','x-form-trigger-wrap-invalid']);
+ me.removeBodyCls(['x-form-trigger-wrap-default', 'x-form-trigger-wrap-invalid']);
return [];
},
me.store.filters.add({
property: 'node',
exactMatch: true,
- value: me.nodename
+ value: me.nodename,
});
}
if (statusfilter !== '') {
me.store.filters.add({
property: 'template',
- value: 0
- },{
+ value: 0,
+ }, {
id: 'x-gridfilter-status',
operator: 'in',
property: 'status',
- value: [statusfilter]
+ value: [statusfilter],
});
}
}
var sm = me.getSelectionModel();
if (me.selectAll) {
- me.mon(store,'load', function(){
+ me.mon(store, 'load', function(){
me.getSelectionModel().selectAll(false);
});
}
- }
+ },
});
sorters: 'vmid',
filters: [{
property: 'type',
- value: /lxc|qemu/
- }]
+ value: /lxc|qemu/,
+ }],
},
listConfig: {
dataIndex: 'vmid',
width: 80,
filter: {
- type: 'number'
- }
+ type: 'number',
+ },
},
{
header: gettext('Name'),
dataIndex: 'name',
flex: 1,
filter: {
- type: 'string'
- }
+ type: 'string',
+ },
},
{
header: gettext('Node'),
- dataIndex: 'node'
+ dataIndex: 'node',
},
{
header: gettext('Status'),
dataIndex: 'status',
filter: {
- type: 'list'
- }
+ type: 'list',
+ },
},
{
header: gettext('Pool'),
dataIndex: 'pool',
hidden: true,
filter: {
- type: 'list'
- }
+ type: 'list',
+ },
},
{
header: gettext('Type'),
store: {
data: [
{id: 'qemu', text: gettext('Virtual Machine')},
- {id: 'lxc', text: gettext('LXC Container')}
+ {id: 'lxc', text: gettext('LXC Container')},
],
- un: function(){} // due to EXTJS-18711
- }
- }
+ un: function(){}, // due to EXTJS-18711
+ },
+ },
},
{
header: 'HA ' + gettext('Status'),
hidden: true,
flex: 1,
filter: {
- type: 'list'
- }
- }
- ]
- }
+ type: 'list',
+ },
+ },
+ ],
+ },
});
Ext.define('PVE.form.VNCKeyboardSelector', {
extend: 'Proxmox.form.KVComboBox',
alias: ['widget.VNCKeyboardSelector'],
- comboItems: PVE.Utils.kvm_keymap_array()
+ comboItems: PVE.Utils.kvm_keymap_array(),
});
var default_views = {
server: {
text: gettext('Server View'),
- groups: ['node']
+ groups: ['node'],
},
folder: {
text: gettext('Folder View'),
- groups: ['type']
+ groups: ['type'],
},
storage: {
text: gettext('Storage View'),
groups: ['node'],
filterfn: function(node) {
return node.data.type === 'storage' || node.data.type === 'node';
- }
+ },
},
pool: {
text: gettext('Pool View'),
filterfn: function(node) {
return node.data.type === 'qemu' || node.data.type === 'lxc' || node.data.type === 'openvz' ||
node.data.type === 'pool';
- }
- }
+ },
+ },
};
var groupdef = [];
model: 'KeyValue',
proxy: {
type: 'memory',
- reader: 'array'
+ reader: 'array',
},
data: groupdef,
- autoload: true
+ autoload: true,
});
Ext.apply(me, {
stateEvents: [ 'select' ],
stateful: true,
stateId: 'pveview',
- id: 'view'
+ id: 'view',
});
me.callParent();
var sp = Ext.state.Manager.getProvider();
me.mon(sp, 'statechange', statechange, me);
- }
+ },
});
['comstar', 'Comstar'],
[ 'istgt', 'istgt'],
[ 'iet', 'IET'],
- [ 'LIO', 'LIO']
- ]
+ [ 'LIO', 'LIO'],
+ ],
});
property: 'volid',
value: '',
anyMatch: true,
- caseSensitive: false
+ caseSensitive: false,
};
var vmidFilter = {
model: 'pve-storage-content',
sorters: {
property: 'volid',
- order: 'DESC'
+ order: 'DESC',
},
filters: [
vmtypeFilter,
searchFilter,
vmidFilter,
- ]
+ ],
});
let updateFilter = function() {
me.store.setProxy({
type: 'proxmox',
- url: url
+ url: url,
});
reload();
});
}
setStorage(value);
- }
- }
+ },
+ },
});
var storagefilter = Ext.create('Ext.form.field.Text', {
me.store.clearFilter(true);
searchFilter.value = field.getValue();
updateFilter();
- }
- }
+ },
+ },
});
var vmidfilterCB = Ext.create('Ext.form.field.Checkbox', {
listeners : {
close: function() {
reload();
- }
- }
+ },
+ },
});
win.show();
- }
+ },
});
var restore_btn = Ext.create('Proxmox.button.Button', {
vmid: vmid,
volid: rec.data.volid,
volidText: PVE.Utils.render_storage_content(rec.data.volid, {}, rec),
- vmtype: vmtype
+ vmtype: vmtype,
});
win.show();
win.on('destroy', reload);
- }
+ },
});
var delete_btn = Ext.create('Proxmox.button.StdRemoveButton', {
},
callback: function() {
reload();
- }
+ },
});
var config_btn = Ext.create('Proxmox.button.Button', {
var win = Ext.create('PVE.window.BackupConfig', {
volume: rec.data.volid,
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
win.show();
- }
+ },
});
Ext.apply(me, {
storagesel,
'-',
vmidfilterCB,
- storagefilter
+ storagefilter,
],
},
columns: [
flex: 2,
sortable: true,
renderer: PVE.Utils.render_storage_content,
- dataIndex: 'volid'
+ dataIndex: 'volid',
},
{
header: gettext('Notes'),
{
header: gettext('Date'),
width: 150,
- dataIndex: 'vdate'
+ dataIndex: 'vdate',
},
{
header: gettext('Format'),
width: 100,
- dataIndex: 'format'
+ dataIndex: 'format',
},
{
header: gettext('Size'),
width: 100,
renderer: Proxmox.Utils.format_size,
- dataIndex: 'size'
+ dataIndex: 'size',
},
{
header: gettext('VMID'),
header: gettext('Verify State'),
dataIndex: 'verification',
renderer: PVE.Utils.render_backup_verification,
- }
- ]
+ },
+ ],
});
me.callParent();
- }
+ },
});
xtype: 'textfield',
name: me.isCreate ? 'name' : 'rename',
fieldLabel: gettext('Name'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
name: 'cidr',
fieldLabel: gettext('IP/CIDR'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
name: 'comment',
- fieldLabel: gettext('Comment')
- }
+ fieldLabel: gettext('Comment'),
+ },
];
var ipanel = Ext.create('Proxmox.panel.InputPanel', {
isCreate: me.isCreate,
- items: items
+ items: items,
});
Ext.apply(me, {
subject: gettext('Alias'),
isAdd: true,
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
var values = response.result.data;
values.rename = values.name;
ipanel.setValues(values);
- }
+ },
});
}
- }
+ },
});
Ext.define('pve-fw-aliases', {
extend: 'Ext.data.Model',
fields: [ 'name', 'cidr', 'comment', 'digest' ],
- idProperty: 'name'
+ idProperty: 'name',
});
Ext.define('PVE.FirewallAliases', {
model: 'pve-fw-aliases',
proxy: {
type: 'proxmox',
- url: "/api2/json" + me.base_url
+ url: "/api2/json" + me.base_url,
},
sorters: {
property: 'name',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var sm = Ext.create('Ext.selection.RowModel', {});
var win = Ext.create('PVE.FirewallAliasEdit', {
base_url: me.base_url,
- alias_name: rec.data.name
+ alias_name: rec.data.name,
});
win.show();
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
me.addBtn = Ext.create('Ext.Button', {
text: gettext('Add'),
handler: function() {
var win = Ext.create('PVE.FirewallAliasEdit', {
- base_url: me.base_url
+ base_url: me.base_url,
});
win.on('destroy', reload);
win.show();
- }
+ },
});
me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: me.base_url + '/',
- callback: reload
+ callback: reload,
});
dataIndex: 'comment',
renderer: Ext.String.htmlEncode,
flex: 3,
- }
+ },
],
listeners: {
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
me.on('activate', reload);
- }
+ },
});
}
return value;
- }
+ },
});
};
items: {
xtype: 'pveFirewallLogLevels',
name: name,
- fieldLabel: name
- }
- }
+ fieldLabel: name,
+ },
+ },
};
};
renderer: Proxmox.Utils.format_boolean,
editor: {
xtype: 'pveFirewallEnableEdit',
- defaultValue: 1
- }
+ defaultValue: 1,
+ },
};
add_boolean_row('nosmurfs', gettext('SMURFS filter'), 1);
add_boolean_row('tcpflags', gettext('TCP flags filter'), 0);
renderer: Proxmox.Utils.format_boolean,
editor: {
xtype: 'pveFirewallEnableEdit',
- defaultValue: 0
- }
+ defaultValue: 0,
+ },
};
add_boolean_row('dhcp', 'DHCP', 1);
add_boolean_row('ndp', 'NDP', 1);
defaultValue: gettext('Default') + ' (enable=1,rate1/second,burst=5)',
editor: {
xtype: 'pveFirewallLograteEdit',
- defaultValue: 'enable=1'
- }
+ defaultValue: 'enable=1',
+ },
};
}
xtype: 'pveFirewallPolicySelector',
name: 'policy_in',
value: 'DROP',
- fieldLabel: gettext('Input Policy')
- }
- }
+ fieldLabel: gettext('Input Policy'),
+ },
+ },
};
me.rows.policy_out = {
xtype: 'pveFirewallPolicySelector',
name: 'policy_out',
value: 'ACCEPT',
- fieldLabel: gettext('Output Policy')
- }
- }
+ fieldLabel: gettext('Output Policy'),
+ },
+ },
};
}
var edit_btn = new Ext.Button({
text: gettext('Edit'),
disabled: true,
- handler: function() { me.run_editor(); }
+ handler: function() { me.run_editor(); },
});
var set_button_status = function() {
url: "/api2/json" + me.base_url,
tbar: [ edit_btn ],
editorConfig: {
- url: '/api2/extjs/' + me.base_url
+ url: '/api2/extjs/' + me.base_url,
},
listeners: {
itemdblclick: me.run_editor,
- selectionchange: set_button_status
- }
+ selectionchange: set_button_status,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
value: 'nolog',
comboItems: [['nolog', 'nolog'], ['emerg', 'emerg'], ['alert', 'alert'],
['crit', 'crit'], ['err', 'err'], ['warning', 'warning'],
- ['notice', 'notice'], ['info', 'info'], ['debug', 'debug']]
+ ['notice', 'notice'], ['info', 'info'], ['debug', 'debug']],
});
header: gettext('Macro'),
dataIndex: 'macro',
hideable: false,
- width: 100
+ width: 100,
},
{
header: gettext('Description'),
renderer: Ext.String.htmlEncode,
flex: 1,
- dataIndex: 'descr'
- }
- ]
+ dataIndex: 'descr',
+ },
+ ],
},
initComponent: function() {
var me = this;
idProperty: 'macro',
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/firewall/macros"
+ url: "/api2/json/cluster/firewall/macros",
},
sorters: {
property: 'macro',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
Ext.apply(me, {
- store: store
+ store: store,
});
me.callParent();
- }
+ },
});
Ext.define('PVE.FirewallRulePanel', {
// form again.
xtype: 'hiddenfield',
name: 'modified_marker',
- value: ''
+ value: '',
},
{
xtype: 'proxmoxKVComboBox',
value: 'in',
comboItems: [['in', 'in'], ['out', 'out']],
fieldLabel: gettext('Direction'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxKVComboBox',
value: 'ACCEPT',
comboItems: [['ACCEPT', 'ACCEPT'], ['DROP', 'DROP'], ['REJECT', 'REJECT']],
fieldLabel: gettext('Action'),
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
if (me.allow_iface) {
name: 'iface',
deleteEmpty: !me.isCreate,
value: '',
- fieldLabel: gettext('Interface')
+ fieldLabel: gettext('Interface'),
});
} else {
me.column1.push({
xtype: 'displayfield',
fieldLabel: '',
- value: ''
+ value: '',
});
}
xtype: 'displayfield',
fieldLabel: '',
height: 7,
- value: ''
+ value: '',
},
{
xtype: 'pveIPRefSelector',
editable: true,
base_url: me.list_refs_url,
value: '',
- fieldLabel: gettext('Source')
+ fieldLabel: gettext('Source'),
},
{
editable: true,
base_url: me.list_refs_url,
value: '',
- fieldLabel: gettext('Destination')
- }
+ fieldLabel: gettext('Destination'),
+ },
);
name: 'enable',
checked: false,
uncheckedValue: 0,
- fieldLabel: gettext('Enable')
+ fieldLabel: gettext('Enable'),
},
{
xtype: 'pveFWMacroSelector',
me.down('field[name=dport]').setDisabled(true);
me.down('field[name=dport]').setValue('');
}
- }
- }
+ },
+ },
},
{
xtype: 'pveIPProtocolSelector',
autoSelect: false,
editable: true,
value: '',
- fieldLabel: gettext('Protocol')
+ fieldLabel: gettext('Protocol'),
},
{
xtype: 'displayfield',
fieldLabel: '',
height: 7,
- value: ''
+ value: '',
},
{
xtype: 'textfield',
name: 'sport',
value: '',
- fieldLabel: gettext('Source port')
+ fieldLabel: gettext('Source port'),
},
{
xtype: 'textfield',
name: 'dport',
value: '',
- fieldLabel: gettext('Dest. port')
- }
+ fieldLabel: gettext('Dest. port'),
+ },
];
me.advancedColumn1 = [
{
- xtype: 'pveFirewallLogLevels'
- }
+ xtype: 'pveFirewallLogLevels',
+ },
];
me.columnB = [
xtype: 'textfield',
name: 'comment',
value: '',
- fieldLabel: gettext('Comment')
- }
+ fieldLabel: gettext('Comment'),
+ },
];
me.callParent();
- }
+ },
});
Ext.define('PVE.FirewallRuleEdit', {
isCreate: me.isCreate,
list_refs_url: me.list_refs_url,
allow_iface: me.allow_iface,
- rule_pos: me.rule_pos
+ rule_pos: me.rule_pos,
});
Ext.apply(me, {
subject: gettext('Rule'),
isAdd: true,
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
form.markInvalid(values.errors);
}, 100);
}
- }
+ },
});
} else if (me.rec) {
ipanel.setValues(me.rec.data);
}
- }
+ },
});
Ext.define('PVE.FirewallGroupRuleEdit', {
{
xtype: 'hiddenfield',
name: 'type',
- value: 'group'
+ value: 'group',
},
{
xtype: 'pveSecurityGroupsSelector',
name: 'action',
value: '',
fieldLabel: gettext('Security Group'),
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
if (me.allow_iface) {
name: 'iface',
deleteEmpty: !me.isCreate,
value: '',
- fieldLabel: gettext('Interface')
+ fieldLabel: gettext('Interface'),
});
}
name: 'enable',
checked: false,
uncheckedValue: 0,
- fieldLabel: gettext('Enable')
- }
+ fieldLabel: gettext('Enable'),
+ },
],
columnB: [
{
xtype: 'textfield',
name: 'comment',
value: '',
- fieldLabel: gettext('Comment')
- }
- ]
+ fieldLabel: gettext('Comment'),
+ },
+ ],
});
Ext.apply(me, {
subject: gettext('Rule'),
isAdd: true,
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
success: function(response, options) {
var values = response.result.data;
ipanel.setValues(values);
- }
+ },
});
}
- }
+ },
});
Ext.define('PVE.FirewallRules', {
}
me.store.setProxy({
type: 'proxmox',
- url: '/api2/json' + url
+ url: '/api2/json' + url,
});
me.store.load();
},
callback: function() {
me.store.load();
- }
+ },
});
},
},
callback: function() {
me.store.load();
- }
+ },
});
},
throw "no list_refs_url specified";
}
- var store = Ext.create('Ext.data.Store',{
- model: 'pve-fw-rule'
+ var store = Ext.create('Ext.data.Store', {
+ model: 'pve-fw-rule',
});
var reload = function() {
allow_iface: me.allow_iface,
base_url: me.base_url,
list_refs_url: me.list_refs_url,
- rule_pos: rec.data.pos
+ rule_pos: rec.data.pos,
});
win.show();
win.on('destroy', reload);
};
- me.editBtn = Ext.create('Proxmox.button.Button',{
+ me.editBtn = Ext.create('Proxmox.button.Button', {
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
me.addBtn = Ext.create('Ext.Button', {
var win = Ext.create('PVE.FirewallRuleEdit', {
allow_iface: me.allow_iface,
base_url: me.base_url,
- list_refs_url: me.list_refs_url
+ list_refs_url: me.list_refs_url,
});
win.on('destroy', reload);
win.show();
- }
+ },
});
var run_copy_editor = function() {
allow_iface: me.allow_iface,
base_url: me.base_url,
list_refs_url: me.list_refs_url,
- rec: rec
+ rec: rec,
});
win.show();
win.on('destroy', reload);
};
- me.copyBtn = Ext.create('Proxmox.button.Button',{
+ me.copyBtn = Ext.create('Proxmox.button.Button', {
text: gettext('Copy'),
selModel: sm,
enableFn: function(rec) {
return (rec.data.type === 'in' || rec.data.type === 'out');
},
disabled: true,
- handler: run_copy_editor
+ handler: run_copy_editor,
});
if (me.allow_groups) {
handler: function() {
var win = Ext.create('PVE.FirewallGroupRuleEdit', {
allow_iface: me.allow_iface,
- base_url: me.base_url
+ base_url: me.base_url,
});
win.on('destroy', reload);
win.show();
- }
+ },
});
}
- me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton',{
+ me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: me.base_url + '/',
confirmMsg: false,
},
callback: function() {
me.store.load();
- }
+ },
});
var tbar = me.tbar_prefix ? [ me.tbar_prefix ] : [];
metaData.tdCls = 'proxmox-invalid-row';
var html = '<p>' + Ext.htmlEncode(errors[name]) + '</p>';
metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' +
- html.replace(/\"/g,'"') + '"';
+ html.replace(/\"/g, '"') + '"';
}
return value;
};
return value;
}
return '';
- }
+ },
},
{
xtype: 'checkcolumn',
delete data.iface;
}
me.updateRule(data);
- }
+ },
},
- width: 50
+ width: 50,
},
{
header: gettext('Type'),
renderer: function(value, metaData, record) {
return render_errors('type', value, metaData, record);
},
- width: 50
+ width: 50,
},
{
header: gettext('Action'),
renderer: function(value, metaData, record) {
return render_errors('action', value, metaData, record);
},
- width: 80
+ width: 80,
},
{
header: gettext('Macro'),
renderer: function(value, metaData, record) {
return render_errors('macro', value, metaData, record);
},
- width: 80
- }
+ width: 80,
+ },
];
if (me.allow_iface) {
renderer: function(value, metaData, record) {
return render_errors('iface', value, metaData, record);
},
- width: 80
+ width: 80,
});
}
renderer: function(value, metaData, record) {
return render_errors('source', value, metaData, record);
},
- width: 100
+ width: 100,
},
{
header: gettext('Destination'),
renderer: function(value, metaData, record) {
return render_errors('dest', value, metaData, record);
},
- width: 100
+ width: 100,
},
{
header: gettext('Protocol'),
renderer: function(value, metaData, record) {
return render_errors('proto', value, metaData, record);
},
- width: 100
+ width: 100,
},
{
header: gettext('Dest. port'),
renderer: function(value, metaData, record) {
return render_errors('dport', value, metaData, record);
},
- width: 100
+ width: 100,
},
{
header: gettext('Source port'),
renderer: function(value, metaData, record) {
return render_errors('sport', value, metaData, record);
},
- width: 100
+ width: 100,
},
{
header: gettext('Log level'),
renderer: function(value, metaData, record) {
return render_errors('log', value, metaData, record);
},
- width: 100
+ width: 100,
},
{
header: gettext('Comment'),
flex: 1,
renderer: function(value, metaData, record) {
return render_errors('comment', Ext.util.Format.htmlEncode(value), metaData, record);
- }
- }
+ },
+ },
);
Ext.apply(me, {
{
ptype: 'gridviewdragdrop',
dragGroup: 'FWRuleDDGroup',
- dropGroup: 'FWRuleDDGroup'
- }
+ dropGroup: 'FWRuleDDGroup',
+ },
],
listeners: {
beforedrop: function(node, data, dropRec, dropPosition) {
me.moveRule(pos, moveto);
return 0;
},
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
},
sortableColumns: false,
- columns: columns
+ columns: columns,
});
me.callParent();
if (me.base_url) {
me.setBaseUrl(me.base_url); // load
}
- }
+ },
}, function() {
Ext.define('pve-fw-rule', {
fields: [ { name: 'enable', type: 'boolean' },
'type', 'action', 'macro', 'source', 'dest', 'proto', 'iface',
'dport', 'sport', 'comment', 'pos', 'digest', 'errors' ],
- idProperty: 'pos'
+ idProperty: 'pos',
});
});
var vmsField = Ext.create('Ext.form.field.Text', {
name: 'vms',
hidden: true,
- allowBlank: false
+ allowBlank: false,
});
var vmStore = Ext.create('Ext.data.Store', {
sorters: [
{
property: 'vmid',
- order: 'ASC'
- }
+ order: 'ASC',
+ },
],
filters: [
function(item) {
return ((item.data.type === 'lxc' || item.data.type === 'qemu') && item.data.pool === '');
- }
- ]
+ },
+ ],
});
- var vmGrid = Ext.create('widget.grid',{
+ var vmGrid = Ext.create('widget.grid', {
store: vmStore,
border: true,
height: 300,
selectedVms.push(vm.data.vmid);
});
vmsField.setValue(selectedVms);
- }
- }
+ },
+ },
},
columns: [
{
header: 'ID',
dataIndex: 'vmid',
- width: 60
+ width: 60,
},
{
header: gettext('Node'),
- dataIndex: 'node'
+ dataIndex: 'node',
},
{
header: gettext('Status'),
} else {
return Proxmox.Utils.stoppedText;
}
- }
+ },
},
{
header: gettext('Name'),
dataIndex: 'name',
- flex: 1
+ flex: 1,
},
{
header: gettext('Type'),
- dataIndex: 'type'
- }
- ]
+ dataIndex: 'type',
+ },
+ ],
});
Ext.apply(me, {
subject: gettext('Virtual Machine'),
- items: [ vmsField, vmGrid ]
+ items: [ vmsField, vmGrid ],
});
me.callParent();
vmStore.load();
- }
+ },
});
Ext.define('PVE.pool.AddStorage', {
nodename: 'localhost',
autoSelect: false,
value: '',
- fieldLabel: gettext("Storage")
- }
- ]
+ fieldLabel: gettext("Storage"),
+ },
+ ],
});
me.callParent();
- }
+ },
});
Ext.define('PVE.grid.PoolMembers', {
sorters: [
{
property : 'type',
- direction: 'ASC'
- }
+ direction: 'ASC',
+ },
],
proxy: {
type: 'proxmox',
root: 'data.members',
- url: "/api2/json/pools/" + me.pool
- }
+ url: "/api2/json/pools/" + me.pool,
+ },
});
var coldef = PVE.data.ResourceStore.defaultColumns();
},
failure: function (response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
});
Ext.apply(me, {
var win = Ext.create('PVE.pool.AddVM', { pool: me.pool });
win.on('destroy', reload);
win.show();
- }
+ },
},
{
text: gettext('Storage'),
var win = Ext.create('PVE.pool.AddStorage', { pool: me.pool });
win.on('destroy', reload);
win.show();
- }
- }
- ]
- })
+ },
+ },
+ ],
+ }),
},
- remove_btn
+ remove_btn,
],
viewConfig: {
- stripeRows: true
+ stripeRows: true,
},
columns: coldef,
listeners: {
var ws = me.up('pveStdWorkspace');
ws.selectById(record.data.id);
},
- activate: reload
- }
+ activate: reload,
+ },
});
me.callParent();
- }
+ },
});
xtype: (me.isCreate && !vmid)?'pveGuestIDSelector':'displayfield',
name: 'guest',
fieldLabel: 'CT/VM ID',
- value: vmid || ''
+ value: vmid || '',
});
items.push(
disallowedNodes: [nodename],
allowBlank: false,
onlineValidator: true,
- fieldLabel: gettext("Target")
+ fieldLabel: gettext("Target"),
},
{
xtype: 'pveCalendarEvent',
fieldLabel: gettext('Schedule'),
emptyText: '*/15 - ' + Ext.String.format(gettext('Every {0} minutes'), 15),
- name: 'schedule'
+ name: 'schedule',
},
{
xtype: 'numberfield',
step: 1,
minValue: 1,
emptyText: gettext('unlimited'),
- name: 'rate'
+ name: 'rate',
},
{
xtype: 'textfield',
fieldLabel: gettext('Comment'),
- name: 'comment'
+ name: 'comment',
},
{
xtype: 'proxmoxcheckbox',
name: 'enabled',
defaultValue: 'on',
checked: true,
- fieldLabel: gettext('Enabled')
- }
+ fieldLabel: gettext('Enabled'),
+ },
);
me.items = [
}
return values;
},
- items: items
- }
+ items: items,
+ },
];
me.callParent();
Ext.Array.forEach(jobs, function(job) {
var match = /^([0-9]+)\-([0-9]+)$/.exec(job.id);
if (match) {
- var vmid = parseInt(match[1],10);
- var id = parseInt(match[2],10);
+ var vmid = parseInt(match[1], 10);
+ var id = parseInt(match[2], 10);
if (highestids[vmid] < id ||
highestids[vmid] === undefined) {
highestids[vmid] = id;
});
me.highestids = highestids;
- }
+ },
});
} else {
response.result.data.enabled = !response.result.data.disable;
me.setValues(response.result.data);
me.digest = response.result.data.digest;
- }
+ },
});
}
- }
+ },
});
/* callback is a function and string */
controller: {
xclass: 'Ext.app.ViewController',
- addJob: function(button,event,rec) {
+ addJob: function(button, event, rec) {
var me = this.getView();
var controller = this;
var win = Ext.create('PVE.window.ReplicaEdit', {
isCreate: true,
method: 'POST',
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
win.on('destroy', function() { controller.reload(); });
win.show();
},
- editJob: function(button,event,rec) {
+ editJob: function(button, event, rec) {
var me = this.getView();
var controller = this;
var data = rec.data;
var win = Ext.create('PVE.window.ReplicaEdit', {
url: '/cluster/replication/' + data.id,
method: 'PUT',
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
win.on('destroy', function() { controller.reload(); });
win.show();
},
- scheduleJobNow: function(button,event,rec) {
+ scheduleJobNow: function(button, event, rec) {
var me = this.getView();
var controller = this;
callback: function() { controller.reload(); },
failure: function (response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
var controller = this;
var logView = Ext.create('Proxmox.panel.LogView', {
border: false,
- url: "/api2/extjs/nodes/" + me.nodename + "/replication/" + rec.data.id + "/log"
+ url: "/api2/extjs/nodes/" + me.nodename + "/replication/" + rec.data.id + "/log",
});
var win = Ext.create('Ext.window.Window', {
items: [ logView ],
width: 800,
height: 400,
modal: true,
- title: gettext("Replication Log")
+ title: gettext("Replication Log"),
});
var task = {
run: function() {
logView.requestUpdate();
},
- interval: 1000
+ interval: 1000,
};
Ext.TaskManager.start(task);
win.on('destroy', function() {
control: {
'#': {
itemdblclick: 'dblClick',
- afterlayout: 'checkPrerequisites'
- }
- }
+ afterlayout: 'checkPrerequisites',
+ },
+ },
},
tbar: [
{
text: gettext('Add'),
itemId: 'addButton',
- handler: 'addJob'
+ handler: 'addJob',
},
{
xtype: 'proxmoxButton',
text: gettext('Edit'),
itemId: 'editButton',
handler: 'editJob',
- disabled: true
+ disabled: true,
},
{
xtype: 'proxmoxStdRemoveButton',
itemId: 'removeButton',
baseurl: '/api2/extjs/cluster/replication/',
dangerous: true,
- callback: 'reload'
+ callback: 'reload',
},
{
xtype: 'proxmoxButton',
text: gettext('Log'),
itemId: 'logButton',
handler: 'showLog',
- disabled: true
+ disabled: true,
},
{
xtype: 'proxmoxButton',
text: gettext('Schedule now'),
itemId: 'scheduleNowButton',
handler: 'scheduleJobNow',
- disabled: true
- }
+ disabled: true,
+ },
],
initComponent: function() {
dataIndex: 'enabled',
xtype: 'checkcolumn',
sortable: true,
- disabled: true
+ disabled: true,
},
{
text: 'ID',
dataIndex: 'id',
width: 60,
- hidden: true
+ hidden: true,
},
{
text: gettext('Guest'),
dataIndex: 'guest',
- width: 75
+ width: 75,
},
{
text: gettext('Job'),
dataIndex: 'jobnum',
- width: 60
+ width: 60,
},
{
text: gettext('Target'),
- dataIndex: 'target'
- }
+ dataIndex: 'target',
+ },
];
if (!me.nodename) {
}
return icons.join(',') + ' ' + states.join(',');
- }
+ },
},
{
text: gettext('Last Sync'),
}
return Proxmox.Utils.render_timestamp(value);
- }
+ },
},
{
text: gettext('Duration'),
dataIndex: 'duration',
width: 60,
- renderer: Proxmox.Utils.render_duration
+ renderer: Proxmox.Utils.render_duration,
},
{
text: gettext('Next Sync'),
}
return Proxmox.Utils.render_timestamp(value);
- }
- }
+ },
+ },
);
}
{
text: gettext('Schedule'),
width: 75,
- dataIndex: 'schedule'
+ dataIndex: 'schedule',
},
{
text: gettext('Rate limit'),
return value.toString() + ' MB/s';
},
- hidden: true
+ hidden: true,
},
{
text: gettext('Comment'),
dataIndex: 'comment',
- renderer: Ext.htmlEncode
- }
+ renderer: Ext.htmlEncode,
+ },
);
me.rstore = Ext.create('Proxmox.data.UpdateStore', {
interval: 3000,
proxy: {
type: 'proxmox',
- url: "/api2/json" + url
- }
+ url: "/api2/json" + url,
+ },
});
me.store = Ext.create('Proxmox.data.DiffStore', {
rstore: me.rstore,
sorters: [
{
- property: 'guest'
+ property: 'guest',
},
{
- property: 'jobnum'
- }
- ]
+ property: 'jobnum',
+ },
+ ],
});
me.callParent();
me.on('destroy', me.rstore.stopUpdate);
me.rstore.startUpdate();
- }
+ },
}, function() {
Ext.define('pve-replication', {
{ name: 'jobnum', type: 'integer' },
{ name: 'schedule', defaultValue: '*/15' },
{ name: 'disable', defaultValue: '' },
- { name: 'enabled', calculate: function(data) { return !data.disable; } }
- ]
+ { name: 'enabled', calculate: function(data) { return !data.disable; } },
+ ],
});
Ext.define('pve-replication-state', {
extend: 'pve-replication',
fields: [
'last_sync', 'next_sync', 'error', 'duration', 'state',
- 'fail_count', 'remove_job', 'pid'
- ]
+ 'fail_count', 'remove_job', 'pid',
+ ],
});
});
border: false,
defaultSorter: {
property: 'type',
- direction: 'ASC'
+ direction: 'ASC',
},
initComponent : function() {
var me = this;
var store = Ext.create('Ext.data.Store', {
model: 'PVEResources',
sorters: me.defaultSorter,
- proxy: { type: 'memory' }
+ proxy: { type: 'memory' },
});
var textfilter = '';
var v = field.getValue();
textfilter = v.toLowerCase();
filter_task.delay(500);
- }
- }
- }
+ },
+ },
+ },
],
viewConfig: {
- stripeRows: true
+ stripeRows: true,
},
listeners: {
itemcontextmenu: PVE.Utils.createCmdMenu,
},
destroy: function() {
rstore.un("load", load_cb);
- }
+ },
},
- columns: coldef
+ columns: coldef,
});
me.callParent();
updateGrid();
rstore.on("load", load_cb);
- }
+ },
});
var store = new Ext.data.Store({
model: 'pve-ha-fencing',
- data: []
+ data: [],
});
Ext.apply(me, {
viewConfig: {
trackOver: false,
deferEmptyText: false,
- emptyText: 'Use watchdog based fencing.'
+ emptyText: 'Use watchdog based fencing.',
},
columns: [
{
header: 'Node',
width: 100,
sortable: true,
- dataIndex: 'node'
+ dataIndex: 'node',
},
{
header: gettext('Command'),
flex: 1,
- dataIndex: 'command'
- }
- ]
+ dataIndex: 'command',
+ },
+ ],
});
me.callParent();
- }
+ },
}, function() {
Ext.define('pve-ha-fencing', {
extend: 'Ext.data.Model',
fields: [
- 'node', 'command', 'digest'
- ]
+ 'node', 'command', 'digest',
+ ],
});
});
listeners: {
selectionchange: function(model, selected) {
update_nodefield(selected);
- }
- }
+ },
+ },
});
// use already cached data to avoid an API call
data: data,
proxy: {
type: 'memory',
- reader: {type: 'json'}
+ reader: {type: 'json'},
},
sorters: [
{
property : 'node',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
});
var nodegrid = Ext.createWidget('grid', {
{
header: gettext('Node'),
flex: 1,
- dataIndex: 'node'
+ dataIndex: 'node',
},
{
header: gettext('Memory usage') + " %",
renderer: PVE.Utils.render_mem_usage_percent,
sortable: true,
width: 150,
- dataIndex: 'mem'
+ dataIndex: 'mem',
},
{
header: gettext('CPU usage'),
renderer: PVE.Utils.render_cpu,
sortable: true,
width: 150,
- dataIndex: 'cpu'
+ dataIndex: 'cpu',
},
{
header: 'Priority',
var record = numberfield.getWidgetRecord();
record.set('priority', value);
update_nodefield(sm.getSelection());
- }
- }
- }
- }
- ]
+ },
+ },
+ },
+ },
+ ],
});
var nodefield = Ext.create('Ext.form.field.Hidden', {
listeners: {
change: function (nodefield, value) {
update_node_selection(value);
- }
+ },
},
isValid: function () {
var value = nodefield.getValue();
return (value && 0 !== value.length);
- }
+ },
});
update_node_selection = function(string) {
value: me.groupId || '',
fieldLabel: 'ID',
vtype: 'StorageId',
- allowBlank: false
+ allowBlank: false,
},
- nodefield
+ nodefield,
];
me.column2 = [
xtype: 'proxmoxcheckbox',
name: 'restricted',
uncheckedValue: 0,
- fieldLabel: 'restricted'
+ fieldLabel: 'restricted',
},
{
xtype: 'proxmoxcheckbox',
name: 'nofailback',
uncheckedValue: 0,
- fieldLabel: 'nofailback'
- }
+ fieldLabel: 'nofailback',
+ },
];
me.columnB = [
{
xtype: 'textfield',
name: 'comment',
- fieldLabel: gettext('Comment')
+ fieldLabel: gettext('Comment'),
},
- nodegrid
+ nodegrid,
];
me.callParent();
- }
+ },
});
Ext.define('PVE.ha.GroupEdit', {
var ipanel = Ext.create('PVE.ha.GroupInputPanel', {
isCreate: me.isCreate,
- groupId: me.groupId
+ groupId: me.groupId,
});
Ext.apply(me, {
subject: gettext('HA Group'),
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
var values = response.result.data;
ipanel.setValues(values);
- }
+ },
});
}
- }
+ },
});
header: gettext('Group'),
width: 100,
sortable: true,
- dataIndex: 'group'
+ dataIndex: 'group',
},
{
header: gettext('Nodes'),
width: 100,
sortable: false,
- dataIndex: 'nodes'
+ dataIndex: 'nodes',
},
{
header: gettext('Comment'),
flex: 1,
dataIndex: 'comment',
- renderer: Ext.String.htmlEncode
- }
- ]
+ renderer: Ext.String.htmlEncode,
+ },
+ ],
},
store: {
model: 'pve-ha-groups',
sorters: {
property: 'group',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
},
initComponent: function() {
var me = this;
me.callParent();
me.getStore().load();
- }
+ },
}, function() {
'group', 'type', 'digest', 'nodes', 'comment',
{
name : 'restricted',
- type: 'boolean'
+ type: 'boolean',
},
{
name : 'nofailback',
- type: 'boolean'
- }
+ type: 'boolean',
+ },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/ha/groups"
+ url: "/api2/json/cluster/ha/groups",
},
- idProperty: 'group'
+ idProperty: 'group',
});
});
model: 'pve-ha-groups',
sorters: {
property: 'group',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var reload = function() {
var run_editor = function() {
var rec = sm.getSelection()[0];
- var win = Ext.create('PVE.ha.GroupEdit',{
- groupId: rec.data.group
+ var win = Ext.create('PVE.ha.GroupEdit', {
+ groupId: rec.data.group,
});
win.on('destroy', reload);
win.show();
baseurl: '/cluster/ha/groups/',
callback: function() {
reload();
- }
+ },
});
var edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
Ext.apply(me, {
store: store,
selModel: sm,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
tbar: [
{
text: gettext('Create'),
disabled: !caps.nodes['Sys.Console'],
handler: function() {
- var win = Ext.create('PVE.ha.GroupEdit',{});
+ var win = Ext.create('PVE.ha.GroupEdit', {});
win.on('destroy', reload);
win.show();
- }
+ },
},
- edit_btn, remove_btn
+ edit_btn, remove_btn,
],
columns: [
{
header: gettext('Group'),
width: 150,
sortable: true,
- dataIndex: 'group'
+ dataIndex: 'group',
},
{
header: 'restricted',
width: 100,
sortable: true,
renderer: Proxmox.Utils.format_boolean,
- dataIndex: 'restricted'
+ dataIndex: 'restricted',
},
{
header: 'nofailback',
width: 100,
sortable: true,
renderer: Proxmox.Utils.format_boolean,
- dataIndex: 'nofailback'
+ dataIndex: 'nofailback',
},
{
header: gettext('Nodes'),
flex: 1,
sortable: false,
- dataIndex: 'nodes'
+ dataIndex: 'nodes',
},
{
header: gettext('Comment'),
flex: 1,
renderer: Ext.String.htmlEncode,
- dataIndex: 'comment'
- }
+ dataIndex: 'comment',
+ },
],
listeners: {
activate: reload,
return false;
}
},
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
- }
+ },
});
userCls: 'pmx-hint',
value: 'Disabling the resource will stop the guest system. ' +
'See the online help for details.',
- hidden: true
+ hidden: true,
});
var fewVotesHint = Ext.createWidget({
xtype: 'displayfield',
userCls: 'pmx-hint',
value: 'At least three quorum votes are recommended for reliable HA.',
- hidden: true
+ hidden: true,
});
Proxmox.Utils.API2Request({
if (votes < MIN_QUORUM_VOTES) {
fewVotesHint.setVisible(true);
}
- }
+ },
});
var vmidStore = (me.vmid) ? {} : {
filters: [
{
property: 'type',
- value: /lxc|qemu/
+ value: /lxc|qemu/,
},
{
property: 'hastate',
- value: /unmanaged/
- }
- ]
+ value: /unmanaged/,
+ },
+ ],
};
// value is a string above, but a number below
fieldLabel: (me.vmid && me.guestType === 'ct') ? 'CT' : 'VM',
value: me.vmid,
store: vmidStore,
- validateExists: true
+ validateExists: true,
},
{
xtype: 'proxmoxintegerfield',
value: 1,
minValue: 0,
maxValue: 10,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
value: 1,
minValue: 0,
maxValue: 10,
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
me.column2 = [
{
xtype: 'pveHAGroupSelector',
name: 'group',
- fieldLabel: gettext('Group')
+ fieldLabel: gettext('Group'),
},
{
xtype: 'proxmoxKVComboBox',
['started', 'started'],
['stopped', 'stopped'],
['ignored', 'ignored'],
- ['disabled', 'disabled']
+ ['disabled', 'disabled'],
],
listeners: {
'change': function(field, newValue) {
disabledHint.setVisible(false);
}
}
- }
- }
+ },
+ },
},
- disabledHint
+ disabledHint,
];
me.columnB = [
{
xtype: 'textfield',
name: 'comment',
- fieldLabel: gettext('Comment')
+ fieldLabel: gettext('Comment'),
},
- fewVotesHint
+ fewVotesHint,
];
me.callParent();
- }
+ },
});
Ext.define('PVE.ha.VMResourceEdit', {
var ipanel = Ext.create('PVE.ha.VMResourceInputPanel', {
isCreate: me.isCreate,
vmid: me.vmid,
- guestType: me.guestType
+ guestType: me.guestType,
});
Ext.apply(me, {
subject: gettext('Resource') + ': ' + gettext('Container') +
'/' + gettext('Virtual Machine'),
isAdd: true,
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
values.vmid = res[2];
ipanel.setValues(values);
- }
+ },
});
}
- }
+ },
});
rstore: me.rstore,
filters: {
property: 'type',
- value: 'service'
- }
+ value: 'service',
+ },
});
var reload = function() {
metaData.tdCls = 'proxmox-invalid-row';
var html = '<p>' + Ext.htmlEncode(msg) + '</p>';
metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' +
- html.replace(/\"/g,'"') + '"';
+ html.replace(/\"/g, '"') + '"';
}
}
return value;
var guestType = res[1];
var vmid = res[2];
- var win = Ext.create('PVE.ha.VMResourceEdit',{
+ var win = Ext.create('PVE.ha.VMResourceEdit', {
guestType: guestType,
- vmid: vmid
+ vmid: vmid,
});
win.on('destroy', reload);
win.show();
},
callback: function() {
reload();
- }
+ },
});
var edit_btn = new Proxmox.button.Button({
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
Ext.apply(me, {
store: store,
selModel: sm,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
tbar: [
{
text: gettext('Add'),
disabled: !caps.nodes['Sys.Console'],
handler: function() {
- var win = Ext.create('PVE.ha.VMResourceEdit',{});
+ var win = Ext.create('PVE.ha.VMResourceEdit', {});
win.on('destroy', reload);
win.show();
- }
+ },
},
- edit_btn, remove_btn
+ edit_btn, remove_btn,
],
columns: [
header: 'ID',
width: 100,
sortable: true,
- dataIndex: 'sid'
+ dataIndex: 'sid',
},
{
header: gettext('State'),
width: 100,
sortable: true,
- dataIndex: 'state'
+ dataIndex: 'state',
},
{
header: gettext('Node'),
width: 100,
sortable: true,
- dataIndex: 'node'
+ dataIndex: 'node',
},
{
header: gettext('Request State'),
renderer: function(v) {
return v || 'started';
},
- dataIndex: 'request_state'
+ dataIndex: 'request_state',
},
{
header: gettext('CRM State'),
width: 100,
hidden: true,
sortable: true,
- dataIndex: 'crm_state'
+ dataIndex: 'crm_state',
},
{
header: gettext('Name'),
width: 100,
sortable: true,
renderer: (v) => v === undefined ? '1' : v,
- dataIndex: 'max_restart'
+ dataIndex: 'max_restart',
},
{
header: gettext('Max. Relocate'),
width: 100,
sortable: true,
renderer: (v) => v === undefined ? '1' : v,
- dataIndex: 'max_relocate'
+ dataIndex: 'max_relocate',
},
{
header: gettext('Group'),
renderer: function(value, metaData, record) {
return render_error('group', value, metaData, record);
},
- dataIndex: 'group'
+ dataIndex: 'group',
},
{
header: gettext('Description'),
flex: 1,
renderer: Ext.String.htmlEncode,
- dataIndex: 'comment'
- }
+ dataIndex: 'comment',
+ },
],
listeners: {
beforeselect: function(grid, record, index, eOpts) {
return false;
}
},
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
- }
+ },
});
onlineHelp: 'chapter_ha_manager',
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
initComponent: function() {
groupField: 'type',
proxy: {
type: 'proxmox',
- url: '/api2/json/cluster/ha/status/current'
- }
+ url: '/api2/json/cluster/ha/status/current',
+ },
});
me.items = [{
rstore: me.rstore,
border: 0,
collapsible: true,
- padding: '0 0 20 0'
- },{
+ padding: '0 0 20 0',
+ }, {
xtype: 'pveHAResourcesView',
flex: 1,
collapsible: true,
title: gettext('Resources'),
border: 0,
- rstore: me.rstore
+ rstore: me.rstore,
}];
me.callParent();
me.on('activate', me.rstore.startUpdate);
- }
+ },
});
quorum: 1,
master: 2,
lrm: 3,
- service: 4
+ service: 4,
},
initComponent : function() {
var p1 = me.sortPriority[rec1.data.type];
var p2 = me.sortPriority[rec2.data.type];
return (p1 !== p2) ? ((p1 > p2) ? 1 : -1) : 0;
- }
+ },
}],
filters: {
property: 'type',
value: 'service',
- operator: '!='
- }
+ operator: '!=',
+ },
});
Ext.apply(me, {
store: store,
stateful: false,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
header: gettext('Type'),
width: 80,
- dataIndex: 'type'
+ dataIndex: 'type',
},
{
header: gettext('Status'),
width: 80,
flex: 1,
- dataIndex: 'status'
- }
- ]
+ dataIndex: 'status',
+ },
+ ],
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
- }
+ },
}, function() {
Ext.define('pve-ha-status', {
},
},
],
- idProperty: 'id'
+ idProperty: 'id',
});
});
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
};
disabled: running,
handler: function() {
vm_command('start');
- }
+ },
},
// {
// text: gettext('Suspend'),
vm_command('shutdown');
});
- }
+ },
},
{
text: gettext('Stop'),
vm_command("stop");
});
- }
+ },
},
{
text: gettext('Reboot'),
vm_command("reboot");
});
- }
+ },
},
{
xtype: 'menuseparator',
- hidden: (standalone || !caps.vms['VM.Migrate']) && !caps.vms['VM.Allocate'] && !caps.vms['VM.Clone']
+ hidden: (standalone || !caps.vms['VM.Migrate']) && !caps.vms['VM.Allocate'] && !caps.vms['VM.Clone'],
},
{
text: gettext('Clone'),
hidden: !caps.vms['VM.Clone'],
handler: function() {
PVE.window.Clone.wrap(nodename, vmid, me.isTemplate, 'lxc');
- }
+ },
},
{
text: gettext('Migrate'),
var win = Ext.create('PVE.window.Migrate', {
vmtype: 'lxc',
nodename: nodename,
- vmid: vmid
+ vmid: vmid,
});
win.show();
- }
+ },
},
{
text: gettext('Convert to template'),
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
- }
+ },
});
});
- }
+ },
},
{ xtype: 'menuseparator' },
{
iconCls: 'fa fa-fw fa-terminal',
handler: function() {
PVE.Utils.openDefaultConsoleWindow(true, 'lxc', vmid, nodename, vmname);
- }
- }
+ },
+ },
];
me.callParent();
- }
+ },
});
me.statusStore = Ext.create('Proxmox.data.ObjectStore', {
url: '/api2/json' + base_url + '/status/current',
- interval: 1000
+ interval: 1000,
});
var vm_command = function(cmd, params) {
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
- }
+ },
});
};
handler: function() {
vm_command('start');
},
- iconCls: 'fa fa-play'
+ iconCls: 'fa fa-play',
});
var shutdownBtn = Ext.create('PVE.button.Split', {
handler: function() {
vm_command("reboot");
},
- iconCls: 'fa fa-refresh'
+ iconCls: 'fa fa-refresh',
},
{
text: gettext('Stop'),
handler: function() {
vm_command("stop");
},
- iconCls: 'fa fa-stop'
- }]
+ iconCls: 'fa fa-stop',
+ }],
},
- iconCls: 'fa fa-power-off'
+ iconCls: 'fa fa-power-off',
});
var migrateBtn = Ext.create('Ext.Button', {
var win = Ext.create('PVE.window.Migrate', {
vmtype: 'lxc',
nodename: nodename,
- vmid: vmid
+ vmid: vmid,
});
win.show();
},
- iconCls: 'fa fa-send-o'
+ iconCls: 'fa fa-send-o',
});
var moreBtn = Ext.create('Proxmox.button.Button', {
hidden: caps.vms['VM.Clone'] ? false : true,
handler: function() {
PVE.window.Clone.wrap(nodename, vmid, template, 'lxc');
- }
+ },
},
{
text: gettext('Convert to template'),
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
- }
+ },
});
- }
+ },
},
{
iconCls: 'fa fa-heartbeat ',
Ext.create('PVE.ha.VMResourceEdit', {
vmid: vmid,
guestType: 'ct',
- isCreate: (!ha || ha === 'unmanaged')
+ isCreate: (!ha || ha === 'unmanaged'),
}).show();
- }
+ },
},
{
text: gettext('Remove'),
handler: function() {
Ext.create('PVE.window.SafeDestroy', {
url: base_url,
- item: { type: 'CT', id: vmid }
+ item: { type: 'CT', id: vmid },
}).show();
},
- iconCls: 'fa fa-trash-o'
- }
- ]}
+ iconCls: 'fa fa-trash-o',
+ },
+ ]},
});
var consoleBtn = Ext.create('PVE.button.ConsoleButton', {
consoleName: vm.name,
hidden: template,
nodename: nodename,
- vmid: vmid
+ vmid: vmid,
});
var statusTxt = Ext.create('Ext.toolbar.TextItem', {
data: {
- lock: undefined
+ lock: undefined,
},
tpl: [
'<tpl if="lock">',
'<i class="fa fa-lg fa-lock"></i> ({lock})',
- '</tpl>'
- ]
+ '</tpl>',
+ ],
});
title: gettext('Summary'),
xtype: 'pveGuestSummary',
iconCls: 'fa fa-book',
- itemId: 'summary'
- }
- ]
+ itemId: 'summary',
+ },
+ ],
});
if (caps.vms['VM.Console'] && !template) {
vmid: vmid,
consoleType: 'lxc',
xtermjs: true,
- nodename: nodename
- }
+ nodename: nodename,
+ },
);
}
itemId: 'resources',
expandedOnInit: true,
iconCls: 'fa fa-cube',
- xtype: 'pveLxcRessourceView'
+ xtype: 'pveLxcRessourceView',
},
{
title: gettext('Network'),
iconCls: 'fa fa-exchange',
itemId: 'network',
- xtype: 'pveLxcNetworkView'
+ xtype: 'pveLxcNetworkView',
},
{
title: gettext('DNS'),
iconCls: 'fa fa-globe',
itemId: 'dns',
- xtype: 'pveLxcDNS'
+ xtype: 'pveLxcDNS',
},
{
title: gettext('Options'),
itemId: 'options',
iconCls: 'fa fa-gear',
- xtype: 'pveLxcOptions'
+ xtype: 'pveLxcOptions',
},
{
title: gettext('Task History'),
iconCls: 'fa fa-list',
xtype: 'proxmoxNodeTasks',
nodename: nodename,
- vmidFilter: vmid
- }
+ vmidFilter: vmid,
+ },
);
if (caps.vms['VM.Backup']) {
title: gettext('Backup'),
iconCls: 'fa fa-floppy-o',
xtype: 'pveBackupView',
- itemId: 'backup'
+ itemId: 'backup',
},
{
title: gettext('Replication'),
iconCls: 'fa fa-retweet',
xtype: 'pveReplicaView',
- itemId: 'replication'
+ itemId: 'replication',
});
}
iconCls: 'fa fa-history',
xtype: 'pveGuestSnapshotTree',
type: 'lxc',
- itemId: 'snapshot'
+ itemId: 'snapshot',
});
}
allow_iface: true,
base_url: base_url + '/firewall/rules',
list_refs_url: base_url + '/firewall/refs',
- itemId: 'firewall'
+ itemId: 'firewall',
},
{
xtype: 'pveFirewallOptions',
title: gettext('Options'),
base_url: base_url + '/firewall/options',
fwtype: 'vm',
- itemId: 'firewall-options'
+ itemId: 'firewall-options',
},
{
xtype: 'pveFirewallAliases',
groups: ['firewall'],
iconCls: 'fa fa-external-link',
base_url: base_url + '/firewall/aliases',
- itemId: 'firewall-aliases'
+ itemId: 'firewall-aliases',
},
{
xtype: 'pveIPSet',
iconCls: 'fa fa-list-ol',
base_url: base_url + '/firewall/ipset',
list_refs_url: base_url + '/firewall/refs',
- itemId: 'firewall-ipset'
+ itemId: 'firewall-ipset',
},
{
title: gettext('Log'),
onlineHelp: 'chapter_pve_firewall',
itemId: 'firewall-fwlog',
xtype: 'proxmoxLogView',
- url: '/api2/extjs' + base_url + '/firewall/log'
- }
+ url: '/api2/extjs' + base_url + '/firewall/log',
+ },
);
}
title: gettext('Permissions'),
itemId: 'permissions',
iconCls: 'fa fa-unlock',
- path: '/vms/' + vmid
+ path: '/vms/' + vmid,
});
}
me.on('destroy', function() {
me.statusStore.stopUpdate();
});
- }
+ },
});
data: {
nodename: '',
storage: '',
- unprivileged: true
- }
+ unprivileged: true,
+ },
},
cbindData: {
- nodename: undefined
+ nodename: undefined,
},
subject: gettext('LXC Container'),
name: 'nodename',
cbind: {
selectCurNode: '{!nodename}',
- preferredValue: '{nodename}'
+ preferredValue: '{nodename}',
},
bind: {
- value: '{nodename}'
+ value: '{nodename}',
},
fieldLabel: gettext('Node'),
allowBlank: false,
- onlineValidator: true
+ onlineValidator: true,
},
{
xtype: 'pveGuestIDSelector',
guestType: 'lxc',
value: '',
loadNextFreeID: true,
- validateExists: false
+ validateExists: false,
},
{
xtype: 'proxmoxtextfield',
value: '',
fieldLabel: gettext('Hostname'),
skipEmptyText: true,
- allowBlank: true
+ allowBlank: true,
},
{
xtype: 'proxmoxcheckbox',
name: 'unprivileged',
value: true,
bind: {
- value: '{unprivileged}'
+ value: '{unprivileged}',
},
- fieldLabel: gettext('Unprivileged container')
- }
+ fieldLabel: gettext('Unprivileged container'),
+ },
],
column2: [
{
fieldLabel: gettext('Resource Pool'),
name: 'pool',
value: '',
- allowBlank: true
+ allowBlank: true,
},
{
xtype: 'textfield',
if (f.rendered) {
f.up().down('field[name=confirmpw]').validate();
}
- }
+ },
},
{
xtype: 'textfield',
return "Passwords do not match!";
}
return true;
- }
+ },
},
{
xtype: 'proxmoxtextfield',
let files = ev.dataTransfer.files;
PVE.Utils.loadSSHKeyFromFile(files[0], v => field.setValue(v));
});
- }
+ },
},
{
xtype: 'filebutton',
field.setValue(v);
});
btn.reset();
- }
- }
- }
- ]
+ },
+ },
+ },
+ ],
},
{
xtype: 'inputpanel',
allowBlank: false,
bind: {
value: '{storage}',
- nodename: '{nodename}'
- }
+ nodename: '{nodename}',
+ },
},
{
xtype: 'pveFileSelector',
fieldLabel: gettext('Template'),
bind: {
storage: '{storage}',
- nodename: '{nodename}'
+ nodename: '{nodename}',
},
- allowBlank: false
- }
- ]
+ allowBlank: false,
+ },
+ ],
},
{
xtype: 'pveLxcMountPointInputPanel',
unused: false,
bind: {
nodename: '{nodename}',
- unprivileged: '{unprivileged}'
+ unprivileged: '{unprivileged}',
},
- confid: 'rootfs'
+ confid: 'rootfs',
},
{
xtype: 'pveLxcCPUInputPanel',
title: gettext('CPU'),
- insideWizard: true
+ insideWizard: true,
},
{
xtype: 'pveLxcMemoryInputPanel',
title: gettext('Memory'),
- insideWizard: true
+ insideWizard: true,
},
{
xtype: 'pveLxcNetworkInputPanel',
title: gettext('Network'),
insideWizard: true,
bind: {
- nodename: '{nodename}'
+ nodename: '{nodename}',
},
- isCreate: true
+ isCreate: true,
},
{
xtype: 'pveLxcDNSInputPanel',
title: gettext('DNS'),
- insideWizard: true
+ insideWizard: true,
},
{
title: gettext('Confirm'),
model: 'KeyValue',
sorters: [{
property : 'key',
- direction: 'ASC'
- }]
+ direction: 'ASC',
+ }],
},
columns: [
{header: 'Key', width: 150, dataIndex: 'key'},
- {header: 'Value', flex: 1, dataIndex: 'value'}
- ]
- }
+ {header: 'Value', flex: 1, dataIndex: 'value'},
+ ],
+ },
],
dockedItems: [
{
name: 'start',
dock: 'bottom',
margin: '5 0 0 0',
- boxLabel: gettext('Start after created')
- }
+ boxLabel: gettext('Start after created'),
+ },
],
listeners: {
show: function(panel) {
summarystore.sort();
summarystore.resumeEvents();
summarystore.fireEvent('refresh');
- }
+ },
},
onSubmit: function() {
var wizard = this.up('window');
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskViewer', {
- upid: upid
+ upid: upid,
});
win.show();
wizard.close();
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
- }
- ]
+ },
+ },
+ ],
});
skipEmptyText: true,
fieldLabel: gettext('DNS domain'),
emptyText: gettext('use host settings'),
- allowBlank: true
+ allowBlank: true,
},
{
xtype: 'proxmoxtextfield',
allowBlank: true,
emptyText: gettext('use host settings'),
name: 'nameserver',
- itemId: 'nameserver'
- }
+ itemId: 'nameserver',
+ },
];
if (me.insideWizard) {
}
me.callParent();
- }
+ },
});
Ext.define('PVE.lxc.DNSEdit', {
Ext.apply(me, {
subject: gettext('Resources'),
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
}
ipanel.setValues(values);
- }
+ },
});
}
- }
+ },
});
Ext.define('PVE.lxc.DNS', {
name: 'hostname',
vtype: 'DnsName',
allowBlank: true,
- emptyText: 'CT' + vmid.toString()
+ emptyText: 'CT' + vmid.toString(),
},
onGetValues: function(values) {
var params = values;
params = { hostname: 'CT'+vmid.toString()};
}
return params;
- }
- }
- } : undefined
+ },
+ },
+ } : undefined,
},
searchdomain: {
header: gettext('DNS domain'),
editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
renderer: function(value) {
return value || gettext('use host settings');
- }
+ },
},
nameserver: {
header: gettext('DNS server'),
editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
renderer: function(value) {
return value || gettext('use host settings');
- }
- }
+ },
+ },
};
var baseurl = 'nodes/' + nodename + '/lxc/' + vmid + '/config';
win = Ext.create(rowdef.editor, {
pveSelNode: me.pveSelNode,
confid: rec.data.key,
- url: '/api2/extjs/nodes/' + nodename + '/lxc/' + vmid + '/config'
+ url: '/api2/extjs/nodes/' + nodename + '/lxc/' + vmid + '/config',
});
} else {
var config = Ext.apply({
pveSelNode: me.pveSelNode,
confid: rec.data.key,
- url: '/api2/extjs/nodes/' + nodename + '/lxc/' + vmid + '/config'
+ url: '/api2/extjs/nodes/' + nodename + '/lxc/' + vmid + '/config',
}, rowdef.editor);
win = Ext.createWidget(rowdef.editor.xtype, config);
win.load();
var rowdef = rows[rec.data.key];
return !!rowdef.editor;
},
- handler: run_editor
+ handler: run_editor,
});
var revert_btn = new PVE.button.PendingRevert();
tbar: [ edit_btn, revert_btn ],
rows: rows,
editorConfig: {
- url: "/api2/extjs/" + baseurl
+ url: "/api2/extjs/" + baseurl,
},
listeners: {
itemdblclick: run_editor,
selectionchange: set_button_status,
- activate: reload
- }
+ activate: reload,
+ },
});
me.callParent();
me.mon(me.getStore(), 'datachanged', function() {
set_button_status();
});
- }
+ },
});
viewModel: {
parent: null,
data: {
- unprivileged: false
+ unprivileged: false,
},
formulas: {
privilegedOnly: function(get) {
},
unprivilegedOnly: function(get) {
return (!get('unprivileged') ? gettext('unprivileged only') : '');
- }
- }
+ },
+ },
},
items: [
name: 'keyctl',
bind: {
disabled: '{!unprivileged}',
- boxLabel: '{unprivilegedOnly}'
- }
+ boxLabel: '{unprivilegedOnly}',
+ },
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Nesting'),
- name: 'nesting'
+ name: 'nesting',
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: 'NFS',
bind: {
disabled: '{unprivileged}',
- boxLabel: '{privilegedOnly}'
- }
+ boxLabel: '{privilegedOnly}',
+ },
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: 'CIFS',
bind: {
disabled: '{unprivileged}',
- boxLabel: '{privilegedOnly}'
- }
+ boxLabel: '{privilegedOnly}',
+ },
},
{
xtype: 'proxmoxcheckbox',
name: 'fuse',
- fieldLabel: 'FUSE'
+ fieldLabel: 'FUSE',
},
{
xtype: 'proxmoxcheckbox',
width: 350,
items: [{
- xtype: 'pveLxcFeaturesInputPanel'
+ xtype: 'pveLxcFeaturesInputPanel',
}],
});
'field[name=mpid]': {
change: function(field, value) {
field.validate();
- }
+ },
},
'#hdstorage': {
change: function(field, newValue) {
var vm = me.getViewModel();
vm.set('type', rec.data.type);
- }
- }
+ },
+ },
},
init: function(view) {
if (view.isCreate) {
vm.set('isIncludedInBackup', true);
}
- }
+ },
},
viewModel: {
mptype: '',
type: '',
confid: '',
- node: ''
+ node: '',
},
formulas: {
},
isBindOrRoot: function(get) {
return get('isBind') || get('isRoot');
- }
- }
+ },
+ },
},
column1: [
disabled: true,
bind: {
hidden: '{hasMP}',
- disabled: '{hasMP}'
+ disabled: '{hasMP}',
},
validator: function(value) {
var me = this.up('inputpanel');
}
/* returns a string above */
return true;
- }
+ },
},
{
xtype: 'pveDiskStorageSelector',
bind: {
hidden: '{hideStorSelector}',
disabled: '{hideStorSelector}',
- nodename: '{node}'
- }
+ nodename: '{node}',
+ },
},
{
xtype: 'textfield',
fieldLabel: gettext('Disk image'),
name: 'file',
bind: {
- hidden: '{!hideStorSelector}'
- }
- }
+ hidden: '{!hideStorSelector}',
+ },
+ },
],
column2: [
fieldLabel: gettext('Path'),
bind: {
hidden: '{isRoot}',
- disabled: '{isRoot}'
- }
+ disabled: '{isRoot}',
+ },
},
{
xtype: 'proxmoxcheckbox',
bind: {
hidden: '{isRoot}',
disabled: '{isBindOrRoot}',
- value: '{isIncludedInBackup}'
- }
- }
+ value: '{isIncludedInBackup}',
+ },
+ },
],
advancedColumn1: [
name: 'quota',
defaultValue: 0,
bind: {
- disabled: '{!quota}'
+ disabled: '{!quota}',
},
fieldLabel: gettext('Enable quota'),
listeners: {
disable: function() {
this.reset();
- }
- }
+ },
+ },
},
{
xtype: 'proxmoxcheckbox',
defaultValue: 0,
bind: {
hidden: '{isRoot}',
- disabled: '{isRoot}'
+ disabled: '{isRoot}',
},
- fieldLabel: gettext('Read-only')
+ fieldLabel: gettext('Read-only'),
},
{
xtype: 'proxmoxKVComboBox',
['noatime', 'noatime'],
['nodev', 'nodev'],
['noexec', 'noexec'],
- ['nosuid', 'nosuid']
+ ['nosuid', 'nosuid'],
],
multiSelect: true,
value: [],
- allowBlank: true
+ allowBlank: true,
},
],
comboItems: [
['__default__', Proxmox.Utils.defaultText],
['1', Proxmox.Utils.enabledText],
- ['0', Proxmox.Utils.disabledText]
+ ['0', Proxmox.Utils.disabledText],
],
value: '__default__',
bind: {
- disabled: '{isBind}'
+ disabled: '{isBind}',
},
- allowBlank: true
+ allowBlank: true,
},
{
xtype: 'proxmoxcheckbox',
inputValue: '0', // reverses the logic
name: 'replicate',
- fieldLabel: gettext('Skip replication')
- }
- ]
+ fieldLabel: gettext('Skip replication'),
+ },
+ ],
});
Ext.define('PVE.lxc.MountPointEdit', {
nodename: nodename,
unused: unused,
unprivileged: me.unprivileged,
- isCreate: me.isCreate
+ isCreate: me.isCreate,
});
var subject;
Ext.apply(me, {
subject: subject,
defaultFocus: me.confid !== 'rootfs' ? 'textfield[name=mp]' : 'tool',
- items: ipanel
+ items: ipanel,
});
me.callParent();
ipanel.setMountPoint(mp);
me.isValid(); // trigger validation
}
- }
+ },
});
- }
+ },
});
var win = Ext.create('Proxmox.window.TaskViewer', { upid: upid });
win.show();
me.close();
- }
+ },
});
},
value: me.disk,
fieldLabel: gettext('Disk'),
vtype: 'StorageId',
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
me.hdsizesel = Ext.createWidget('numberfield', {
decimalPrecision: 3,
value: '0',
fieldLabel: gettext('Size Increment') + ' (GiB)',
- allowBlank: false
+ allowBlank: false,
});
items.push(me.hdsizesel);
border: false,
fieldDefaults: {
labelWidth: 120,
- anchor: '100%'
+ anchor: '100%',
},
- items: items
+ items: items,
});
var form = me.formPanel.getForm();
var values = form.getValues();
me.resize_disk(me.disk, values.size);
}
- }
+ },
});
Ext.apply(me, {
border: false,
layout: 'fit',
buttons: [ submitBtn ],
- items: [ me.formPanel ]
+ items: [ me.formPanel ],
});
return;
}
- }
+ },
});
var idselector = {
xtype: 'hidden',
name: 'id',
- value: me.ifname
+ value: me.ifname,
};
me.column1 = [
}
// validator can return bool/string
return true;
- }
+ },
},
{
xtype: 'textfield',
vtype: 'MacAddress',
value: cdata.hwaddr,
allowBlank: true,
- emptyText: 'auto'
+ emptyText: 'auto',
},
{
xtype: 'PVE.form.BridgeSelector',
nodename: me.nodename,
fieldLabel: gettext('Bridge'),
value: cdata.bridge,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'pveVlanField',
name: 'tag',
- value: cdata.tag
+ value: cdata.tag,
},
{
xtype: 'numberfield',
maxValue: 10*1024,
value: cdata.rate,
emptyText: 'unlimited',
- allowBlank: true
+ allowBlank: true,
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Firewall'),
name: 'firewall',
- value: cdata.firewall
- }
+ value: cdata.firewall,
+ },
];
var dhcp4 = (cdata.ip === 'dhcp');
{
layout: {
type: 'hbox',
- align: 'middle'
+ align: 'middle',
},
border: false,
margin: '0 0 5 0',
items: [
{
xtype: 'label',
- text: 'IPv4:' // do not localize
+ text: 'IPv4:', // do not localize
},
{
xtype: 'radiofield',
listeners: {
change: function(cb, value) {
me.down('field[name=ip]').setEmptyText(
- !!value ? Proxmox.Utils.NoneText : ""
+ !!value ? Proxmox.Utils.NoneText : "",
);
me.down('field[name=ip]').setDisabled(!value);
me.down('field[name=gw]').setDisabled(!value);
- }
- }
+ },
+ },
},
{
xtype: 'radiofield',
name: 'ipv4mode',
inputValue: 'dhcp',
checked: dhcp4,
- margin: '0 0 0 10'
- }
- ]
+ margin: '0 0 0 10',
+ },
+ ],
},
{
xtype: 'textfield',
value: cdata.ip,
emptyText: dhcp4 ? '' : Proxmox.Utils.NoneText,
disabled: dhcp4,
- fieldLabel: 'IPv4/CIDR' // do not localize
+ fieldLabel: 'IPv4/CIDR', // do not localize
},
{
xtype: 'textfield',
vtype: 'IPAddress',
disabled: dhcp4,
fieldLabel: gettext('Gateway') + ' (IPv4)',
- margin: '0 0 3 0' // override bottom margin to account for the menuseparator
+ margin: '0 0 3 0', // override bottom margin to account for the menuseparator
},
{
xtype: 'menuseparator',
height: '3',
- margin: '0'
+ margin: '0',
},
{
layout: {
type: 'hbox',
- align: 'middle'
+ align: 'middle',
},
border: false,
margin: '0 0 5 0',
items: [
{
xtype: 'label',
- text: 'IPv6:' // do not localize
+ text: 'IPv6:', // do not localize
},
{
xtype: 'radiofield',
listeners: {
change: function(cb, value) {
me.down('field[name=ip6]').setEmptyText(
- !!value ? Proxmox.Utils.NoneText : ""
+ !!value ? Proxmox.Utils.NoneText : "",
);
me.down('field[name=ip6]').setDisabled(!value);
me.down('field[name=gw6]').setDisabled(!value);
- }
- }
+ },
+ },
},
{
xtype: 'radiofield',
name: 'ipv6mode',
inputValue: 'dhcp',
checked: dhcp6,
- margin: '0 0 0 10'
+ margin: '0 0 0 10',
},
{
xtype: 'radiofield',
name: 'ipv6mode',
inputValue: 'auto',
checked: auto6,
- margin: '0 0 0 10'
- }
- ]
+ margin: '0 0 0 10',
+ },
+ ],
},
{
xtype: 'textfield',
emptyText: dhcp6 || auto6 ? '' : Proxmox.Utils.NoneText,
vtype: 'IP6CIDRAddress',
disabled: (dhcp6 || auto6),
- fieldLabel: 'IPv6/CIDR' // do not localize
+ fieldLabel: 'IPv6/CIDR', // do not localize
},
{
xtype: 'textfield',
vtype: 'IP6Address',
value: cdata.gw6,
disabled: (dhcp6 || auto6),
- fieldLabel: gettext('Gateway') + ' (IPv6)'
- }
+ fieldLabel: gettext('Gateway') + ' (IPv6)',
+ },
];
me.callParent();
- }
+ },
});
Ext.define('PVE.lxc.NetworkEdit', {
ifname: me.ifname,
nodename: me.nodename,
dataCache: me.dataCache,
- isCreate: me.isCreate
+ isCreate: me.isCreate,
});
Ext.apply(me, {
subject: gettext('Network Device') + ' (veth)',
digest: me.dataCache.digest,
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
- }
+ },
});
Ext.define('PVE.lxc.NetworkView', {
});
me.store.loadData(records);
me.down('button[name=addButton]').setDisabled((records.length >= 32));
- }
+ },
});
},
sorters: [
{
property : 'id',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
});
var sm = Ext.create('Ext.selection.RowModel', {});
},
failure: function (response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
});
var run_editor = function() {
url: me.url,
nodename: nodename,
dataCache: me.dataCache,
- ifname: rec.data.id
+ ifname: rec.data.id,
});
win.on('destroy', me.load, me);
win.show();
}
return true;
},
- handler: run_editor
+ handler: run_editor,
});
Ext.apply(me, {
url: me.url,
nodename: nodename,
isCreate: true,
- dataCache: me.dataCache
+ dataCache: me.dataCache,
});
win.on('destroy', me.load, me);
win.show();
- }
+ },
},
remove_btn,
- edit_btn
+ edit_btn,
],
columns: [
{
header: 'ID',
width: 50,
- dataIndex: 'id'
+ dataIndex: 'id',
},
{
header: gettext('Name'),
width: 80,
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
header: gettext('Bridge'),
width: 80,
- dataIndex: 'bridge'
+ dataIndex: 'bridge',
},
{
header: gettext('Firewall'),
width: 80,
dataIndex: 'firewall',
- renderer: Proxmox.Utils.format_boolean
+ renderer: Proxmox.Utils.format_boolean,
},
{
header: gettext('VLAN Tag'),
width: 80,
- dataIndex: 'tag'
+ dataIndex: 'tag',
},
{
header: gettext('MAC address'),
width: 110,
- dataIndex: 'hwaddr'
+ dataIndex: 'hwaddr',
},
{
header: gettext('IP address'),
} else {
return rec.data.ip;
}
- }
+ },
},
{
header: gettext('Gateway'),
} else {
return rec.data.gw;
}
- }
- }
+ },
+ },
],
listeners: {
activate: me.load,
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
- }
+ },
}, function() {
Ext.define('pve-lxc-network', {
extend: "Ext.data.Model",
proxy: { type: 'memory' },
fields: [ 'id', 'name', 'hwaddr', 'bridge',
- 'ip', 'gw', 'ip6', 'gw6', 'tag', 'firewall' ]
+ 'ip', 'gw', 'ip6', 'gw6', 'tag', 'firewall' ],
});
});
name: 'onboot',
uncheckedValue: 0,
defaultValue: 0,
- fieldLabel: gettext('Start at boot')
- }
- } : undefined
+ fieldLabel: gettext('Start at boot'),
+ },
+ } : undefined,
},
startup: {
header: gettext('Start/Shutdown order'),
editor: caps.vms['VM.Config.Options'] && caps.nodes['Sys.Modify'] ?
{
xtype: 'pveWindowStartupEdit',
- onlineHelp: 'pct_startup_and_shutdown'
- } : undefined
+ onlineHelp: 'pct_startup_and_shutdown',
+ } : undefined,
},
ostype: {
header: gettext('OS Type'),
- defaultValue: Proxmox.Utils.unknownText
+ defaultValue: Proxmox.Utils.unknownText,
},
arch: {
header: gettext('Architecture'),
- defaultValue: Proxmox.Utils.unknownText
+ defaultValue: Proxmox.Utils.unknownText,
},
console: {
header: '/dev/console',
defaultValue: 1,
deleteDefaultValue: true,
checked: true,
- fieldLabel: '/dev/console'
- }
- } : undefined
+ fieldLabel: '/dev/console',
+ },
+ } : undefined,
},
tty: {
header: gettext('TTY count'),
value: 2,
fieldLabel: gettext('TTY count'),
emptyText: gettext('Default'),
- deleteEmpty: true
- }
- } : undefined
+ deleteEmpty: true,
+ },
+ } : undefined,
},
cmode: {
header: gettext('Console mode'),
['__default__', Proxmox.Utils.defaultText + " (tty)"],
['tty', "/dev/tty[X]"],
['console', "/dev/console"],
- ['shell', "shell"]
+ ['shell', "shell"],
],
- fieldLabel: gettext('Console mode')
- }
- } : undefined
+ fieldLabel: gettext('Console mode'),
+ },
+ } : undefined,
},
protection: {
header: gettext('Protection'),
uncheckedValue: 0,
defaultValue: 0,
deleteDefaultValue: true,
- fieldLabel: gettext('Enabled')
- }
- } : undefined
+ fieldLabel: gettext('Enabled'),
+ },
+ } : undefined,
},
unprivileged: {
header: gettext('Unprivileged container'),
renderer: Proxmox.Utils.format_boolean,
- defaultValue: 0
+ defaultValue: 0,
},
features: {
header: gettext('Features'),
defaultValue: Proxmox.Utils.noneText,
editor: Proxmox.UserName === 'root@pam' ?
- 'PVE.lxc.FeaturesEdit' : undefined
+ 'PVE.lxc.FeaturesEdit' : undefined,
},
hookscript: {
- header: gettext('Hookscript')
- }
+ header: gettext('Hookscript'),
+ },
};
var baseurl = 'nodes/' + nodename + '/lxc/' + vmid + '/config';
var rowdef = rows[rec.data.key];
return !!rowdef.editor;
},
- handler: function() { me.run_editor(); }
+ handler: function() { me.run_editor(); },
});
var revert_btn = new PVE.button.PendingRevert();
tbar: [ edit_btn, revert_btn ],
rows: rows,
editorConfig: {
- url: '/api2/extjs/' + baseurl
+ url: '/api2/extjs/' + baseurl,
},
listeners: {
itemdblclick: me.run_editor,
- selectionchange: set_button_status
- }
+ selectionchange: set_button_status,
+ },
});
me.callParent();
set_button_status();
});
- }
+ },
});
Ext.apply(me, {
subject: gettext('Memory'),
- items: Ext.create('PVE.lxc.MemoryInputPanel')
+ items: Ext.create('PVE.lxc.MemoryInputPanel'),
});
me.callParent();
me.load();
- }
+ },
});
Ext.apply(me, {
subject: gettext('CPU'),
- items: Ext.create('PVE.lxc.CPUInputPanel')
+ items: Ext.create('PVE.lxc.CPUInputPanel'),
});
me.callParent();
me.load();
- }
+ },
});
Ext.define('PVE.lxc.CPUInputPanel', {
step: 1,
fieldLabel: gettext('CPU limit'),
allowBlank: true,
- emptyText: gettext('unlimited')
- }
+ emptyText: gettext('unlimited'),
+ },
],
advancedColumn2: [
minValue: 8,
maxValue: 500000,
labelWidth: labelWidth,
- allowBlank: false
- }
+ allowBlank: false,
+ },
],
initComponent: function() {
fieldLabel: gettext('Cores'),
allowBlank: true,
deleteEmpty: true,
- emptyText: gettext('unlimited')
- }
+ emptyText: gettext('unlimited'),
+ },
];
me.callParent();
- }
+ },
});
Ext.define('PVE.lxc.MemoryInputPanel', {
step: 32,
fieldLabel: gettext('Memory') + ' (MiB)',
labelWidth: labelWidth,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
step: 32,
fieldLabel: gettext('Swap') + ' (MiB)',
labelWidth: labelWidth,
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
if (me.insideWizard) {
}
me.callParent();
- }
+ },
});
group: 1,
renderer: function(value) {
return Proxmox.Utils.format_size(value*1024*1024);
- }
+ },
},
swap: {
header: gettext('Swap'),
group: 2,
renderer: function(value) {
return Proxmox.Utils.format_size(value*1024*1024);
- }
+ },
},
cores: {
header: gettext('Cores'),
res += ' [cpuunits=' + cpuunits + ']';
}
return res;
- }
+ },
},
rootfs: {
header: gettext('Root Disk'),
defaultValue: Proxmox.Utils.noneText,
editor: mpeditor,
tdCls: 'pve-itype-icon-storage',
- group: 4
+ group: 4,
},
cpulimit: {
- visible: false
+ visible: false,
},
cpuunits: {
- visible: false
+ visible: false,
},
unprivileged: {
- visible: false
- }
+ visible: false,
+ },
};
PVE.Utils.forEachMP(function(bus, i) {
order: i,
tdCls: 'pve-itype-icon-storage',
editor: mpeditor,
- header: header
+ header: header,
};
}, true);
var win = Ext.create('PVE.window.MPResize', {
disk: rec.data.key,
nodename: nodename,
- vmid: vmid
+ vmid: vmid,
});
win.show();
waitMsgTarget: me,
method: 'PUT',
params: {
- 'delete': rec.data.key
+ 'delete': rec.data.key,
},
failure: function (response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
- }
+ },
});
};
disk: rec.data.key,
nodename: nodename,
vmid: vmid,
- type: 'lxc'
+ type: 'lxc',
});
win.show();
var rowdef = rows[rec.data.key];
return !!rowdef.editor;
},
- handler: function() { me.run_editor(); }
+ handler: function() { me.run_editor(); },
});
var resize_btn = new Proxmox.button.Button({
text: gettext('Resize disk'),
selModel: me.selModel,
disabled: true,
- handler: run_resize
+ handler: run_resize,
});
var remove_btn = new Proxmox.button.Button({
return msg;
},
- handler: run_remove
+ handler: run_remove,
});
var move_btn = new Proxmox.button.Button({
selModel: me.selModel,
disabled: true,
dangerous: true,
- handler: run_move
+ handler: run_move,
});
var revert_btn = new PVE.button.PendingRevert();
var win = Ext.create('PVE.lxc.MountPointEdit', {
url: '/api2/extjs/' + baseurl,
unprivileged: me.getObjectValue('unprivileged'),
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
win.on('destroy', me.reload, me);
win.show();
- }
- }
- ]
- })
+ },
+ },
+ ],
+ }),
},
edit_btn,
remove_btn,
resize_btn,
move_btn,
- revert_btn
+ revert_btn,
],
rows: rows,
sorterFn: sorterFn,
editorConfig: {
pveSelNode: me.pveSelNode,
- url: '/api2/extjs/' + baseurl
+ url: '/api2/extjs/' + baseurl,
},
listeners: {
itemdblclick: me.run_editor,
- selectionchange: set_button_status
- }
+ selectionchange: set_button_status,
+ },
});
me.callParent();
});
Ext.apply(me.editorConfig, { unprivileged: me.getObjectValue('unprivileged') });
- }
+ },
});
if (btn === 'yes') {
Ext.callback(fn, me.scope, [me, e], 0, me);
}
- }
+ },
});
} else {
Ext.callback(fn, me.scope, [me, e], 0, me);
}
};
- }
+ },
});
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
};
var win = Ext.create('PVE.window.Migrate', {
vmtype: guestType,
nodename: nodename,
- vmid: vmid
+ vmid: vmid,
});
win.show();
- }
+ },
},
{
text: gettext('Clone'),
nodename: nodename,
guestType: guestType,
vmid: vmid,
- isTemplate: template
+ isTemplate: template,
});
win.show();
- }
- }
+ },
+ },
];
me.callParent();
- }
+ },
});
name: 'contact',
vtype: 'email',
allowBlank: false,
- fieldLabel: gettext('E-Mail')
+ fieldLabel: gettext('E-Mail'),
},
{
xtype: 'proxmoxComboGrid',
idProperty: ['name'],
proxy: {
type: 'proxmox',
- url: '/api2/json/cluster/acme/directories'
+ url: '/api2/json/cluster/acme/directories',
},
sorters: {
property: 'name',
- order: 'ASC'
- }
+ order: 'ASC',
+ },
},
listConfig: {
columns: [
{
header: gettext('Name'),
dataIndex: 'name',
- flex: 1
+ flex: 1,
},
{
header: gettext('URL'),
dataIndex: 'url',
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
},
listeners: {
change: function(combogrid, value) {
url: '/cluster/acme/tos',
method: 'GET',
params: {
- directory: value
+ directory: value,
},
success: function(response, opt) {
field.setValue(response.result.data);
},
failure: function(response, opt) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
- }
+ },
+ },
},
{
xtype: 'displayfield',
itemId: 'tos_url_display',
renderer: PVE.Utils.render_optional_url,
- name: 'tos_url_display'
+ name: 'tos_url_display',
},
{
xtype: 'hidden',
itemId: 'tos_url',
- name: 'tos_url'
+ name: 'tos_url',
},
{
xtype: 'proxmoxcheckbox',
return true;
}
return false;
- }
+ },
},
- ]
+ ],
});
width: 600,
fieldDefaults: {
- labelWidth: 140
+ labelWidth: 140,
},
title: gettext('Account'),
{
xtype: 'displayfield',
fieldLabel: gettext('E-Mail'),
- name: 'email'
+ name: 'email',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Created'),
- name: 'createdAt'
+ name: 'createdAt',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Status'),
- name: 'status'
+ name: 'status',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Directory'),
renderer: PVE.Utils.render_optional_url,
- name: 'directory'
+ name: 'directory',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Terms of Services'),
renderer: PVE.Utils.render_optional_url,
- name: 'tos'
- }
+ name: 'tos',
+ },
],
initComponent: function() {
data.createdAt = data.account.createdAt;
data.status = data.account.status;
me.setValues(data);
- }
+ },
});
- }
+ },
});
Ext.define('PVE.node.ACMEDomainEdit', {
xtype: 'pveCertView',
border: 0,
cbind: {
- nodename: '{nodename}'
- }
+ nodename: '{nodename}',
+ },
},
{
xtype: 'pveACMEView',
border: 0,
cbind: {
- nodename: '{nodename}'
- }
- }
- ]
+ nodename: '{nodename}',
+ },
+ },
+ ],
});
title: gettext('Certificate'),
fieldDefaults: {
- labelWidth: 120
+ labelWidth: 120,
},
width: 800,
resizable: true,
{
xtype: 'displayfield',
fieldLabel: gettext('Name'),
- name: 'filename'
+ name: 'filename',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Fingerprint'),
- name: 'fingerprint'
+ name: 'fingerprint',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Issuer'),
- name: 'issuer'
+ name: 'issuer',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Subject'),
- name: 'subject'
+ name: 'subject',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Public Key Type'),
- name: 'public-key-type'
+ name: 'public-key-type',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Public Key Size'),
- name: 'public-key-bits'
+ name: 'public-key-bits',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Valid Since'),
renderer: Proxmox.Utils.render_timestamp,
- name: 'notbefore'
+ name: 'notbefore',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Expires'),
renderer: Proxmox.Utils.render_timestamp,
- name: 'notafter'
+ name: 'notafter',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Subject Alternative Names'),
name: 'san',
- renderer: PVE.Utils.render_san
+ renderer: PVE.Utils.render_san,
},
{
xtype: 'textarea',
grow: true,
growMax: 200,
fieldLabel: gettext('Certificate'),
- name: 'pem'
- }
+ name: 'pem',
+ },
],
initComponent: function() {
}
});
}
- }
+ },
});
- }
+ },
});
Ext.define('PVE.node.CertUpload', {
labelAlign: 'top',
emptyText: gettext('No change'),
name: 'key',
- xtype: 'textarea'
+ xtype: 'textarea',
},
{
xtype: 'filebutton',
});
});
btn.reset();
- }
- }
+ },
+ },
},
{
xtype: 'box',
- autoEl: 'hr'
+ autoEl: 'hr',
},
{
fieldLabel: gettext('Certificate Chain'),
labelAlign: 'top',
allowBlank: false,
name: 'certificates',
- xtype: 'textarea'
+ xtype: 'textarea',
},
{
xtype: 'filebutton',
});
});
btn.reset();
- }
- }
+ },
+ },
},
{
xtype: 'hidden',
name: 'restart',
- value: '1'
+ value: '1',
},
{
xtype: 'hidden',
name: 'force',
- value: '1'
- }
+ value: '1',
+ },
],
initComponent: function() {
me.url = '/nodes/' + me.nodename + '/certificates/custom';
me.callParent();
- }
+ },
});
Ext.define('pve-certificate', {
extend: 'Ext.data.Model',
fields: [ 'filename', 'fingerprint', 'issuer', 'notafter', 'notbefore', 'subject', 'san', 'public-key-bits', 'public-key-type' ],
- idProperty: 'filename'
+ idProperty: 'filename',
});
Ext.define('PVE.node.Certificates', {
handler: function() {
var me = this.up('grid');
var win = Ext.create('PVE.node.CertUpload', {
- nodename: me.nodename
+ nodename: me.nodename,
});
win.show();
win.on('destroy', me.reload, me);
- }
+ },
},
{
xtype: 'button',
},
failure: function(response, opt) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
},
'-',
{
handler: function() {
var me = this.up('grid');
me.view_certificate();
- }
- }
+ },
+ },
],
columns: [
{
header: gettext('File'),
width: 150,
- dataIndex: 'filename'
+ dataIndex: 'filename',
},
{
header: gettext('Issuer'),
flex: 1,
- dataIndex: 'issuer'
+ dataIndex: 'issuer',
},
{
header: gettext('Subject'),
flex: 1,
- dataIndex: 'subject'
+ dataIndex: 'subject',
},
{
header: gettext('Public Key Alogrithm'),
flex: 1,
dataIndex: 'public-key-type',
- hidden: true
+ hidden: true,
},
{
header: gettext('Public Key Size'),
flex: 1,
dataIndex: 'public-key-bits',
- hidden: true
+ hidden: true,
},
{
header: gettext('Valid Since'),
width: 150,
dataIndex: 'notbefore',
- renderer: Proxmox.Utils.render_timestamp
+ renderer: Proxmox.Utils.render_timestamp,
},
{
header: gettext('Expires'),
width: 150,
dataIndex: 'notafter',
- renderer: Proxmox.Utils.render_timestamp
+ renderer: Proxmox.Utils.render_timestamp,
},
{
header: gettext('Subject Alternative Names'),
flex: 1,
dataIndex: 'san',
- renderer: PVE.Utils.render_san
+ renderer: PVE.Utils.render_san,
},
{
header: gettext('Fingerprint'),
dataIndex: 'fingerprint',
- hidden: true
+ hidden: true,
},
{
header: gettext('PEM'),
dataIndex: 'pem',
- hidden: true
- }
+ hidden: true,
+ },
],
reload: function() {
}
var win = Ext.create('PVE.node.CertificateViewer', {
cert: selection[0].data.filename,
- nodename : me.nodename
+ nodename : me.nodename,
});
win.show();
},
listeners: {
- itemdblclick: 'view_certificate'
+ itemdblclick: 'view_certificate',
},
initComponent: function() {
model: 'pve-certificate',
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/certificates/info'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/certificates/info',
+ },
});
me.store = {
type: 'diff',
- rstore: me.rstore
+ rstore: me.rstore,
};
me.callParent();
me.mon(me.rstore, 'load', me.set_button_status, me);
me.rstore.startUpdate();
me.on('destroy', me.rstore.stopUpdate, me.rstore);
- }
+ },
});
handler: function() {
var me = this.up('menu');
var wiz = Ext.create('PVE.qemu.CreateWizard', {
- nodename: me.nodename
+ nodename: me.nodename,
});
wiz.show();
- }
+ },
},
{
text: gettext('Create CT'),
handler: function() {
var me = this.up('menu');
var wiz = Ext.create('PVE.lxc.CreateWizard', {
- nodename: me.nodename
+ nodename: me.nodename,
});
wiz.show();
- }
+ },
},
{ xtype: 'menuseparator' },
{
nodename: me.nodename,
title: gettext('Bulk Start'),
btnText: gettext('Start'),
- action: 'startall'
+ action: 'startall',
});
win.show();
- }
+ },
},
{
text: gettext('Bulk Stop'),
nodename: me.nodename,
title: gettext('Bulk Stop'),
btnText: gettext('Stop'),
- action: 'stopall'
+ action: 'stopall',
});
win.show();
- }
+ },
},
{
text: gettext('Bulk Migrate'),
nodename: me.nodename,
title: gettext('Bulk Migrate'),
btnText: gettext('Migrate'),
- action: 'migrateall'
+ action: 'migrateall',
});
win.show();
- }
+ },
},
{ xtype: 'menuseparator' },
{
handler: function() {
var me = this.up('menu');
PVE.Utils.openDefaultConsoleWindow(true, 'shell', undefined, me.nodename, undefined);
- }
+ },
},
{ xtype: 'menuseparator' },
{
Ext.Msg.show({
title: 'Success',
icon: Ext.Msg.INFO,
- msg: Ext.String.format(gettext("Wake on LAN packet send for '{0}': '{1}'"), me.nodename, response.result.data)
+ msg: Ext.String.format(gettext("Wake on LAN packet send for '{0}': '{1}'"), me.nodename, response.result.data),
});
- }
+ },
});
- }
- }
+ },
+ },
],
initComponent: function() {
if (me.pveSelNode.data.running) {
me.getComponent('wakeonlan').setDisabled(true);
}
- }
+ },
});
nodename: me.nodename,
diskType: 'unused',
fieldLabel: gettext('Disk'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxKVComboBox',
comboItems: [
['ext4', 'ext4'],
- ['xfs', 'xfs']
+ ['xfs', 'xfs'],
],
fieldLabel: gettext('Filesystem'),
name: 'filesystem',
value: '',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
name: 'name',
fieldLabel: gettext('Name'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'add_storage',
fieldLabel: gettext('Add Storage'),
- value: '1'
- }
- ]
+ value: '1',
+ },
+ ],
});
me.callParent();
- }
+ },
});
Ext.define('PVE.node.Directorylist', {
{
text: gettext('Path'),
dataIndex: 'path',
- flex: 1
+ flex: 1,
},
{
header: gettext('Device'),
flex: 1,
- dataIndex: 'device'
+ dataIndex: 'device',
},
{
header: gettext('Type'),
width: 100,
- dataIndex: 'type'
+ dataIndex: 'type',
},
{
header: gettext('Options'),
width: 100,
- dataIndex: 'options'
+ dataIndex: 'options',
},
{
header: gettext('Unit File'),
hidden: true,
- dataIndex: 'unitfile'
- }
+ dataIndex: 'unitfile',
+ },
],
rootVisible: false,
handler: function() {
var me = this.up('panel');
me.reload();
- }
+ },
},
{
text: gettext('Create') + ': Directory',
handler: function() {
var me = this.up('panel');
var win = Ext.create('PVE.node.CreateDirectory', {
- nodename: me.nodename
+ nodename: me.nodename,
}).show();
win.on('destroy', function() { me.reload(); });
- }
- }
+ },
+ },
],
reload: function() {
activate: function() {
var me = this;
me.reload();
- }
+ },
},
initComponent: function() {
fields: ['path', 'device', 'type', 'options', 'unitfile' ],
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/" + me.nodename + '/disks/directory'
+ url: "/api2/json/nodes/" + me.nodename + '/disks/directory',
},
- sorters: 'path'
- }
+ sorters: 'path',
+ },
});
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.getStore(), true);
me.reload();
- }
+ },
});
nodename: me.nodename,
diskType: 'unused',
fieldLabel: gettext('Disk'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
name: 'name',
fieldLabel: gettext('Name'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'add_storage',
fieldLabel: gettext('Add Storage'),
- value: '1'
- }
- ]
+ value: '1',
+ },
+ ],
});
me.callParent();
- }
+ },
});
Ext.define('PVE.node.LVMList', {
xtype: 'treecolumn',
text: gettext('Name'),
dataIndex: 'name',
- flex: 1
+ flex: 1,
},
{
text: gettext('Number of LVs'),
dataIndex: 'lvcount',
width: 150,
- align: 'right'
+ align: 'right',
},
{
header: gettext('Usage'),
tdCls: 'x-progressbar-default-cell',
xtype: 'widgetcolumn',
widget: {
- xtype: 'pveProgressBar'
- }
+ xtype: 'pveProgressBar',
+ },
},
{
header: gettext('Size'),
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
- dataIndex: 'size'
+ dataIndex: 'size',
},
{
header: gettext('Free'),
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
- dataIndex: 'free'
- }
+ dataIndex: 'free',
+ },
],
rootVisible: false,
handler: function() {
var me = this.up('panel');
me.reload();
- }
+ },
},
{
text: gettext('Create') + ': Volume Group',
nodename: me.nodename,
taskDone: function() {
me.reload();
- }
+ },
}).show();
- }
- }
+ },
+ },
],
reload: function() {
sm.deselectAll();
me.setRootNode(response.result.data);
me.expandAll();
- }
+ },
});
},
activate: function() {
var me = this;
me.reload();
- }
+ },
},
initComponent: function() {
var txt = 'fa x-fa-tree fa-';
txt += (data.leaf) ? 'hdd-o' : 'object-group';
return txt;
- }
+ },
},
{
type: 'number',
name: 'usage',
calculate: function(data) {
return ((data.size-data.free)/data.size);
- }
- }
+ },
+ },
],
- sorters: 'name'
+ sorters: 'name',
});
me.callParent();
me.reload();
- }
+ },
});
nodename: me.nodename,
diskType: 'unused',
fieldLabel: gettext('Disk'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
name: 'name',
fieldLabel: gettext('Name'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'add_storage',
fieldLabel: gettext('Add Storage'),
- value: '1'
- }
- ]
+ value: '1',
+ },
+ ],
});
me.callParent();
- }
+ },
});
Ext.define('PVE.node.LVMThinList', {
{
text: gettext('Name'),
dataIndex: 'lv',
- flex: 1
+ flex: 1,
},
{
header: gettext('Usage'),
tdCls: 'x-progressbar-default-cell',
xtype: 'widgetcolumn',
widget: {
- xtype: 'pveProgressBar'
- }
+ xtype: 'pveProgressBar',
+ },
},
{
header: gettext('Size'),
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
- dataIndex: 'lv_size'
+ dataIndex: 'lv_size',
},
{
header: gettext('Used'),
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
- dataIndex: 'used'
+ dataIndex: 'used',
},
{
header: gettext('Metadata Usage'),
tdCls: 'x-progressbar-default-cell',
xtype: 'widgetcolumn',
widget: {
- xtype: 'pveProgressBar'
- }
+ xtype: 'pveProgressBar',
+ },
},
{
header: gettext('Metadata Size'),
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
- dataIndex: 'metadata_size'
+ dataIndex: 'metadata_size',
},
{
header: gettext('Metadata Used'),
align: 'right',
sortable: true,
renderer: Proxmox.Utils.format_size,
- dataIndex: 'metadata_used'
- }
+ dataIndex: 'metadata_used',
+ },
],
rootVisible: false,
handler: function() {
var me = this.up('panel');
me.reload();
- }
+ },
},
{
text: gettext('Create') + ': Thinpool',
nodename: me.nodename,
taskDone: function() {
me.reload();
- }
+ },
}).show();
- }
- }
+ },
+ },
],
reload: function() {
activate: function() {
var me = this;
me.reload();
- }
+ },
},
initComponent: function() {
name: 'usage',
calculate: function(data) {
return data.used/data.lv_size;
- }
+ },
},
{
type: 'number',
name: 'metadata_usage',
calculate: function(data) {
return data.metadata_used/data.metadata_size;
- }
- }
+ },
+ },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/" + me.nodename + '/disks/lvmthin'
+ url: "/api2/json/nodes/" + me.nodename + '/disks/lvmthin',
},
- sorters: 'lv'
- }
+ sorters: 'lv',
+ },
});
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.getStore(), true);
me.reload();
- }
+ },
});
columns: 2,
tableAttrs: {
style: {
- width: '100%'
- }
- }
+ width: '100%',
+ },
+ },
},
defaults: {
xtype: 'pveInfoWidget',
- padding: '0 15 5 15'
+ padding: '0 15 5 15',
},
items: [
title: gettext('CPU usage'),
valueField: 'cpu',
maxField: 'cpuinfo',
- renderer: PVE.Utils.render_node_cpu_usage
+ renderer: PVE.Utils.render_node_cpu_usage,
},
{
itemId: 'wait',
iconCls: 'fa fa-fw fa-clock-o',
title: gettext('IO delay'),
valueField: 'wait',
- rowspan: 2
+ rowspan: 2,
},
{
itemId: 'load',
iconCls: 'fa fa-fw fa-tasks',
title: gettext('Load average'),
printBar: false,
- textField: 'loadavg'
+ textField: 'loadavg',
},
{
xtype: 'box',
colspan: 2,
- padding: '0 0 20 0'
+ padding: '0 0 20 0',
},
{
iconCls: 'fa fa-fw pve-itype-icon-memory pve-icon',
title: gettext('RAM usage'),
valueField: 'memory',
maxField: 'memory',
- renderer: PVE.Utils.render_node_size_usage
+ renderer: PVE.Utils.render_node_size_usage,
},
{
itemId: 'ksm',
renderer: function(record) {
return PVE.Utils.render_size(record.shared);
},
- padding: '0 15 10 15'
+ padding: '0 15 10 15',
},
{
iconCls: 'fa fa-fw fa-hdd-o',
title: gettext('HD space') + '(root)',
valueField: 'rootfs',
maxField: 'rootfs',
- renderer: PVE.Utils.render_node_size_usage
+ renderer: PVE.Utils.render_node_size_usage,
},
{
iconCls: 'fa fa-fw fa-refresh',
title: gettext('SWAP usage'),
valueField: 'swap',
maxField: 'swap',
- renderer: PVE.Utils.render_node_size_usage
+ renderer: PVE.Utils.render_node_size_usage,
},
{
xtype: 'box',
colspan: 2,
- padding: '0 0 20 0'
+ padding: '0 0 20 0',
},
{
itemId: 'cpus',
gettext('Socket')
) + ")";
},
- value: ''
+ value: '',
},
{
itemId: 'kversion',
title: gettext('Kernel Version'),
printBar: false,
textField: 'kversion',
- value: ''
+ value: '',
},
{
itemId: 'version',
printBar: false,
title: gettext('PVE Manager Version'),
textField: 'pveversion',
- value: ''
- }
+ value: '',
+ },
],
updateTitle: function() {
var me = this;
var uptime = Proxmox.Utils.render_uptime(me.getRecordValue('uptime'));
me.setTitle(me.pveSelNode.data.node + ' (' + gettext('Uptime') + ': ' + uptime + ')');
- }
+ },
});
style: {
'background-color': 'white',
'white-space': 'pre',
- 'font-family': 'monospace'
- }
+ 'font-family': 'monospace',
+ },
});
var win = Ext.create('Ext.window.Window', {
iconCls: 'fa fa-clipboard',
handler: function(button) {
window.getSelection().selectAllChildren(
- document.getElementById('pkgversions')
+ document.getElementById('pkgversions'),
);
document.execCommand("copy");
},
});
view.update(Ext.htmlEncode(text));
- }
+ },
});
},
text: gettext('Package versions'),
handler: function(){
Proxmox.Utils.checked_command(function() { me.showVersions(); });
- }
+ },
});
var rrdstore = Ext.create('Proxmox.data.RRDStore', {
rrdurl: "/api2/json/nodes/" + nodename + "/rrddata",
- model: 'pve-rrd-node'
+ model: 'pve-rrd-node',
});
Ext.apply(me, {
defaults: {
minHeight: 320,
padding: 5,
- columnWidth: 1
+ columnWidth: 1,
},
items: [
{
xtype: 'pveNodeStatus',
rstore: rstore,
width: 770,
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('CPU usage'),
- fields: ['cpu','iowait'],
+ fields: ['cpu', 'iowait'],
fieldTitles: [gettext('CPU usage'), gettext('IO delay')],
- store: rrdstore
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Server load'),
fields: ['loadavg'],
fieldTitles: [gettext('Load average')],
- store: rrdstore
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Memory usage'),
- fields: ['memtotal','memused'],
+ fields: ['memtotal', 'memused'],
fieldTitles: [gettext('Total'), gettext('RAM usage')],
- store: rrdstore
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Network traffic'),
- fields: ['netin','netout'],
- store: rrdstore
- }
+ fields: ['netin', 'netout'],
+ store: rrdstore,
+ },
],
listeners: {
resize: function(panel) {
rstore.setInterval(5000); // don't stop it, it's not ours!
rrdstore.stopUpdate();
},
- }
+ },
});
me.callParent();
}
PVE.Utils.updateColumns(me.getComponent('itemcontainer'));
});
- }
+ },
});
var disks = grid.getSelection();
var val = [];
- disks.sort(function(a,b) {
+ disks.sort(function(a, b) {
var aorder = a.get('order') || 0;
var border = b.get('order') || 0;
return (aorder - border);
xtype: 'textfield',
hidden: true,
name: 'devices',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
name: 'name',
fieldLabel: gettext('Name'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'add_storage',
fieldLabel: gettext('Add Storage'),
- value: '1'
- }
+ value: '1',
+ },
],
column2: [
{
['raid10', 'RAID10'],
['raidz', 'RAIDZ'],
['raidz2', 'RAIDZ2'],
- ['raidz3', 'RAIDZ3']
- ]
+ ['raidz3', 'RAIDZ3'],
+ ],
},
{
xtype: 'proxmoxKVComboBox',
['gzip', 'gzip'],
['lz4', 'lz4'],
['lzjb', 'lzjb'],
- ['zle', 'zle']
- ]
+ ['zle', 'zle'],
+ ],
},
{
xtype: 'proxmoxintegerfield',
minValue: 9,
maxValue: 16,
value: '12',
- name: 'ashift'
- }
+ name: 'ashift',
+ },
],
columnB: [
{
itemId: 'disklist',
selModel: 'checkboxmodel',
listeners: {
- selectionchange: update_disklist
+ selectionchange: update_disklist,
},
store: {
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/disks/list?type=unused'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/disks/list?type=unused',
+ },
},
columns: [
{
var record = numberfield.getWidgetRecord();
record.set('order', value);
update_disklist(record);
- }
- }
- }
- }
- ]
- }
- ]
+ },
+ },
+ },
+ },
+ ],
+ },
+ ],
},
{
xtype: 'displayfield',
value: 'Note: ZFS is not compatible with disks backed by a hardware ' +
'RAID controller. For details see ' +
'<a target="_blank" href="' + Proxmox.Utils.get_help_link('chapter_zfs') + '">the reference documentation</a>.',
- }
- ]
+ },
+ ],
});
me.callParent();
me.down('#disklist').getStore().load();
- }
+ },
});
Ext.define('PVE.node.ZFSDevices', {
xtype: 'treecolumn',
text: gettext('Name'),
dataIndex: 'name',
- flex: 1
+ flex: 1,
},
{
text: gettext('Health'),
renderer: PVE.Utils.render_zfs_health,
- dataIndex: 'state'
+ dataIndex: 'state',
},
{
text: 'READ',
- dataIndex: 'read'
+ dataIndex: 'read',
},
{
text: 'WRITE',
- dataIndex: 'write'
+ dataIndex: 'write',
},
{
text: 'CKSUM',
- dataIndex: 'cksum'
+ dataIndex: 'cksum',
},
{
text: gettext('Message'),
- dataIndex: 'msg'
- }
+ dataIndex: 'msg',
+ },
],
rootVisible: true,
sm.deselectAll();
me.setRootNode(response.result.data);
me.expandAll();
- }
+ },
});
},
if (data.leaf) {
return txt + 'hdd-o';
}
- }
- }
+ },
+ },
],
- sorters: 'name'
+ sorters: 'name',
});
me.callParent();
me.reload();
- }
+ },
});
Ext.define('PVE.node.ZFSStatus', {
me.rows = {
scan: {
- header: gettext('Scan')
+ header: gettext('Scan'),
},
status: {
- header: gettext('Status')
+ header: gettext('Status'),
},
action: {
- header: gettext('Action')
+ header: gettext('Action'),
},
errors: {
- header: gettext('Errors')
- }
+ header: gettext('Errors'),
+ },
};
me.callParent();
me.reload();
- }
+ },
});
Ext.define('PVE.node.ZFSList', {
{
text: gettext('Name'),
dataIndex: 'name',
- flex: 1
+ flex: 1,
},
{
header: gettext('Size'),
renderer: Proxmox.Utils.format_size,
- dataIndex: 'size'
+ dataIndex: 'size',
},
{
header: gettext('Free'),
renderer: Proxmox.Utils.format_size,
- dataIndex: 'free'
+ dataIndex: 'free',
},
{
header: gettext('Allocated'),
renderer: Proxmox.Utils.format_size,
- dataIndex: 'alloc'
+ dataIndex: 'alloc',
},
{
header: gettext('Fragmentation'),
renderer: function(value) {
return value.toString() + '%';
},
- dataIndex: 'frag'
+ dataIndex: 'frag',
},
{
header: gettext('Health'),
renderer: PVE.Utils.render_zfs_health,
- dataIndex: 'health'
+ dataIndex: 'health',
},
{
header: gettext('Deduplication'),
renderer: function(value) {
return value.toFixed(2).toString() + 'x';
},
- dataIndex: 'dedup'
- }
+ dataIndex: 'dedup',
+ },
],
rootVisible: false,
handler: function() {
var me = this.up('panel');
me.reload();
- }
+ },
},
{
text: gettext('Create') + ': ZFS',
handler: function() {
var me = this.up('panel');
var win = Ext.create('PVE.node.CreateZFS', {
- nodename: me.nodename
+ nodename: me.nodename,
}).show();
win.on('destroy', function() { me.reload(); });
- }
+ },
},
{
text: gettext('Detail'),
return;
}
me.show_detail(selection[0].get('name'));
- }
- }
+ },
+ },
],
show_detail: function(zpool) {
layout: 'fit',
nodename: me.nodename,
flex: 0,
- zpool: zpool
+ zpool: zpool,
});
var devicetree = Ext.create('PVE.node.ZFSDevices', {
title: gettext('Devices'),
nodename: me.nodename,
flex: 1,
- zpool: zpool
+ zpool: zpool,
});
region: 'center',
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [detailsgrid, devicetree],
tbar: [{
devicetree.reload();
detailsgrid.reload();
- }
- }]
- }]
+ },
+ }],
+ }],
}).show();
},
itemdblclick: function(grid, record) {
var me = this;
me.show_detail(record.get('name'));
- }
+ },
},
initComponent: function() {
fields: ['name', 'size', 'free', 'alloc', 'dedup', 'frag', 'health'],
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/" + me.nodename + '/disks/zfs'
+ url: "/api2/json/nodes/" + me.nodename + '/disks/zfs',
},
- sorters: 'name'
- }
+ sorters: 'name',
+ },
});
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.getStore(), true);
me.reload();
- }
+ },
});
style: {
backgroundColor: '#f5f5f5',
padding: 0,
- margin: 0
+ margin: 0,
},
items: {
xtype: 'treelist',
} else {
info.toggle = true;
}
- }
- }
- }
+ },
+ },
+ },
},
{
xtype: 'toolbar',
itemId: 'toolbar',
dock: 'top',
height: 36,
- overflowHandler: 'scroller'
+ overflowHandler: 'scroller',
}],
firstItem: '',
tbar.unshift({
xtype: 'tbtext',
text: title,
- baseCls: 'x-panel-header-text'
+ baseCls: 'x-panel-header-text',
});
me.helpButton = Ext.create('Proxmox.button.Help', {
hidden: false,
listenToGlobalEvent: false,
- onlineHelp: me.onlineHelp || undefined
+ onlineHelp: me.onlineHelp || undefined,
});
tbar.push(me.helpButton);
title: gettext('Search'),
iconCls: 'fa fa-search',
xtype: 'pveResourceGrid',
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
}
me.store = Ext.create('Ext.data.TreeStore', {
root: {
- expanded: true
- }
+ expanded: true,
+ },
});
var root = me.store.getRoot();
me.insertNodes(me.items);
pveSelNode: me.pveSelNode,
viewFilter: me.viewFilter,
workspace: me.workspace,
- border: 0
+ border: 0,
});
me.callParent();
var root = me.store.getRoot();
items.forEach(function(item) {
- var treeitem = Ext.create('Ext.data.TreeModel',{
+ var treeitem = Ext.create('Ext.data.TreeModel', {
id: item.itemId,
text: item.title,
iconCls: item.iconCls,
leaf: true,
- expanded: item.expandedOnInit
+ expanded: item.expandedOnInit,
});
item.header = false;
if (me.savedItems[item.itemId] !== undefined) {
var me = this;
return {
isQemu: me.pveSelNode.data.type === 'qemu',
- isLxc: me.pveSelNode.data.type === 'lxc'
+ isLxc: me.pveSelNode.data.type === 'lxc',
};
},
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
defaults: {
xtype: 'pveInfoWidget',
- padding: '2 25'
+ padding: '2 25',
},
items: [
{
xtype: 'box',
- height: 20
+ height: 20,
},
{
itemId: 'status',
text += ' (' + qmpstatus + ')';
}
return text;
- }
+ },
},
{
itemId: 'hamanaged',
title: gettext('HA State'),
printBar: false,
textField: 'ha',
- renderer: PVE.Utils.format_ha
+ renderer: PVE.Utils.format_ha,
},
{
xtype: 'pveInfoWidget',
iconCls: 'fa fa-building fa-fw',
title: gettext('Node'),
cbind: {
- text: '{pveSelNode.data.node}'
+ text: '{pveSelNode.data.node}',
},
- printBar: false
+ printBar: false,
},
{
xtype: 'box',
- height: 15
+ height: 15,
},
{
itemId: 'cpu',
renderer: PVE.Utils.render_cpu_usage,
// in this specific api call
// we already have the correct value for the usage
- calculate: Ext.identityFn
+ calculate: Ext.identityFn,
},
{
itemId: 'memory',
iconCls: 'fa fa-fw pve-itype-icon-memory pve-icon',
title: gettext('Memory usage'),
valueField: 'mem',
- maxField: 'maxmem'
+ maxField: 'maxmem',
},
{
itemId: 'swap',
maxField: 'maxswap',
cbind: {
hidden: '{isQemu}',
- disabled: '{isQemu}'
- }
+ disabled: '{isQemu}',
+ },
},
{
itemId: 'rootfs',
if (used === 0) {
return PVE.Utils.render_size(max);
} else {
- return PVE.Utils.render_size_usage(used,max);
+ return PVE.Utils.render_size_usage(used, max);
}
- }
+ },
},
{
xtype: 'box',
- height: 15
+ height: 15,
},
{
itemId: 'ips',
rstore: '{rstore}',
pveSelNode: '{pveSelNode}',
hidden: '{isLxc}',
- disabled: '{isLxc}'
- }
- }
+ disabled: '{isLxc}',
+ },
+ },
],
updateTitle: function() {
}
me.setTitle(me.getRecordValue('name') + text);
- }
+ },
});
padding: template ? '5' : '0 5 0 0',
itemId: 'gueststatus',
pveSelNode: me.pveSelNode,
- rstore: rstore
+ rstore: rstore,
},
{
xtype: 'pveNotesView',
type: 'hbox',
align: 'stretch',
},
- items: items
- }
+ items: items,
+ },
];
rrdstore = Ext.create('Proxmox.data.RRDStore', {
rrdurl: `/api2/json/nodes/${nodename}/${type}/${vmid}/rrddata`,
- model: 'pve-rrd-guest'
+ model: 'pve-rrd-guest',
});
items.push(
pveSelNode: me.pveSelNode,
fields: ['cpu'],
fieldTitles: [gettext('CPU usage')],
- store: rrdstore
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
pveSelNode: me.pveSelNode,
fields: ['maxmem', 'mem'],
fieldTitles: [gettext('Total'), gettext('RAM usage')],
- store: rrdstore
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Network traffic'),
pveSelNode: me.pveSelNode,
- fields: ['netin','netout'],
- store: rrdstore
+ fields: ['netin', 'netout'],
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Disk IO'),
pveSelNode: me.pveSelNode,
- fields: ['diskread','diskwrite'],
- store: rrdstore
- }
+ fields: ['diskread', 'diskwrite'],
+ store: rrdstore,
+ },
);
}
xtype: 'container',
itemId: 'itemcontainer',
layout: {
- type: 'column'
+ type: 'column',
},
minWidth: 700,
defaults: {
listeners: {
resize: function(container) {
PVE.Utils.updateColumns(container);
- }
- }
- }
- ]
+ },
+ },
+ },
+ ],
});
me.callParent();
}
PVE.Utils.updateColumns(me.getComponent('itemcontainer'));
});
- }
+ },
});
data: {
iconCls: PVE.Utils.get_health_icon(undefined, true),
text: '',
- title: ''
+ title: '',
},
style: {
- 'text-align':'center'
+ 'text-align':'center',
},
tpl: [
'<h3>{title}</h3>',
'<i class="fa fa-5x {iconCls}"></i>',
'<br /><br/>',
- '{text}'
+ '{text}',
],
updateHealth: function(data) {
}
me.callParent();
- }
+ },
});
Ext.define('pve-fw-ipsets', {
extend: 'Ext.data.Model',
fields: [ 'name', 'comment', 'digest' ],
- idProperty: 'name'
+ idProperty: 'name',
});
Ext.define('PVE.IPSetList', {
model: 'pve-fw-ipsets',
proxy: {
type: 'proxmox',
- url: "/api2/json" + me.base_url
+ url: "/api2/json" + me.base_url,
},
sorters: {
property: 'name',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var sm = Ext.create('Ext.selection.RowModel', {});
{
xtype: 'hiddenfield',
name: 'rename',
- value: rec.data.name
+ value: rec.data.name,
},
{
xtype: 'textfield',
name: 'name',
value: rec.data.name,
fieldLabel: gettext('Name'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
name: 'comment',
value: rec.data.comment,
- fieldLabel: gettext('Comment')
- }
- ]
+ fieldLabel: gettext('Comment'),
+ },
+ ],
});
win.show();
win.on('destroy', reload);
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
me.addBtn = new Proxmox.button.Button({
name: 'name',
value: '',
fieldLabel: gettext('Name'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
name: 'comment',
value: '',
- fieldLabel: gettext('Comment')
- }
- ]
+ fieldLabel: gettext('Comment'),
+ },
+ ],
});
win.show();
win.on('destroy', reload);
- }
+ },
});
me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: me.base_url + '/',
- callback: reload
+ callback: reload,
});
Ext.apply(me, {
selModel: sm,
columns: [
{ header: 'IPSet', dataIndex: 'name', width: '100' },
- { header: gettext('Comment'), dataIndex: 'comment', renderer: Ext.String.htmlEncode, flex: 1 }
+ { header: gettext('Comment'), dataIndex: 'comment', renderer: Ext.String.htmlEncode, flex: 1 },
],
listeners: {
itemdblclick: run_editor,
deselect: function() {
me.ipset_panel.setBaseUrl(undefined);
},
- show: reload
- }
+ show: reload,
+ },
});
me.callParent();
store.load();
- }
+ },
});
Ext.define('PVE.IPSetCidrEdit', {
editable: true,
base_url: me.list_refs_url,
value: '',
- fieldLabel: gettext('IP/CIDR')
+ fieldLabel: gettext('IP/CIDR'),
});
} else {
column1.push({
xtype: 'displayfield',
name: 'cidr',
value: '',
- fieldLabel: gettext('IP/CIDR')
+ fieldLabel: gettext('IP/CIDR'),
});
}
name: 'nomatch',
checked: false,
uncheckedValue: 0,
- fieldLabel: 'nomatch'
- }
+ fieldLabel: 'nomatch',
+ },
],
columnB: [
{
xtype: 'textfield',
name: 'comment',
value: '',
- fieldLabel: gettext('Comment')
- }
- ]
+ fieldLabel: gettext('Comment'),
+ },
+ ],
});
Ext.apply(me, {
subject: gettext('IP/CIDR'),
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
success: function(response, options) {
var values = response.result.data;
ipanel.setValues(values);
- }
+ },
});
}
- }
+ },
});
Ext.define('PVE.IPSetGrid', {
me.removeBtn.baseurl = url + '/';
me.store.setProxy({
type: 'proxmox',
- url: '/api2/json' + url
+ url: '/api2/json' + url,
});
me.store.load();
}
var store = new Ext.data.Store({
- model: 'pve-ipset'
+ model: 'pve-ipset',
});
var reload = function() {
}
var win = Ext.create('PVE.IPSetCidrEdit', {
base_url: me.base_url,
- cidr: rec.data.cidr
+ cidr: rec.data.cidr,
});
win.show();
win.on('destroy', reload);
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
me.addBtn = new Proxmox.button.Button({
}
var win = Ext.create('PVE.IPSetCidrEdit', {
base_url: me.base_url,
- list_refs_url: me.list_refs_url
+ list_refs_url: me.list_refs_url,
});
win.show();
win.on('destroy', reload);
- }
+ },
});
me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: me.base_url + '/',
- callback: reload
+ callback: reload,
});
var render_errors = function(value, metaData, record) {
metaData.tdCls = 'proxmox-invalid-row';
var html = '<p>' + Ext.htmlEncode(msg) + '</p>';
metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' +
- html.replace(/\"/g,'"') + '"';
+ html.replace(/\"/g, '"') + '"';
}
}
return value;
store: store,
selModel: sm,
listeners: {
- itemdblclick: run_editor
+ itemdblclick: run_editor,
},
columns: [
{
- xtype: 'rownumberer'
+ xtype: 'rownumberer',
},
{
header: gettext('IP/CIDR'),
return '<b>! </b>' + value;
}
return value;
- }
+ },
},
{
header: gettext('Comment'),
flex: 1,
renderer: function(value) {
return Ext.util.Format.htmlEncode(value);
- }
- }
- ]
+ },
+ },
+ ],
});
me.callParent();
if (me.base_url) {
me.setBaseUrl(me.base_url); // load
}
- }
+ },
}, function() {
Ext.define('pve-ipset', {
extend: 'Ext.data.Model',
fields: [ { name: 'nomatch', type: 'boolean' },
'cidr', 'comment', 'errors' ],
- idProperty: 'cidr'
+ idProperty: 'cidr',
});
});
var ipset_panel = Ext.createWidget('pveIPSetGrid', {
region: 'center',
list_refs_url: me.list_refs_url,
- border: false
+ border: false,
});
var ipset_list = Ext.createWidget('pveIPSetList', {
base_url: me.base_url,
width: '50%',
border: false,
- split: true
+ split: true,
});
Ext.apply(me, {
listeners: {
show: function() {
ipset_list.fireEvent('show', ipset_list);
- }
- }
+ },
+ },
});
me.callParent();
- }
+ },
});
-Ext.define('PVE.widget.Info',{
+Ext.define('PVE.widget.Info', {
extend: 'Ext.container.Container',
alias: 'widget.pveInfoWidget',
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
value: 0,
data: {
title: '',
usage: '',
- iconCls: undefined
+ iconCls: undefined,
},
tpl: [
'<div class="left-aligned">',
'<tpl if="iconCls">',
'<i class="{iconCls}"></i> ',
'</tpl>',
- '{title}</div> <div class="right-aligned">{usage}</div>'
- ]
+ '{title}</div> <div class="right-aligned">{usage}</div>',
+ ],
},
{
height: 2,
- border: 0
+ border: 0,
},
{
xtype: 'progressbar',
itemId: 'progress',
height: 5,
value: 0,
- animate: true
- }
+ animate: true,
+ },
],
warningThreshold: 0.6,
me.updateValue(me.text, me.value);
me.setIconCls(me.iconCls);
- }
+ },
});
handler: function() {
var me = this.up('panel');
me.run_editor();
- }
- }
- ]
+ },
+ },
+ ],
},
run_editor: function() {
var me = this;
var win = Ext.create('PVE.window.NotesEdit', {
pveSelNode: me.pveSelNode,
- url: me.url
+ url: me.url,
});
win.show();
win.on('destroy', me.load, me);
if (me.collapsible && me.collapseMode === 'auto') {
me.setCollapsed(data === '');
}
- }
+ },
});
},
handler: function() {
var me = this.up('panel');
me.run_editor();
- }
+ },
}],
initComponent : function() {
}
}
me.load();
- }
+ },
});
layout: {
type: 'hbox',
- align: 'center'
+ align: 'center',
},
items: [
{
xtype: 'box',
itemId: 'title',
data: {
- title: ''
+ title: '',
},
- tpl: '<h3>{title}:</h3>'
+ tpl: '<h3>{title}:</h3>',
},
{
flex: 1,
type: 'numeric',
position: 'left',
hidden: true,
- minimum: 0
+ minimum: 0,
},
{
type: 'numeric',
position: 'bottom',
- hidden: true
- }
+ hidden: true,
+ },
],
store: {
text: '0 B/s',
textAlign: 'end',
textBaseline: 'middle',
- fontSize: 14
+ fontSize: 14,
}],
series: [{
let value = me.up().renderer(record.data.val);
tooltip.setHtml(
me.up().title + ': ' + value + '<br />' +
- Ext.Date.format(date, 'H:i:s')
+ Ext.Date.format(date, 'H:i:s'),
);
- }
+ },
},
style: {
lineWidth: 1.5,
- opacity: 0.60
+ opacity: 0.60,
},
marker: {
opacity: 0,
scaling: 0.01,
fx: {
duration: 200,
- easing: 'easeOut'
- }
+ easing: 'easeOut',
+ },
},
highlightCfg: {
opacity: 1,
- scaling: 1.5
- }
- }]
- }
+ scaling: 1.5,
+ },
+ }],
+ },
],
// the renderer for the tooltip and last value, default just the value
me.store.add({
time: time || now,
- val: value || 0
+ val: value || 0,
});
// delete all old records when we have 20 times more datapoints
me.valuesprite.setText(panel.renderer(value || 0).toString());
me.valuesprite.setAttributes({
x: me.getWidth() - 15,
- y: me.getHeight()/2
+ y: me.getHeight()/2,
}, true);
me.redraw();
},
if (me.color) {
me.chart.series[0].setStyle({
fill: me.color,
- stroke: me.color
+ stroke: me.color,
});
}
- }
+ },
});
var atab = me.getActiveTab().itemId;
var state = { value: atab };
sp.set(stateid, state);
- }
+ },
},
items: [
{
itemId: 'tasks',
title: gettext('Tasks'),
- xtype: 'pveClusterTasks'
+ xtype: 'pveClusterTasks',
},
{
itemId: 'clog',
title: gettext('Cluster log'),
- xtype: 'pveClusterLog'
- }
- ]
+ xtype: 'pveClusterLog',
+ },
+ ],
});
me.callParent();
sp.un('statechange', statechange);
});
- }
+ },
});
alias: 'widget.pveStatusView',
layout: {
- type: 'column'
+ type: 'column',
},
title: gettext('Status'),
return '';
},
- fieldRenderer: function(val,max) {
+ fieldRenderer: function(val, max) {
if (max === undefined) {
return val;
}
if (!Ext.isNumeric(max) || max === 1) {
return PVE.Utils.render_usage(val);
}
- return PVE.Utils.render_size_usage(val,max);
+ return PVE.Utils.render_size_usage(val, max);
},
fieldCalculator: function(used, max) {
if (Ext.isFunction(field.calculate)) {
calculate = field.calculate;
}
- field.updateValue(renderer.call(field, used,max), calculate(used,max));
+ field.updateValue(renderer.call(field, used, max), calculate(used, max));
}
},
me.callParent();
me.mon(me.rstore, 'load', 'updateValues');
- }
+ },
});
-Ext.define('PVE.panel.TemplateStatusView',{
+Ext.define('PVE.panel.TemplateStatusView', {
extend: 'PVE.panel.StatusView',
alias: 'widget.pveTemplateStatusView',
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
defaults: {
xtype: 'pveInfoWidget',
printBar: false,
- padding: '2 25'
+ padding: '2 25',
},
items: [
{
xtype: 'box',
- height: 20
+ height: 20,
},
{
itemId: 'hamanaged',
title: gettext('HA State'),
printBar: false,
textField: 'ha',
- renderer: PVE.Utils.format_ha
+ renderer: PVE.Utils.format_ha,
},
{
itemId: 'node',
iconCls: 'fa fa-fw fa-building',
- title: gettext('Node')
+ title: gettext('Node'),
},
{
xtype: 'box',
- height: 20
+ height: 20,
},
{
itemId: 'cpus',
iconCls: 'fa fa-fw pve-itype-icon-processor pve-icon',
title: gettext('Processors'),
- textField: 'cpus'
+ textField: 'cpus',
},
{
itemId: 'memory',
iconCls: 'fa fa-fw pve-itype-icon-memory pve-icon',
title: gettext('Memory'),
textField: 'maxmem',
- renderer: PVE.Utils.render_size
+ renderer: PVE.Utils.render_size,
},
{
itemId: 'swap',
iconCls: 'fa fa-refresh fa-fw',
title: gettext('Swap'),
textField: 'maxswap',
- renderer: PVE.Utils.render_size
+ renderer: PVE.Utils.render_size,
},
{
itemId: 'disk',
iconCls: 'fa fa-hdd-o fa-fw',
title: gettext('Bootdisk size'),
textField: 'maxdisk',
- renderer: PVE.Utils.render_size
+ renderer: PVE.Utils.render_size,
},
{
xtype: 'box',
- height: 20
- }
+ height: 20,
+ },
],
initComponent: function() {
me.remove(me.getComponent('swap'));
}
me.getComponent('node').updateValue(me.pveSelNode.data.node);
- }
+ },
});
title: gettext('Summary'),
iconCls: 'fa fa-book',
xtype: 'pvePoolSummary',
- itemId: 'summary'
+ itemId: 'summary',
},
{
title: gettext('Members'),
xtype: 'pvePoolMembers',
iconCls: 'fa fa-th',
pool: pool,
- itemId: 'members'
+ itemId: 'members',
},
{
xtype: 'pveACLView',
title: gettext('Permissions'),
iconCls: 'fa fa-unlock',
itemId: 'permissions',
- path: '/pool/' + pool
- }
- ]
+ path: '/pool/' + pool,
+ },
+ ],
});
me.callParent();
- }
+ },
});
comment: {
header: gettext('Comment'),
renderer: Ext.String.htmlEncode,
- required: true
- }
+ required: true,
+ },
};
Ext.apply(me, {
url: "/api2/json/pools/" + pool,
- rows: rows
+ rows: rows,
});
me.callParent();
- }
+ },
});
var statusview = Ext.create('PVE.pool.StatusView', {
pveSelNode: me.pveSelNode,
- style: 'padding-top:0px'
+ style: 'padding-top:0px',
});
var rstore = statusview.rstore;
bodyStyle: 'padding:10px',
defaults: {
style: 'padding-top:10px',
- width: 800
+ width: 800,
},
- items: [ statusview ]
+ items: [ statusview ],
});
me.on('activate', rstore.startUpdate);
me.on('destroy', rstore.stopUpdate);
me.callParent();
- }
+ },
});
title: gettext('Guest Agent Network Information'),
height: 300,
layout: {
- type: 'fit'
+ type: 'fit',
},
modal: true,
items: [
{
dataIndex: 'name',
text: gettext('Name'),
- flex: 3
+ flex: 3,
},
{
dataIndex: 'hardware-address',
text: gettext('MAC address'),
- width: 140
+ width: 140,
},
{
dataIndex: 'ip-addresses',
}
});
return ips.join('<br>');
- }
- }
- ]
- }
- ]
+ },
+ },
+ ],
+ },
+ ],
});
Ext.define('PVE.qemu.AgentIPView', {
layout: {
type: 'hbox',
- align: 'top'
+ align: 'top',
},
nics: [],
items: [
{
xtype: 'box',
- html: '<i class="fa fa-exchange"></i> IPs'
+ html: '<i class="fa fa-exchange"></i> IPs',
},
{
xtype: 'container',
layout: {
type: 'vbox',
align: 'right',
- pack: 'end'
+ pack: 'end',
},
items: [
{
flex: 1,
itemId: 'ipBox',
style: {
- 'text-align': 'right'
- }
+ 'text-align': 'right',
+ },
},
{
xtype: 'button',
win.down('grid').getStore().setData(me.nics);
win.show();
},
- text: gettext('More')
- }
- ]
- }
+ text: gettext('More'),
+ },
+ ],
+ },
],
getDefaultIps: function(nics) {
method: 'POST',
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + nodename + '/qemu/' + vmid + '/agent/network-get-interfaces'
- }
+ url: '/api2/json/nodes/' + nodename + '/qemu/' + vmid + '/agent/network-get-interfaces',
+ },
});
me.callParent();
// check if the guest agent is there on every statusstore load
me.mon(me.rstore, 'load', me.startIPStore, me);
- }
+ },
});
var ret = PVE.Parser.printPropertyString(values);
if (ret === '') {
return {
- 'delete': 'audio0'
+ 'delete': 'audio0',
};
}
return {
- audio0: ret
+ audio0: ret,
};
},
comboItems: [
['ich9-intel-hda', 'ich9-intel-hda'],
['intel-hda', 'intel-hda'],
- ['AC97', 'AC97']
- ]
+ ['AC97', 'AC97'],
+ ],
}, {
name: 'driver',
xtype: 'proxmoxKVComboBox',
comboItems: [
['spice', 'SPICE'],
['none', `${Proxmox.Utils.NoneText} (${gettext('Dummy Device')})`],
- ]
- }]
+ ],
+ }],
});
Ext.define('PVE.qemu.AudioEdit', {
subject: gettext('Audio Device'),
items: [{
- xtype: 'pveAudioInputPanel'
+ xtype: 'pveAudioInputPanel',
}],
initComponent : function() {
if (audio0) {
me.setValues(PVE.Parser.parsePropertyString(audio0));
}
- }
+ },
});
- }
+ },
});
if (!me.confid) {
me.bussel = Ext.create('PVE.form.ControllerSelector', {
- noVirtIO: true
+ noVirtIO: true,
});
items.push(me.bussel);
}
} else {
cdImageField.reset();
}
- }
- }
+ },
+ },
});
me.cdfilesel = Ext.create('PVE.form.FileSelector', {
storageContent: 'iso',
fieldLabel: gettext('ISO image'),
labelAlign: 'right',
- allowBlank: false
+ allowBlank: false,
});
me.cdstoragesel = Ext.create('PVE.form.StorageSelector', {
listeners: {
change: function(f, value) {
me.cdfilesel.setStorage(value);
- }
- }
+ },
+ },
});
items.push(me.cdstoragesel);
xtype: 'radiofield',
name: 'mediaType',
inputValue: 'cdrom',
- boxLabel: gettext('Use physical CD/DVD Drive')
+ boxLabel: gettext('Use physical CD/DVD Drive'),
});
items.push({
xtype: 'radiofield',
name: 'mediaType',
inputValue: 'none',
- boxLabel: gettext('Do not use any media')
+ boxLabel: gettext('Do not use any media'),
});
me.items = items;
me.callParent();
- }
+ },
});
Ext.define('PVE.qemu.CDEdit', {
var ipanel = Ext.create('PVE.qemu.CDInputPanel', {
confid: me.confid,
- nodename: nodename
+ nodename: nodename,
});
Ext.applyIf(me, {
subject: 'CD/DVD Drive',
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
}
ipanel.setDrive(drive);
}
- }
+ },
});
- }
+ },
});
noVirtIO: true,
itemId: 'drive',
fieldLabel: gettext('CloudInit Drive'),
- name: 'drive'
+ name: 'drive',
},
{
xtype: 'pveDiskStorageSelector',
itemId: 'storselector',
storageContent: 'images',
nodename: me.nodename,
- hideSize: true
- }
+ hideSize: true,
+ },
];
me.callParent();
- }
+ },
});
Ext.define('PVE.qemu.CIDriveEdit', {
me.items = [{
xtype: 'pveCIDriveInputPanel',
itemId: 'cipanel',
- nodename: nodename
+ nodename: nodename,
}];
me.callParent();
me.load({
success: function(response, opts) {
me.down('#cipanel').setVMConfig(response.result.data);
- }
+ },
});
- }
+ },
});
},
callback: function() {
me.reload();
- }
+ },
});
},
- text: gettext('Remove')
+ text: gettext('Remove'),
},
{
xtype: 'proxmoxButton',
var me = this.up('grid');
me.run_editor();
},
- text: gettext('Edit')
+ text: gettext('Edit'),
},
'-',
{
failure: failure,
callback: function() {
me.reload();
- }
+ },
});
- }
+ },
});
- }
- }
+ },
+ },
],
border: false,
itemdblclick: function() {
var me = this;
me.run_editor();
- }
+ },
},
initComponent: function() {
deleteEmpty: true,
emptyText: Proxmox.Utils.defaultText,
fieldLabel: gettext('User'),
- name: 'ciuser'
- }
- ]
+ name: 'ciuser',
+ },
+ ],
} : undefined,
renderer: function(value) {
return value || Proxmox.Utils.defaultText;
- }
+ },
},
cipassword: {
header: gettext('Password'),
deleteEmpty: true,
emptyText: Proxmox.Utils.noneText,
fieldLabel: gettext('Password'),
- name: 'cipassword'
- }
- ]
+ name: 'cipassword',
+ },
+ ],
} : undefined,
renderer: function(value) {
return value || Proxmox.Utils.noneText;
- }
+ },
},
searchdomain: {
header: gettext('DNS domain'),
iconCls: 'fa fa-globe',
editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
never_delete: true,
- defaultValue: gettext('use host settings')
+ defaultValue: gettext('use host settings'),
},
nameserver: {
header: gettext('DNS servers'),
iconCls: 'fa fa-globe',
editor: caps.vms['VM.Config.Network'] ? 'PVE.lxc.DNSEdit' : undefined,
never_delete: true,
- defaultValue: gettext('use host settings')
+ defaultValue: gettext('use host settings'),
},
sshkeys: {
header: gettext('SSH public key'),
return Proxmox.Utils.noneText;
}
},
- defaultValue: ''
- }
+ defaultValue: '',
+ },
};
var i;
var ipconfig_renderer = function(value, md, record, ri, ci, store, pending) {
header: gettext('IP Config') + ' (net' + i.toString() +')',
editor: caps.vms['VM.Config.Network'] ? 'PVE.qemu.IPConfigEdit' : undefined,
iconCls: 'fa fa-exchange',
- renderer: ipconfig_renderer
+ renderer: ipconfig_renderer,
};
me.rows['ipconfig' + i.toString()] = {
- visible: false
+ visible: false,
};
}
PVE.Utils.forEachBus(['ide', 'scsi', 'sata'], function(type, id) {
me.rows[type+id] = {
- visible: false
+ visible: false,
};
});
me.callParent();
me.mon(me.rstore, 'load', me.set_button_status, me);
- }
+ },
});
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
- }
+ },
});
};
disabled: running || suspended,
handler: function() {
vm_command('start');
- }
+ },
},
{
text: gettext('Pause'),
}
vm_command('suspend');
});
- }
+ },
},
{
text: gettext('Hibernate'),
}
vm_command('suspend', { todisk: 1 });
});
- }
+ },
},
{
text: gettext('Resume'),
hidden: !suspended,
handler: function() {
vm_command('resume');
- }
+ },
},
{
text: gettext('Shutdown'),
vm_command('shutdown');
});
- }
+ },
},
{
text: gettext('Stop'),
vm_command("stop");
});
- }
+ },
},
{
text: gettext('Reboot'),
vm_command("reboot");
});
- }
+ },
},
{
xtype: 'menuseparator',
- hidden: (standalone || !caps.vms['VM.Migrate']) && !caps.vms['VM.Allocate'] && !caps.vms['VM.Clone']
+ hidden: (standalone || !caps.vms['VM.Migrate']) && !caps.vms['VM.Allocate'] && !caps.vms['VM.Clone'],
},
{
text: gettext('Migrate'),
var win = Ext.create('PVE.window.Migrate', {
vmtype: 'qemu',
nodename: nodename,
- vmid: vmid
+ vmid: vmid,
});
win.show();
- }
+ },
},
{
text: gettext('Clone'),
hidden: !caps.vms['VM.Clone'],
handler: function() {
PVE.window.Clone.wrap(nodename, vmid, me.isTemplate, 'qemu');
- }
+ },
},
{
text: gettext('Convert to template'),
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
- }
+ },
});
});
- }
+ },
},
{ xtype: 'menuseparator' },
{
var allowXtermjs = response.result.data.serial;
var consoles = {
spice: allowSpice,
- xtermjs: allowXtermjs
+ xtermjs: allowXtermjs,
};
PVE.Utils.openDefaultConsoleWindow(consoles, 'kvm', vmid, nodename, vmname);
- }
+ },
});
- }
- }
+ },
+ },
];
me.callParent();
- }
+ },
});
me.statusStore = Ext.create('Proxmox.data.ObjectStore', {
url: '/api2/json' + base_url + '/status/current',
- interval: 1000
+ interval: 1000,
});
var vm_command = function(cmd, params) {
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
- }
+ },
});
};
handler: function() {
vm_command('resume');
},
- iconCls: 'fa fa-play'
+ iconCls: 'fa fa-play',
});
var startBtn = Ext.create('Ext.Button', {
handler: function() {
vm_command('start');
},
- iconCls: 'fa fa-play'
+ iconCls: 'fa fa-play',
});
var migrateBtn = Ext.create('Ext.Button', {
var win = Ext.create('PVE.window.Migrate', {
vmtype: 'qemu',
nodename: nodename,
- vmid: vmid
+ vmid: vmid,
});
win.show();
},
- iconCls: 'fa fa-send-o'
+ iconCls: 'fa fa-send-o',
});
var moreBtn = Ext.create('Proxmox.button.Button', {
hidden: caps.vms['VM.Clone'] ? false : true,
handler: function() {
PVE.window.Clone.wrap(nodename, vmid, template, 'qemu');
- }
+ },
},
{
text: gettext('Convert to template'),
method: 'POST',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
- }
+ },
});
- }
+ },
},
{
iconCls: 'fa fa-heartbeat ',
var ha = vm.hastate;
Ext.create('PVE.ha.VMResourceEdit', {
vmid: vmid,
- isCreate: (!ha || ha === 'unmanaged')
+ isCreate: (!ha || ha === 'unmanaged'),
}).show();
- }
+ },
},
{
text: gettext('Remove'),
handler: function() {
Ext.create('PVE.window.SafeDestroy', {
url: base_url,
- item: { type: 'VM', id: vmid }
+ item: { type: 'VM', id: vmid },
}).show();
},
- iconCls: 'fa fa-trash-o'
- }
- ]}
+ iconCls: 'fa fa-trash-o',
+ },
+ ]},
});
var shutdownBtn = Ext.create('PVE.button.Split', {
handler: function() {
vm_command("reboot");
},
- iconCls: 'fa fa-refresh'
- },{
+ iconCls: 'fa fa-refresh',
+ }, {
text: gettext('Pause'),
disabled: !caps.vms['VM.PowerMgmt'],
confirmMsg: Proxmox.Utils.format_task_description('qmpause', vmid),
handler: function() {
vm_command("suspend");
},
- iconCls: 'fa fa-pause'
- },{
+ iconCls: 'fa fa-pause',
+ }, {
text: gettext('Hibernate'),
disabled: !caps.vms['VM.PowerMgmt'],
confirmMsg: Proxmox.Utils.format_task_description('qmsuspend', vmid),
handler: function() {
vm_command("suspend", { todisk: 1 });
},
- iconCls: 'fa fa-download'
- },{
+ iconCls: 'fa fa-download',
+ }, {
text: gettext('Stop'),
disabled: !caps.vms['VM.PowerMgmt'],
dangerous: true,
handler: function() {
vm_command("stop", { timeout: 30 });
},
- iconCls: 'fa fa-stop'
- },{
+ iconCls: 'fa fa-stop',
+ }, {
text: gettext('Reset'),
disabled: !caps.vms['VM.PowerMgmt'],
tooltip: Ext.String.format(gettext('Reset {0} immediately'), 'VM'),
handler: function() {
vm_command("reset");
},
- iconCls: 'fa fa-bolt'
- }]
+ iconCls: 'fa fa-bolt',
+ }],
},
- iconCls: 'fa fa-power-off'
+ iconCls: 'fa fa-power-off',
});
var consoleBtn = Ext.create('PVE.button.ConsoleButton', {
consoleType: 'kvm',
consoleName: vm.name,
nodename: nodename,
- vmid: vmid
+ vmid: vmid,
});
var statusTxt = Ext.create('Ext.toolbar.TextItem', {
data: {
- lock: undefined
+ lock: undefined,
},
tpl: [
'<tpl if="lock">',
'<i class="fa fa-lg fa-lock"></i> ({lock})',
- '</tpl>'
- ]
+ '</tpl>',
+ ],
});
Ext.apply(me, {
title: gettext('Summary'),
xtype: 'pveGuestSummary',
iconCls: 'fa fa-book',
- itemId: 'summary'
- }
- ]
+ itemId: 'summary',
+ },
+ ],
});
if (caps.vms['VM.Console'] && !template) {
xtype: 'pveNoVncConsole',
vmid: vmid,
consoleType: 'kvm',
- nodename: nodename
+ nodename: nodename,
});
}
title: gettext('Hardware'),
itemId: 'hardware',
iconCls: 'fa fa-desktop',
- xtype: 'PVE.qemu.HardwareView'
+ xtype: 'PVE.qemu.HardwareView',
},
{
title: 'Cloud-Init',
itemId: 'cloudinit',
iconCls: 'fa fa-cloud',
- xtype: 'pveCiPanel'
+ xtype: 'pveCiPanel',
},
{
title: gettext('Options'),
iconCls: 'fa fa-gear',
itemId: 'options',
- xtype: 'PVE.qemu.Options'
+ xtype: 'PVE.qemu.Options',
},
{
title: gettext('Task History'),
xtype: 'proxmoxNodeTasks',
iconCls: 'fa fa-list',
nodename: nodename,
- vmidFilter: vmid
- }
+ vmidFilter: vmid,
+ },
);
if (caps.vms['VM.Monitor'] && !template) {
title: gettext('Monitor'),
iconCls: 'fa fa-eye',
itemId: 'monitor',
- xtype: 'pveQemuMonitor'
+ xtype: 'pveQemuMonitor',
});
}
title: gettext('Backup'),
iconCls: 'fa fa-floppy-o',
xtype: 'pveBackupView',
- itemId: 'backup'
+ itemId: 'backup',
},
{
title: gettext('Replication'),
iconCls: 'fa fa-retweet',
xtype: 'pveReplicaView',
- itemId: 'replication'
+ itemId: 'replication',
});
}
iconCls: 'fa fa-history',
type: 'qemu',
xtype: 'pveGuestSnapshotTree',
- itemId: 'snapshot'
+ itemId: 'snapshot',
});
}
allow_iface: true,
base_url: base_url + '/firewall/rules',
list_refs_url: base_url + '/firewall/refs',
- itemId: 'firewall'
+ itemId: 'firewall',
},
{
xtype: 'pveFirewallOptions',
title: gettext('Options'),
base_url: base_url + '/firewall/options',
fwtype: 'vm',
- itemId: 'firewall-options'
+ itemId: 'firewall-options',
},
{
xtype: 'pveFirewallAliases',
groups: ['firewall'],
iconCls: 'fa fa-external-link',
base_url: base_url + '/firewall/aliases',
- itemId: 'firewall-aliases'
+ itemId: 'firewall-aliases',
},
{
xtype: 'pveIPSet',
iconCls: 'fa fa-list-ol',
base_url: base_url + '/firewall/ipset',
list_refs_url: base_url + '/firewall/refs',
- itemId: 'firewall-ipset'
+ itemId: 'firewall-ipset',
},
{
title: gettext('Log'),
onlineHelp: 'chapter_pve_firewall',
itemId: 'firewall-fwlog',
xtype: 'proxmoxLogView',
- url: '/api2/extjs' + base_url + '/firewall/log'
- }
+ url: '/api2/extjs' + base_url + '/firewall/log',
+ },
);
}
title: gettext('Permissions'),
iconCls: 'fa fa-unlock',
itemId: 'permissions',
- path: '/vms/' + vmid
+ path: '/vms/' + vmid,
});
}
me.on('destroy', function() {
me.statusStore.stopUpdate();
});
- }
+ },
});
data: {
nodename: '',
current: {
- scsihw: ''
- }
- }
+ scsihw: '',
+ },
+ },
},
cbindData: {
- nodename: undefined
+ nodename: undefined,
},
subject: gettext('Virtual Machine'),
name: 'nodename',
cbind: {
selectCurNode: '{!nodename}',
- preferredValue: '{nodename}'
+ preferredValue: '{nodename}',
},
bind: {
- value: '{nodename}'
+ value: '{nodename}',
},
fieldLabel: gettext('Node'),
allowBlank: false,
- onlineValidator: true
+ onlineValidator: true,
},
{
xtype: 'pveGuestIDSelector',
guestType: 'qemu',
value: '',
loadNextFreeID: true,
- validateExists: false
+ validateExists: false,
},
{
xtype: 'textfield',
vtype: 'DnsName',
value: '',
fieldLabel: gettext('Name'),
- allowBlank: true
- }
+ allowBlank: true,
+ },
],
column2: [
{
fieldLabel: gettext('Resource Pool'),
name: 'pool',
value: '',
- allowBlank: true
- }
+ allowBlank: true,
+ },
],
advancedColumn1: [
{
uncheckedValue: 0,
defaultValue: 0,
deleteDefaultValue: true,
- fieldLabel: gettext('Start at boot')
- }
+ fieldLabel: gettext('Start at boot'),
+ },
],
advancedColumn2: [
{
defaultValue: '',
emptyText: 'any',
labelWidth: 120,
- fieldLabel: gettext('Start/Shutdown order')
+ fieldLabel: gettext('Start/Shutdown order'),
},
{
xtype: 'textfield',
defaultValue: '',
emptyText: 'default',
labelWidth: 120,
- fieldLabel: gettext('Startup delay')
+ fieldLabel: gettext('Startup delay'),
},
{
xtype: 'textfield',
defaultValue: '',
emptyText: 'default',
labelWidth: 120,
- fieldLabel: gettext('Shutdown timeout')
- }
+ fieldLabel: gettext('Shutdown timeout'),
+ },
],
onGetValues: function(values) {
var res = PVE.Parser.printStartup({
order: values.order,
up: values.up,
- down: values.down
+ down: values.down,
});
if (res) {
delete values.down;
return values;
- }
+ },
},
{
xtype: 'container',
layout: 'hbox',
defaults: {
flex: 1,
- padding: '0 10'
+ padding: '0 10',
},
title: gettext('OS'),
items: [
{
xtype: 'pveQemuCDInputPanel',
bind: {
- nodename: '{nodename}'
+ nodename: '{nodename}',
},
confid: 'ide2',
- insideWizard: true
+ insideWizard: true,
},
{
xtype: 'pveQemuOSTypePanel',
- insideWizard: true
- }
- ]
+ insideWizard: true,
+ },
+ ],
},
{
xtype: 'pveQemuSystemPanel',
title: gettext('System'),
isCreate: true,
- insideWizard: true
+ insideWizard: true,
},
{
xtype: 'pveQemuHDInputPanel',
bind: {
- nodename: '{nodename}'
+ nodename: '{nodename}',
},
title: gettext('Hard Disk'),
isCreate: true,
- insideWizard: true
+ insideWizard: true,
},
{
xtype: 'pveQemuProcessorPanel',
insideWizard: true,
- title: gettext('CPU')
+ title: gettext('CPU'),
},
{
xtype: 'pveQemuMemoryPanel',
insideWizard: true,
- title: gettext('Memory')
+ title: gettext('Memory'),
},
{
xtype: 'pveQemuNetworkInputPanel',
bind: {
- nodename: '{nodename}'
+ nodename: '{nodename}',
},
title: gettext('Network'),
- insideWizard: true
+ insideWizard: true,
},
{
title: gettext('Confirm'),
model: 'KeyValue',
sorters: [{
property : 'key',
- direction: 'ASC'
- }]
+ direction: 'ASC',
+ }],
},
columns: [
{header: 'Key', width: 150, dataIndex: 'key'},
- {header: 'Value', flex: 1, dataIndex: 'value'}
- ]
- }
+ {header: 'Value', flex: 1, dataIndex: 'value'},
+ ],
+ },
],
dockedItems: [
{
name: 'start',
dock: 'bottom',
margin: '5 0 0 0',
- boxLabel: gettext('Start after created')
- }
+ boxLabel: gettext('Start after created'),
+ },
],
listeners: {
show: function(panel) {
summarystore.resumeEvents();
summarystore.fireEvent('refresh');
- }
+ },
},
onSubmit: function() {
var wizard = this.up('window');
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
- }
- ]
+ },
+ },
+ ],
});
var ret = PVE.Parser.printPropertyString(values, 'type');
if (ret === '') {
return {
- 'delete': 'vga'
+ 'delete': 'vga',
};
}
return {
- vga: ret
+ vga: ret,
};
},
var memoryfield = me.down('field[name=memory]');
memoryfield.setEmptyText(emptyText);
memoryfield.setDisabled(disable);
- }
- }
- },{
+ },
+ },
+ }, {
xtype: 'proxmoxintegerfield',
emptyText: Proxmox.Utils.defaultText,
fieldLabel: gettext('Memory') + ' (MiB)',
minValue: 4,
maxValue: 512,
step: 4,
- name: 'memory'
- }]
+ name: 'memory',
+ }],
});
Ext.define('PVE.qemu.DisplayEdit', {
width: 350,
items: [{
- xtype: 'pveDisplayInputPanel'
+ xtype: 'pveDisplayInputPanel',
}],
initComponent : function() {
me.vmconfig = response.result.data;
var vga = me.vmconfig.vga || '__default__';
me.setValues(PVE.Parser.parsePropertyString(vga, 'type'));
- }
+ },
});
- }
+ },
});
control: {
'field[name=controller]': {
change: 'onControllerChange',
- afterrender: 'onControllerChange'
+ afterrender: 'onControllerChange',
},
'field[name=iothread]' : {
change: function(f, value) {
}
var vmScsiType = value ? 'virtio-scsi-single': 'virtio-scsi-pci';
this.lookupReference('scsiController').setValue(vmScsiType);
- }
- }
+ },
+ },
},
init: function(view) {
if (view.isCreate) {
vm.set('isIncludedInBackup', true);
}
- }
+ },
},
onGetValues: function(values) {
if (!me.confid || me.unused) {
me.bussel = Ext.create('PVE.form.ControllerSelector', {
- vmconfig: me.insideWizard ? {ide2: 'cdrom'} : {}
+ vmconfig: me.insideWizard ? {ide2: 'cdrom'} : {},
});
me.column1.push(me.bussel);
fieldLabel: gettext('SCSI Controller'),
reference: 'scsiController',
bind: me.insideWizard ? {
- value: '{current.scsihw}'
+ value: '{current.scsihw}',
} : undefined,
renderer: PVE.Utils.render_scsihw,
submitValue: false,
- hidden: true
+ hidden: true,
});
me.column1.push(me.scsiController);
}
fieldLabel: gettext('Disk image'),
matchFieldWidth: false,
listConfig: {
- width: 350
+ width: 350,
},
data: [],
- allowBlank: false
+ allowBlank: false,
});
me.column1.push(me.unusedDisks);
} else if (me.isCreate) {
storageContent: 'images',
name: 'disk',
nodename: me.nodename,
- autoSelect: me.insideWizard
+ autoSelect: me.insideWizard,
});
} else {
me.column1.push({
disabled: true,
submitValue: false,
fieldLabel: gettext('Disk image'),
- name: 'hdimage'
+ name: 'hdimage',
});
}
xtype: 'CacheTypeSelector',
name: 'cache',
value: '__default__',
- fieldLabel: gettext('Cache')
+ fieldLabel: gettext('Cache'),
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Discard'),
reference: 'discard',
- name: 'discard'
- }
+ name: 'discard',
+ },
);
me.advancedColumn1.push(
fieldLabel: gettext('SSD emulation'),
labelWidth: labelWidth,
name: 'ssd',
- reference: 'ssd'
+ reference: 'ssd',
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: 'IO thread',
labelWidth: labelWidth,
reference: 'iothread',
- name: 'iothread'
+ name: 'iothread',
},
{
xtype: 'numberfield',
step: 1,
fieldLabel: gettext('Read limit') + ' (MB/s)',
labelWidth: labelWidth,
- emptyText: gettext('unlimited')
+ emptyText: gettext('unlimited'),
},
{
xtype: 'numberfield',
step: 1,
fieldLabel: gettext('Write limit') + ' (MB/s)',
labelWidth: labelWidth,
- emptyText: gettext('unlimited')
+ emptyText: gettext('unlimited'),
},
{
xtype: 'proxmoxintegerfield',
step: 10,
fieldLabel: gettext('Read limit') + ' (ops/s)',
labelWidth: labelWidth,
- emptyText: gettext('unlimited')
+ emptyText: gettext('unlimited'),
},
{
xtype: 'proxmoxintegerfield',
step: 10,
fieldLabel: gettext('Write limit') + ' (ops/s)',
labelWidth: labelWidth,
- emptyText: gettext('unlimited')
- }
+ emptyText: gettext('unlimited'),
+ },
);
me.advancedColumn2.push(
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Skip replication'),
labelWidth: labelWidth,
- name: 'noreplicate'
+ name: 'noreplicate',
},
{
xtype: 'numberfield',
step: 1,
fieldLabel: gettext('Read max burst') + ' (MB)',
labelWidth: labelWidth,
- emptyText: gettext('default')
+ emptyText: gettext('default'),
},
{
xtype: 'numberfield',
step: 1,
fieldLabel: gettext('Write max burst') + ' (MB)',
labelWidth: labelWidth,
- emptyText: gettext('default')
+ emptyText: gettext('default'),
},
{
xtype: 'proxmoxintegerfield',
step: 10,
fieldLabel: gettext('Read max burst') + ' (ops)',
labelWidth: labelWidth,
- emptyText: gettext('default')
+ emptyText: gettext('default'),
},
{
xtype: 'proxmoxintegerfield',
step: 10,
fieldLabel: gettext('Write max burst') + ' (ops)',
labelWidth: labelWidth,
- emptyText: gettext('default')
- }
+ emptyText: gettext('default'),
+ },
);
me.callParent();
- }
+ },
});
Ext.define('PVE.qemu.HDEdit', {
confid: me.confid,
nodename: nodename,
unused: unused,
- isCreate: me.isCreate
+ isCreate: me.isCreate,
});
var subject;
ipanel.setDrive(drive);
me.isValid(); // trigger validation
}
- }
+ },
});
- }
+ },
});
name: 'efidisk0',
storageContent: 'images',
nodename: me.nodename,
- hideSize: true
+ hideSize: true,
},
{
xtype: 'label',
];
me.callParent();
- }
+ },
});
Ext.define('PVE.qemu.EFIDiskEdit', {
}];
me.callParent();
- }
+ },
});
success: function(response, options) {
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskViewer', {
- upid: upid
+ upid: upid,
});
win.show();
win.on('destroy', function() { me.close(); });
- }
+ },
});
},
value: me.disk,
fieldLabel: qemu ? gettext('Disk') : gettext('Mount Point'),
vtype: 'StorageId',
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
items.push({
storageLabel: gettext('Target Storage'),
nodename: me.nodename,
storageContent: qemu ? 'images' : 'rootdir',
- hideSize: true
+ hideSize: true,
});
items.push({
fieldLabel: gettext('Delete source'),
name: 'deleteDisk',
uncheckedValue: 0,
- checked: false
+ checked: false,
});
me.formPanel = Ext.create('Ext.form.Panel', {
border: false,
fieldDefaults: {
labelWidth: 100,
- anchor: '100%'
+ anchor: '100%',
},
- items: items
+ items: items,
});
var form = me.formPanel.getForm();
me.move_disk(me.disk, values.hdstorage, values.diskformat,
values.deleteDisk);
}
- }
+ },
});
Ext.apply(me, {
border: false,
layout: 'fit',
buttons: [ submitBtn ],
- items: [ me.formPanel ]
+ items: [ me.formPanel ],
});
});
me.formPanel.isValid();
- }
+ },
});
},
success: function(response, options) {
me.close();
- }
+ },
});
},
value: me.disk,
fieldLabel: gettext('Disk'),
vtype: 'StorageId',
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
me.hdsizesel = Ext.createWidget('numberfield', {
decimalPrecision: 3,
value: '0',
fieldLabel: gettext('Size Increment') + ' (GiB)',
- allowBlank: false
+ allowBlank: false,
});
items.push(me.hdsizesel);
border: false,
fieldDefaults: {
labelWidth: 140,
- anchor: '100%'
+ anchor: '100%',
},
- items: items
+ items: items,
});
var form = me.formPanel.getForm();
var values = form.getValues();
me.resize_disk(me.disk, values.size);
}
- }
+ },
});
Ext.apply(me, {
border: false,
layout: 'fit',
buttons: [ submitBtn ],
- items: [ me.formPanel ]
+ items: [ me.formPanel ],
});
return;
}
- }
+ },
});
res += ' [balloon=0]';
}
return res;
- }
+ },
},
sockets: {
header: gettext('Processors'),
}
return res;
- }
+ },
},
bios: {
header: 'BIOS',
editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.BiosEdit' : undefined,
defaultValue: '',
iconCls: 'microchip',
- renderer: PVE.Utils.render_qemu_bios
+ renderer: PVE.Utils.render_qemu_bios,
},
vga: {
header: gettext('Display'),
iconCls: 'desktop',
group:5,
defaultValue: '',
- renderer: PVE.Utils.render_kvm_vga_driver
+ renderer: PVE.Utils.render_kvm_vga_driver,
},
machine: {
header: gettext('Machine'),
fieldLabel: gettext('Machine'),
comboItems: [
['__default__', PVE.Utils.render_qemu_machine('')],
- ['q35', 'q35']
- ]
+ ['q35', 'q35'],
+ ],
}]} : undefined,
iconCls: 'cogs',
never_delete: true,
group: 6,
defaultValue: '',
- renderer: PVE.Utils.render_qemu_machine
+ renderer: PVE.Utils.render_qemu_machine,
},
scsihw: {
header: gettext('SCSI Controller'),
renderer: PVE.Utils.render_scsihw,
group: 7,
never_delete: true,
- defaultValue: ''
+ defaultValue: '',
},
vmstate: {
header: gettext('Hibernation VM State'),
group: 100,
},
cores: {
- visible: false
+ visible: false,
},
cpu: {
- visible: false
+ visible: false,
},
numa: {
- visible: false
+ visible: false,
},
balloon: {
- visible: false
+ visible: false,
},
hotplug: {
- visible: false
+ visible: false,
},
vcpus: {
- visible: false
+ visible: false,
},
cpuunits: {
- visible: false
+ visible: false,
},
cpulimit: {
- visible: false
+ visible: false,
},
shares: {
- visible: false
- }
+ visible: false,
+ },
};
PVE.Utils.forEachBus(undefined, function(type, id) {
isOnStorageBus: true,
header: gettext('Hard Disk') + ' (' + confid +')',
cdheader: gettext('CD/DVD Drive') + ' (' + confid +')',
- cloudheader: gettext('CloudInit Drive') + ' (' + confid + ')'
+ cloudheader: gettext('CloudInit Drive') + ' (' + confid + ')',
};
});
for (i = 0; i < PVE.Utils.hardware_counts.net; i++) {
iconCls: 'exchange',
editor: caps.vms['VM.Config.Network'] ? 'PVE.qemu.NetworkEdit' : undefined,
never_delete: caps.vms['VM.Config.Network'] ? false : true,
- header: gettext('Network Device') + ' (' + confid +')'
+ header: gettext('Network Device') + ' (' + confid +')',
};
}
rows.efidisk0 = {
iconCls: 'hdd-o',
editor: null,
never_delete: caps.vms['VM.Config.Disk'] ? false : true,
- header: gettext('EFI Disk')
+ header: gettext('EFI Disk'),
};
for (i = 0; i < PVE.Utils.hardware_counts.usb; i++) {
confid = "usb" + i.toString();
iconCls: 'usb',
editor: caps.nodes['Sys.Console'] ? 'PVE.qemu.USBEdit' : undefined,
never_delete: caps.nodes['Sys.Console'] ? false : true,
- header: gettext('USB Device') + ' (' + confid + ')'
+ header: gettext('USB Device') + ' (' + confid + ')',
};
}
for (i = 0; i < PVE.Utils.hardware_counts.hostpci; i++) {
tdCls: 'pve-itype-icon-pci',
never_delete: caps.nodes['Sys.Console'] ? false : true,
editor: caps.nodes['Sys.Console'] ? 'PVE.qemu.PCIEdit' : undefined,
- header: gettext('PCI Device') + ' (' + confid + ')'
+ header: gettext('PCI Device') + ' (' + confid + ')',
};
}
for (i = 0; i < PVE.Utils.hardware_counts.serial; i++) {
order: i,
tdCls: 'pve-itype-icon-serial',
never_delete: caps.nodes['Sys.Console'] ? false : true,
- header: gettext('Serial Port') + ' (' + confid + ')'
+ header: gettext('Serial Port') + ' (' + confid + ')',
};
}
rows.audio0 = {
iconCls: 'volume-up',
editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.AudioEdit' : undefined,
never_delete: caps.vms['VM.Config.HWType'] ? false : true,
- header: gettext('Audio Device')
+ header: gettext('Audio Device'),
};
for (i = 0; i < 256; i++) {
rows["unused" + i.toString()] = {
iconCls: 'hdd-o',
del_extra_msg: gettext('This will permanently erase all data.'),
editor: caps.vms['VM.Config.Disk'] ? 'PVE.qemu.HDEdit' : undefined,
- header: gettext('Unused Disk') + ' ' + i.toString()
+ header: gettext('Unused Disk') + ' ' + i.toString(),
};
}
rows.rng0 = {
tdCls: 'pve-itype-icon-die',
editor: caps.nodes['Sys.Console'] ? 'PVE.qemu.RNGEdit' : undefined,
never_delete: caps.nodes['Sys.Console'] ? false : true,
- header: gettext("VirtIO RNG")
+ header: gettext("VirtIO RNG"),
};
var sorterFn = function(rec1, rec2) {
win = Ext.create(editor, {
pveSelNode: me.pveSelNode,
confid: rec.data.key,
- url: '/api2/extjs/' + baseurl
+ url: '/api2/extjs/' + baseurl,
});
} else {
var config = Ext.apply({
pveSelNode: me.pveSelNode,
confid: rec.data.key,
- url: '/api2/extjs/' + baseurl
+ url: '/api2/extjs/' + baseurl,
}, rowdef.editor);
win = Ext.createWidget(rowdef.editor.xtype, config);
win.load();
var win = Ext.create('PVE.window.HDResize', {
disk: rec.data.key,
nodename: nodename,
- vmid: vmid
+ vmid: vmid,
});
win.show();
var win = Ext.create('PVE.window.HDMove', {
disk: rec.data.key,
nodename: nodename,
- vmid: vmid
+ vmid: vmid,
});
win.show();
text: gettext('Edit'),
selModel: sm,
disabled: true,
- handler: run_editor
+ handler: run_editor,
});
var resize_btn = new Proxmox.button.Button({
text: gettext('Resize disk'),
selModel: sm,
disabled: true,
- handler: run_resize
+ handler: run_resize,
});
var move_btn = new Proxmox.button.Button({
text: gettext('Move disk'),
selModel: sm,
disabled: true,
- handler: run_move
+ handler: run_move,
});
var remove_btn = new Proxmox.button.Button({
waitMsgTarget: me,
method: b.RESTMethod,
params: {
- 'delete': rec.data.key
+ 'delete': rec.data.key,
},
callback: () => me.reload(),
failure: function (response, opts) {
upid: upid,
listeners: {
destroy: () => me.reload(),
- }
+ },
});
win.show();
}
- }
+ },
});
},
listeners: {
var optimal = alt > def ? alt : def;
btn.setSize({ width: optimal });
- }
- }
+ },
+ },
});
var revert_btn = new PVE.button.PendingRevert({
apiurl: '/api2/extjs/' + baseurl,
});
- var efidisk_menuitem = Ext.create('Ext.menu.Item',{
+ var efidisk_menuitem = Ext.create('Ext.menu.Item', {
text: gettext('EFI Disk'),
iconCls: 'fa fa-fw fa-hdd-o black',
disabled: !caps.vms['VM.Config.Disk'],
});
win.on('destroy', me.reload, me);
win.show();
- }
+ },
});
let counts = {};
handler: function() {
var win = Ext.create('PVE.qemu.HDEdit', {
url: '/api2/extjs/' + baseurl,
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
win.on('destroy', me.reload, me);
win.show();
- }
+ },
},
{
text: gettext('CD/DVD Drive'),
handler: function() {
var win = Ext.create('PVE.qemu.CDEdit', {
url: '/api2/extjs/' + baseurl,
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
win.on('destroy', me.reload, me);
win.show();
- }
+ },
},
{
text: gettext('Network Device'),
var win = Ext.create('PVE.qemu.NetworkEdit', {
url: '/api2/extjs/' + baseurl,
pveSelNode: me.pveSelNode,
- isCreate: true
+ isCreate: true,
});
win.on('destroy', me.reload, me);
win.show();
- }
+ },
},
efidisk_menuitem,
{
handler: function() {
var win = Ext.create('PVE.qemu.USBEdit', {
url: '/api2/extjs/' + baseurl,
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
win.on('destroy', me.reload, me);
win.show();
- }
+ },
},
{
text: gettext('PCI Device'),
handler: function() {
var win = Ext.create('PVE.qemu.PCIEdit', {
url: '/api2/extjs/' + baseurl,
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
win.on('destroy', me.reload, me);
win.show();
- }
+ },
},
{
text: gettext('Serial Port'),
disabled: !caps.vms['VM.Config.Options'],
handler: function() {
var win = Ext.create('PVE.qemu.SerialEdit', {
- url: '/api2/extjs/' + baseurl
+ url: '/api2/extjs/' + baseurl,
});
win.on('destroy', me.reload, me);
win.show();
- }
+ },
},
{
text: gettext('CloudInit Drive'),
handler: function() {
var win = Ext.create('PVE.qemu.CIDriveEdit', {
url: '/api2/extjs/' + baseurl,
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
win.on('destroy', me.reload, me);
win.show();
- }
+ },
},
{
text: gettext('Audio Device'),
var win = Ext.create('PVE.qemu.AudioEdit', {
url: '/api2/extjs/' + baseurl,
isCreate: true,
- isAdd: true
+ isAdd: true,
});
win.on('destroy', me.reload, me);
win.show();
- }
+ },
},
{
text: gettext("VirtIO RNG"),
var win = Ext.create('PVE.qemu.RNGEdit', {
url: '/api2/extjs/' + baseurl,
isCreate: true,
- isAdd: true
+ isAdd: true,
});
win.on('destroy', me.reload, me);
win.show();
- }
- }
- ]
- })
+ },
+ },
+ ],
+ }),
},
remove_btn,
edit_btn,
resize_btn,
move_btn,
- revert_btn
+ revert_btn,
],
rows: rows,
sorterFn: sorterFn,
listeners: {
itemdblclick: run_editor,
- selectionchange: set_button_status
- }
+ selectionchange: set_button_status,
+ },
});
me.callParent();
me.on('destroy', me.rstore.stopUpdate, me.rstore);
me.mon(me.getStore(), 'datachanged', set_button_status, me);
- }
+ },
});
{
xtype: 'displayfield',
fieldLabel: gettext('Network Device'),
- value: me.netid
+ value: me.netid,
},
{
layout: {
type: 'hbox',
- align: 'middle'
+ align: 'middle',
},
border: false,
margin: '0 0 5 0',
items: [
{
xtype: 'label',
- text: gettext('IPv4') + ':'
+ text: gettext('IPv4') + ':',
},
{
xtype: 'radiofield',
change: function(cb, value) {
me.down('field[name=ip]').setDisabled(!value);
me.down('field[name=gw]').setDisabled(!value);
- }
- }
+ },
+ },
},
{
xtype: 'radiofield',
name: 'ipv4mode',
inputValue: 'dhcp',
checked: false,
- margin: '0 0 0 10'
- }
- ]
+ margin: '0 0 0 10',
+ },
+ ],
},
{
xtype: 'textfield',
vtype: 'IPCIDRAddress',
value: '',
disabled: true,
- fieldLabel: gettext('IPv4/CIDR')
+ fieldLabel: gettext('IPv4/CIDR'),
},
{
xtype: 'textfield',
value: '',
vtype: 'IPAddress',
disabled: true,
- fieldLabel: gettext('Gateway') + ' (' + gettext('IPv4') +')'
- }
+ fieldLabel: gettext('Gateway') + ' (' + gettext('IPv4') +')',
+ },
];
me.column2 = [
{
- xtype: 'displayfield'
+ xtype: 'displayfield',
},
{
layout: {
type: 'hbox',
- align: 'middle'
+ align: 'middle',
},
border: false,
margin: '0 0 5 0',
items: [
{
xtype: 'label',
- text: gettext('IPv6') + ':'
+ text: gettext('IPv6') + ':',
},
{
xtype: 'radiofield',
change: function(cb, value) {
me.down('field[name=ip6]').setDisabled(!value);
me.down('field[name=gw6]').setDisabled(!value);
- }
- }
+ },
+ },
},
{
xtype: 'radiofield',
name: 'ipv6mode',
inputValue: 'dhcp',
checked: false,
- margin: '0 0 0 10'
- }
- ]
+ margin: '0 0 0 10',
+ },
+ ],
},
{
xtype: 'textfield',
value: '',
vtype: 'IP6CIDRAddress',
disabled: true,
- fieldLabel: gettext('IPv6/CIDR')
+ fieldLabel: gettext('IPv6/CIDR'),
},
{
xtype: 'textfield',
vtype: 'IP6Address',
value: '',
disabled: true,
- fieldLabel: gettext('Gateway') + ' (' + gettext('IPv6') +')'
- }
+ fieldLabel: gettext('Gateway') + ' (' + gettext('IPv6') +')',
+ },
];
me.callParent();
- }
+ },
});
Ext.define('PVE.qemu.IPConfigEdit', {
var ipanel = Ext.create('PVE.qemu.IPConfigPanel', {
confid: me.confid,
netid: me.netid,
- nodename: nodename
+ nodename: nodename,
});
Ext.applyIf(me, {
subject: gettext('Network Config'),
- items: ipanel
+ items: ipanel,
});
me.callParent();
}
ipanel.setIPConfig(me.confid, ipconfig);
ipanel.setVMConfig(me.vmconfig);
- }
+ },
});
- }
+ },
});
xtype: 'VNCKeyboardSelector',
name: 'keyboard',
value: '__default__',
- fieldLabel: gettext('Keyboard Layout')
- }
+ fieldLabel: gettext('Keyboard Layout'),
+ },
});
me.callParent();
me.load();
- }
+ },
});
bf.setValue(value);
}
bf.validate();
- }
- }
- }
+ },
+ },
+ },
];
me.advancedItems= [
var memory = me.down('field[name=memory]').getValue();
var shares = me.down('field[name=shares]');
shares.setDisabled(value === memory);
- }
- }
+ },
+ },
},
{
xtype: 'proxmoxintegerfield',
labelWidth: labelWidth,
allowBlank: true,
emptyText: Proxmox.Utils.defaultText + ' (1000)',
- submitEmptyText: false
+ submitEmptyText: false,
},
{
xtype: 'proxmoxcheckbox',
var memory = me.down('field[name=memory]');
bf.setDisabled(!value);
shares.setDisabled(!value || (bf.getValue() === memory.getValue()));
- }
- }
- }
+ },
+ },
+ },
];
if (me.insideWizard) {
me.advancedItems = undefined;
}
me.callParent();
- }
+ },
});
}
var ipanel = Ext.create('PVE.qemu.MemoryInputPanel', {
- hotplug: memoryhotplug
+ hotplug: memoryhotplug,
});
Ext.apply(me, {
items: [ ipanel ],
// uncomment the following to use the async configiguration API
// backgroundDelay: 5,
- width: 400
+ width: 400,
});
me.callParent();
ballooning: data.balloon === 0 ? '0' : '1',
shares: data.shares,
memory: data.memory || '512',
- balloon: data.balloon > 0 ? data.balloon : (data.memory || '512')
+ balloon: data.balloon > 0 ? data.balloon : (data.memory || '512'),
};
ipanel.setValues(values);
- }
+ },
});
- }
+ },
});
autoScroll: true,
border: true,
margins: '5 5 5 5',
- bodyStyle: 'font-family: monospace;'
+ bodyStyle: 'font-family: monospace;',
});
var scrollToEnd = function() {
},
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
- }
+ },
});
};
default:
break;
}
- }
- }
- }
+ },
+ },
+ },
],
listeners: {
show: function() {
var field = me.query('textfield[name="cmd"]')[0];
field.focus(false, true);
- }
- }
+ },
+ },
});
me.callParent();
- }
+ },
});
fieldLabel: gettext('Bridge'),
nodename: me.nodename,
autoSelect: true,
- allowBlank: false
+ allowBlank: false,
});
me.column1 = [
{
xtype: 'pveVlanField',
name: 'tag',
- value: ''
+ value: '',
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Firewall'),
name: 'firewall',
- checked: (me.insideWizard || me.isCreate)
- }
+ checked: (me.insideWizard || me.isCreate),
+ },
];
me.advancedColumn1 = [
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Disconnect'),
- name: 'disconnect'
- }
+ name: 'disconnect',
+ },
];
if (me.insideWizard) {
'model',
'macaddr',
'rate',
- 'queues'
+ 'queues',
];
fields.forEach(function(fieldname) {
me.down('field[name='+fieldname+']').setDisabled(value);
});
me.down('field[name=bridge]').validate();
- }
- }
+ },
+ },
});
me.column2.unshift({
- xtype: 'displayfield'
+ xtype: 'displayfield',
});
}
name: 'model',
fieldLabel: gettext('Model'),
value: PVE.qemu.OSDefaults.generic.networkCard,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
fieldLabel: gettext('MAC address'),
vtype: 'MacAddress',
allowBlank: true,
- emptyText: 'auto'
+ emptyText: 'auto',
});
me.advancedColumn2 = [
{
maxValue: 10*1024,
value: '',
emptyText: 'unlimited',
- allowBlank: true
+ allowBlank: true,
},
{
xtype: 'proxmoxintegerfield',
minValue: 1,
maxValue: 8,
value: '',
- allowBlank: true
- }
+ allowBlank: true,
+ },
];
me.callParent();
- }
+ },
});
Ext.define('PVE.qemu.NetworkEdit', {
var ipanel = Ext.create('PVE.qemu.NetworkInputPanel', {
confid: me.confid,
nodename: nodename,
- isCreate: me.isCreate
+ isCreate: me.isCreate,
});
Ext.applyIf(me, {
subject: gettext('Network Device'),
- items: ipanel
+ items: ipanel,
});
me.callParent();
ipanel.setNetwork(me.confid, data);
}
- }
+ },
});
- }
+ },
});
ide: 4,
sata: 3,
scsi: 2,
- virtio: 1
+ virtio: 1,
},
- scsihw: 'virtio-scsi-pci'
+ scsihw: 'virtio-scsi-pci',
};
// virtio-net is in kernel since 2.6.25
scsi: 4,
virtio: 3,
sata: 2,
- ide: 1
+ ide: 1,
},
- networkCard: 'virtio'
+ networkCard: 'virtio',
});
// recommandation from http://wiki.qemu.org/Windows2000
pveOS: 'w2k',
parent : 'generic',
networkCard: 'rtl8139',
- scsihw: ''
+ scsihw: '',
});
// https://pve.proxmox.com/wiki/Windows_XP_Guest_Notes
addOS({
pveOS: 'wxp',
- parent : 'w2k'
+ parent : 'w2k',
});
me.getDefaults = function(ostype) {
return PVE.qemu.OSDefaults.generic;
}
};
- }
+ },
});
xclass: 'Ext.app.ViewController',
control: {
'combobox[name=osbase]': {
- change: 'onOSBaseChange'
+ change: 'onOSBaseChange',
},
'combobox[name=ostype]': {
afterrender: 'onOSTypeChange',
- change: 'onOSTypeChange'
- }
+ change: 'onOSTypeChange',
+ },
},
onOSBaseChange: function(field, value) {
this.lookup('ostype').getStore().setData(PVE.Utils.kvm_ostypes[value]);
} else {
throw 'non unique widget :' + widget + ' in Wizard';
}
- }
+ },
},
initComponent : function() {
{
xtype: 'displayfield',
value: gettext('Guest OS') + ':',
- hidden: !me.insideWizard
+ hidden: !me.insideWizard,
},
{
xtype: 'combobox',
editable: false,
queryMode: 'local',
value: 'Linux',
- store: Object.keys(PVE.Utils.kvm_ostypes)
+ store: Object.keys(PVE.Utils.kvm_ostypes),
},
{
xtype: 'combobox',
} else {
ostype.setValue(store.getAt(0));
}
- }
- }
- }
- }
+ },
+ },
+ },
+ },
];
me.callParent();
- }
+ },
});
Ext.define('PVE.qemu.OSTypeEdit', {
var value = response.result.data.ostype || 'other';
var osinfo = PVE.Utils.get_kvm_osinfo(value);
me.setValues({ ostype: value, osbase: osinfo.base });
- }
+ },
});
- }
+ },
});
vtype: 'DnsName',
value: '',
fieldLabel: gettext('Name'),
- allowBlank: true
+ allowBlank: true,
},
onGetValues: function(values) {
var params = values;
params = { 'delete':'name'};
}
return params;
- }
- }
- } : undefined
+ },
+ },
+ } : undefined,
},
onboot: {
header: gettext('Start at boot'),
uncheckedValue: 0,
defaultValue: 0,
deleteDefaultValue: true,
- fieldLabel: gettext('Start at boot')
- }
- } : undefined
+ fieldLabel: gettext('Start at boot'),
+ },
+ } : undefined,
},
startup: {
header: gettext('Start/Shutdown order'),
editor: caps.vms['VM.Config.Options'] && caps.nodes['Sys.Modify'] ?
{
xtype: 'pveWindowStartupEdit',
- onlineHelp: 'qm_startup_and_shutdown'
- } : undefined
+ onlineHelp: 'qm_startup_and_shutdown',
+ } : undefined,
},
ostype: {
header: gettext('OS Type'),
editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.OSTypeEdit' : undefined,
renderer: PVE.Utils.render_kvm_ostype,
- defaultValue: 'other'
+ defaultValue: 'other',
},
bootdisk: {
- visible: false
+ visible: false,
},
boot: {
header: gettext('Boot Order'),
}
}
return text;
- }
+ },
},
tablet: {
header: gettext('Use tablet for pointer'),
uncheckedValue: 0,
defaultValue: 1,
deleteDefaultValue: true,
- fieldLabel: gettext('Enabled')
- }
- } : undefined
+ fieldLabel: gettext('Enabled'),
+ },
+ } : undefined,
},
hotplug: {
header: gettext('Hotplug'),
value: '',
multiSelect: true,
fieldLabel: gettext('Hotplug'),
- allowBlank: true
- }
- } : undefined
+ allowBlank: true,
+ },
+ } : undefined,
},
acpi: {
header: gettext('ACPI support'),
uncheckedValue: 0,
defaultValue: 1,
deleteDefaultValue: true,
- fieldLabel: gettext('Enabled')
- }
- } : undefined
+ fieldLabel: gettext('Enabled'),
+ },
+ } : undefined,
},
kvm: {
header: gettext('KVM hardware virtualization'),
uncheckedValue: 0,
defaultValue: 1,
deleteDefaultValue: true,
- fieldLabel: gettext('Enabled')
- }
- } : undefined
+ fieldLabel: gettext('Enabled'),
+ },
+ } : undefined,
},
freeze: {
header: gettext('Freeze CPU at startup'),
defaultValue: 0,
deleteDefaultValue: true,
labelWidth: 140,
- fieldLabel: gettext('Freeze CPU at startup')
- }
- } : undefined
+ fieldLabel: gettext('Freeze CPU at startup'),
+ },
+ } : undefined,
},
localtime: {
header: gettext('Use local time for RTC'),
[0, PVE.Utils.render_localtime(0)],
],
labelWidth: 140,
- fieldLabel: gettext('Use local time for RTC')
- }
- } : undefined
+ fieldLabel: gettext('Use local time for RTC'),
+ },
+ } : undefined,
},
startdate: {
header: gettext('RTC start date'),
value: 'now',
fieldLabel: gettext('RTC start date'),
vtype: 'QemuStartDate',
- allowBlank: true
- }
- } : undefined
+ allowBlank: true,
+ },
+ } : undefined,
},
smbios1: {
header: gettext('SMBIOS settings (type1)'),
defaultValue: '',
renderer: Ext.String.htmlEncode,
- editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.Smbios1Edit' : undefined
+ editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.Smbios1Edit' : undefined,
},
agent: {
header: 'QEMU Guest Agent',
width: 350,
items: {
xtype: 'pveAgentFeatureSelector',
- name: 'agent'
- }
- } : undefined
+ name: 'agent',
+ },
+ } : undefined,
},
protection: {
header: gettext('Protection'),
uncheckedValue: 0,
defaultValue: 0,
deleteDefaultValue: true,
- fieldLabel: gettext('Enabled')
- }
- } : undefined
+ fieldLabel: gettext('Enabled'),
+ },
+ } : undefined,
},
spice_enhancements: {
header: gettext('Spice Enhancements'),
items: {
xtype: 'pveSpiceEnhancementSelector',
name: 'spice_enhancements',
- }
- } : undefined
+ },
+ } : undefined,
},
vmstatestorage: {
header: gettext('VM State storage'),
skipEmptyText: true,
nodename: nodename,
name: 'vmstatestorage',
- }
- } : undefined
+ },
+ } : undefined,
},
hookscript: {
- header: gettext('Hookscript')
- }
+ header: gettext('Hookscript'),
+ },
};
var baseurl = 'nodes/' + nodename + '/qemu/' + vmid + '/config';
var edit_btn = new Ext.Button({
text: gettext('Edit'),
disabled: true,
- handler: function() { me.run_editor(); }
+ handler: function() { me.run_editor(); },
});
var revert_btn = new PVE.button.PendingRevert();
tbar: [ edit_btn, revert_btn ],
rows: rows,
editorConfig: {
- url: "/api2/extjs/" + baseurl
+ url: "/api2/extjs/" + baseurl,
},
listeners: {
itemdblclick: me.run_editor,
- selectionchange: set_button_status
- }
+ selectionchange: set_button_status,
+ },
});
me.callParent();
me.mon(me.getStore(), 'datachanged', function() {
set_button_status();
});
- }
+ },
});
}
}
// remove optional '0000' domain
- if (values.host.substring(0,5) === '0000:') {
+ if (values.host.substring(0, 5) === '0000:') {
values.host = values.host.substring(5);
}
if (values.multifunction) {
padding: '0 0 10 0',
value: 'No IOMMU detected, please activate it.' +
'See Documentation for further information.',
- userCls: 'pmx-hint'
+ userCls: 'pmx-hint',
});
me.items.insert(0, warning);
me.updateLayout(); // insert does not trigger that
if (!pcidev) {
return;
}
- var id = pcidev.data.id.substring(0,5); // 00:00
+ var id = pcidev.data.id.substring(0, 5); // 00:00
var iommu = pcidev.data.iommugroup;
// try to find out if there are more devices
// in that iommu group
var count = 0;
pcisel.getStore().each(function(record) {
if (record.data.iommugroup === iommu &&
- record.data.id.substring(0,5) !== id)
+ record.data.id.substring(0, 5) !== id)
{
count++;
return false;
itemId: 'iommuwarning',
value: 'The selected Device is not in a seperate' +
'IOMMU group, make sure this is intended.',
- userCls: 'pmx-hint'
+ userCls: 'pmx-hint',
});
me.items.insert(0, warning);
me.updateLayout(); // insert does not trigger that
if (pcidev.data.mdev) {
mdevfield.setPciID(value);
}
- }
- }
+ },
+ },
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('All Functions'),
- name: 'multifunction'
- }
+ name: 'multifunction',
+ },
];
me.column2 = [
mf.setValue(false);
}
mf.setDisabled(!!value);
- }
- }
+ },
+ },
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Primary GPU'),
- name: 'x-vga'
- }
+ name: 'x-vga',
+ },
];
me.advancedColumn1 = [
{
xtype: 'proxmoxcheckbox',
fieldLabel: 'ROM-Bar',
- name: 'rombar'
+ name: 'rombar',
},
{
xtype: 'displayfield',
submitValue: true,
hidden: true,
fieldLabel: 'ROM-File',
- name: 'romfile'
- }
+ name: 'romfile',
+ },
];
me.advancedColumn2 = [
{
xtype: 'proxmoxcheckbox',
fieldLabel: 'PCI-Express',
- name: 'pcie'
- }
+ name: 'pcie',
+ },
];
me.callParent();
- }
+ },
});
Ext.define('PVE.qemu.PCIEdit', {
var ipanel = Ext.create('PVE.qemu.PCIInputPanel', {
confid: me.confid,
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
Ext.apply(me, {
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
me.load({
success: function(response) {
ipanel.setVMConfig(response.result.data);
- }
+ },
});
- }
+ },
});
xtype: 'CPUModelSelector',
name: 'cputype',
reference: 'cputype',
- fieldLabel: gettext('Type')
+ fieldLabel: gettext('Type'),
},
{
xtype: 'displayfield',
step: 1,
fieldLabel: gettext('CPU limit'),
allowBlank: true,
- emptyText: gettext('unlimited')
- }
+ emptyText: gettext('unlimited'),
+ },
],
advancedColumn2: [
maxValue: 500000,
value: '1024',
deleteEmpty: true,
- allowBlank: true
+ allowBlank: true,
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Enable NUMA'),
name: 'numa',
- uncheckedValue: 0
- }
+ uncheckedValue: 0,
+ },
],
advancedColumnB: [
{
xtype: 'label',
- text: 'Extra CPU Flags:'
+ text: 'Extra CPU Flags:',
},
{
xtype: 'vmcpuflagselector',
- name: 'flags'
- }
- ]
+ name: 'flags',
+ },
+ ],
});
Ext.define('PVE.qemu.ProcessorEdit', {
Ext.apply(me, {
subject: gettext('Processors'),
- items: ipanel
+ items: ipanel,
});
me.callParent();
}
}
me.setValues(data);
- }
+ },
});
- }
+ },
});
var ret = PVE.Parser.printPropertyString(values);
return {
- rng0: ret
+ rng0: ret,
};
},
change: function(el, newVal) {
let limitWarning = this.lookupReference('limitWarning');
limitWarning.setHidden(!!newVal);
- }
+ },
},
'#source': {
change: function(el, newVal) {
let limitWarning = this.lookupReference('sourceWarning');
limitWarning.setHidden(newVal !== '/dev/random');
- }
- }
- }
+ },
+ },
+ },
},
items: [{
comboItems: [
['/dev/urandom', '/dev/urandom'],
['/dev/random', '/dev/random'],
- ['/dev/hwrng', '/dev/hwrng']
- ]
+ ['/dev/hwrng', '/dev/hwrng'],
+ ],
},
{
xtype: 'numberfield',
value: 1024,
fieldLabel: gettext('Limit (Bytes/Period)'),
labelWidth: 130,
- emptyText: gettext('unlimited')
+ emptyText: gettext('unlimited'),
},
{
xtype: 'numberfield',
reference: 'sourceWarning',
value: gettext('Using /dev/random as entropy source is discouraged, as it can lead to host entropy starvation. /dev/urandom is preferred, and does not lead to a decrease in security in practice.'),
userCls: 'pmx-hint',
- hidden: true
+ hidden: true,
},
{
xtype: 'displayfield',
reference: 'limitWarning',
value: gettext('Disabling the limiter can potentially allow a guest to overload the host. Proceed with caution.'),
userCls: 'pmx-hint',
- hidden: true
- }]
+ hidden: true,
+ }],
});
Ext.define('PVE.qemu.RNGEdit', {
subject: gettext('VirtIO RNG'),
items: [{
- xtype: 'pveRNGInputPanel'
+ xtype: 'pveRNGInputPanel',
}],
initComponent : function() {
if (rng0) {
me.setValues(PVE.Parser.parsePropertyString(rng0));
}
- }
+ },
});
}
- }
+ },
});
xtype: 'textarea',
itemId: 'sshkeys',
name: 'sshkeys',
- height: 250
+ height: 250,
},
{
xtype: 'filebutton',
});
});
btn.reset();
- }
- }
- }
+ },
+ },
+ },
],
initComponent: function() {
me.down('#filebutton').setVisible(false);
}
- }
+ },
});
Ext.define('PVE.qemu.SSHKeyEdit', {
Ext.apply(me, {
subject: gettext('SSH Keys'),
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
data.sshkeys = decodeURIComponent(data.sshkeys);
ipanel.setValues(data);
}
- }
+ },
});
}
- }
+ },
});
xtype: 'pveScsiHwSelector',
name: 'scsihw',
value: '__default__',
- fieldLabel: gettext('Type')
- }
+ fieldLabel: gettext('Type'),
+ },
});
me.callParent();
me.load();
- }
+ },
});
return "This device is already in use.";
}
return true;
- }
- }
- ]
+ },
+ },
+ ],
});
Ext.define('PVE.qemu.SerialEdit', {
var ipanel = Ext.create('PVE.qemu.SerialnputPanel', {});
Ext.apply(me, {
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
me.load({
success: function(response, options) {
ipanel.setVMConfig(response.result.data);
- }
+ },
});
- }
+ },
});
var me = this;
var params = {
- smbios1: PVE.Parser.printQemuSmbios1(values)
+ smbios1: PVE.Parser.printQemuSmbios1(values),
};
return params;
xtype: 'textfield',
fieldLabel: 'UUID',
regex: /^[a-fA-F0-9]{8}(?:-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}$/,
- name: 'uuid'
+ name: 'uuid',
},
{
xtype: 'textareafield',
fieldLabel: gettext('Manufacturer'),
fieldStyle: {
height: '2em',
- minHeight: '2em'
+ minHeight: '2em',
},
- name: 'manufacturer'
+ name: 'manufacturer',
},
{
xtype: 'textareafield',
fieldLabel: gettext('Product'),
fieldStyle: {
height: '2em',
- minHeight: '2em'
+ minHeight: '2em',
},
- name: 'product'
+ name: 'product',
},
{
xtype: 'textareafield',
fieldLabel: gettext('Version'),
fieldStyle: {
height: '2em',
- minHeight: '2em'
+ minHeight: '2em',
},
- name: 'version'
+ name: 'version',
},
{
xtype: 'textareafield',
fieldLabel: gettext('Serial'),
fieldStyle: {
height: '2em',
- minHeight: '2em'
+ minHeight: '2em',
},
- name: 'serial'
+ name: 'serial',
},
{
xtype: 'textareafield',
fieldLabel: 'SKU',
fieldStyle: {
height: '2em',
- minHeight: '2em'
+ minHeight: '2em',
},
- name: 'sku'
+ name: 'sku',
},
{
xtype: 'textareafield',
fieldLabel: gettext('Family'),
fieldStyle: {
height: '2em',
- minHeight: '2em'
+ minHeight: '2em',
},
- name: 'family'
- }
- ]
+ name: 'family',
+ },
+ ],
});
Ext.define('PVE.qemu.Smbios1Edit', {
Ext.applyIf(me, {
subject: gettext('SMBIOS settings (type1)'),
width: 450,
- items: ipanel
+ items: ipanel,
});
me.callParent();
}
ipanel.setSmbios1(data);
}
- }
+ },
});
- }
+ },
});
viewModel: {
data: {
efi: false,
- addefi: true
+ addefi: true,
},
formulas: {
efidisk: function(get) {
return get('efi') && get('addefi');
- }
- }
+ },
+ },
},
onGetValues: function(values) {
- if (values.vga && values.vga.substr(0,6) === 'serial') {
- values['serial' + values.vga.substr(6,1)] = 'socket';
+ if (values.vga && values.vga.substr(0, 6) === 'serial') {
+ values['serial' + values.vga.substr(6, 1)] = 'socket';
}
var efidrive = {};
control: {
'pveScsiHwSelector': {
- change: 'scsihwChange'
+ change: 'scsihwChange',
},
'pveQemuBiosSelector': {
- change: 'biosChange'
- }
- }
+ change: 'biosChange',
+ },
+ },
},
column1: [
deleteEmpty: false,
fieldLabel: gettext('Graphic card'),
name: 'vga',
- comboItems: PVE.Utils.kvm_vga_driver_array()
+ comboItems: PVE.Utils.kvm_vga_driver_array(),
},
{
xtype: 'proxmoxcheckbox',
uncheckedValue: 0,
defaultValue: 0,
deleteDefaultValue: true,
- fieldLabel: gettext('Qemu Agent')
- }
+ fieldLabel: gettext('Qemu Agent'),
+ },
],
column2: [
name: 'scsihw',
value: '__default__',
bind: {
- value: '{current.scsihw}'
+ value: '{current.scsihw}',
},
- fieldLabel: gettext('SCSI Controller')
- }
+ fieldLabel: gettext('SCSI Controller'),
+ },
],
advancedColumn1: [
xtype: 'pveQemuBiosSelector',
name: 'bios',
value: '__default__',
- fieldLabel: 'BIOS'
+ fieldLabel: 'BIOS',
},
{
xtype: 'proxmoxcheckbox',
bind: {
value: '{addefi}',
hidden: '{!efi}',
- disabled: '{!efi}'
+ disabled: '{!efi}',
},
hidden: true,
submitValue: false,
disabled: true,
- fieldLabel: gettext('Add EFI Disk')
+ fieldLabel: gettext('Add EFI Disk'),
},
{
xtype: 'pveDiskStorageSelector',
bind: {
nodename: '{nodename}',
hidden: '{!efi}',
- disabled: '{!efidisk}'
+ disabled: '{!efidisk}',
},
autoSelect: false,
disabled: true,
hidden: true,
- hideSize: true
- }
+ hideSize: true,
+ },
],
advancedColumn2: [
fieldLabel: gettext('Machine'),
comboItems: [
['__default__', PVE.Utils.render_qemu_machine('')],
- ['q35', 'q35']
- ]
- }
- ]
+ ['q35', 'q35'],
+ ],
+ },
+ ],
});
onlineHelp: 'qm_usb_passthrough',
viewModel: {
- data: {}
+ data: {},
},
setVMConfig: function(vmconfig) {
inputValue: 'spice',
boxLabel: gettext('Spice Port'),
submitValue: false,
- checked: true
+ checked: true,
},
{
name: 'usb',
inputValue: 'hostdevice',
boxLabel: gettext('Use USB Vendor/Device ID'),
reference: 'hostdevice',
- submitValue: false
+ submitValue: false,
},
{
xtype: 'pveUSBSelector',
inputValue: 'port',
boxLabel: gettext('Use USB Port'),
reference: 'port',
- submitValue: false
+ submitValue: false,
},
{
xtype: 'pveUSBSelector',
inputValue: true,
checked: true,
reference: 'usb3',
- fieldLabel: gettext('Use USB3')
- }
- ]
- }
- ]
+ fieldLabel: gettext('Use USB3'),
+ },
+ ],
+ },
+ ],
});
Ext.define('PVE.qemu.USBEdit', {
var ipanel = Ext.create('PVE.qemu.USBInputPanel', {
confid: me.confid,
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
Ext.apply(me, {
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
for (let i = 0; i < data.length; i++) {
if (/^(host=)?(0x)?[a-zA-Z0-9]{4}\:(0x)?[a-zA-Z0-9]{4}$/.test(data[i])) {
hostdevice = data[i];
- hostdevice = hostdevice.replace('host=', '').replace('0x','');
+ hostdevice = hostdevice.replace('host=', '').replace('0x', '');
type = 'hostdevice';
} else if (/^(host=)?(\d+)\-(\d+(\.\d+)*)$/.test(data[i])) {
port = data[i];
usb : type,
hostdevice: hostdevice,
port: port,
- usb3: usb3
+ usb3: usb3,
};
ipanel.setValues(values);
- }
+ },
});
- }
+ },
});
Ext.apply(me, {
title: Ext.String.format(gettext("Zone {0} on node {1}"),
"'" + sdnid + "'", "'" + nodename + "'"),
- hstateid: 'sdntab'
+ hstateid: 'sdntab',
});
if (caps.sdn['SDN.Audit']) {
xtype: 'pveSDNZoneContentView',
title: gettext('Content'),
iconCls: 'fa fa-th',
- itemId: 'content'
+ itemId: 'content',
});
}
title: gettext('Permissions'),
iconCls: 'fa fa-unlock',
itemId: 'permissions',
- path: '/sdn/zones/' + sdnid
+ path: '/sdn/zones/' + sdnid,
});
}
me.callParent();
- }
+ },
});
controllerid: sid,
autoShow: true,
listeners: {
- destroy: this.reloadStore
- }
+ destroy: this.reloadStore,
+ },
});
},
model: 'pve-sdn-controller',
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/sdn/controllers"
+ url: "/api2/json/cluster/sdn/controllers",
},
sorters: {
property: 'controller',
- order: 'DESC'
+ order: 'DESC',
},
});
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
var remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/cluster/sdn/controllers/',
- callback: reload
+ callback: reload,
});
// else we cannot dynamically generate the add menu handlers
addMenuItems.push({
text: PVE.Utils.format_sdncontroller_type(type),
iconCls: 'fa fa-fw fa-' + controller.faIcon,
- handler: addHandleGenerator(type)
+ handler: addHandleGenerator(type),
});
}
reloadStore: reload,
selModel: sm,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
tbar: [
{
text: gettext('Add'),
menu: new Ext.menu.Menu({
- items: addMenuItems
- })
+ items: addMenuItems,
+ }),
},
remove_btn,
edit_btn,
header: 'ID',
flex: 2,
sortable: true,
- dataIndex: 'controller'
+ dataIndex: 'controller',
},
{
header: gettext('Type'),
flex: 1,
sortable: true,
dataIndex: 'type',
- renderer: PVE.Utils.format_sdncontroller_type
+ renderer: PVE.Utils.format_sdncontroller_type,
},
],
listeners: {
activate: reload,
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
- }
+ },
});
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
initComponent: function() {
groupField: 'type',
proxy: {
type: 'proxmox',
- url: '/api2/json/cluster/resources'
- }
+ url: '/api2/json/cluster/resources',
+ },
});
me.items = [{
rstore: me.rstore,
border: 0,
collapsible: true,
- padding: '0 0 20 0'
+ padding: '0 0 20 0',
}];
me.callParent();
me.on('activate', me.rstore.startUpdate);
- }
+ },
});
var p1 = me.sortPriority[rec1.data.type];
var p2 = me.sortPriority[rec2.data.type];
return (p1 !== p2) ? ((p1 > p2) ? 1 : -1) : 0;
- }
+ },
}],
filters: {
property: 'type',
value: 'sdn',
- operator: '=='
- }
+ operator: '==',
+ },
});
Ext.apply(me, {
waitMsgTarget: me,
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
},
],
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
header: 'SDN',
width: 80,
- dataIndex: 'sdn'
+ dataIndex: 'sdn',
},
{
header: gettext('Node'),
width: 80,
- dataIndex: 'node'
+ dataIndex: 'node',
},
{
header: gettext('Status'),
width: 80,
flex: 1,
- dataIndex: 'status'
- }
- ]
+ dataIndex: 'status',
+ },
+ ],
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
- }
+ },
}, function() {
Ext.define('pve-sdn-status', {
fields: [
'id', 'type', 'node', 'status', 'sdn',
],
- idProperty: 'id'
+ idProperty: 'id',
});
});
name: 'vlanaware',
uncheckedValue: 0,
checked: false,
- fieldLabel: gettext('VLAN Aware')
+ fieldLabel: gettext('VLAN Aware'),
},
{
xtype: 'textfield',
model: 'pve-sdn-vnet',
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/sdn/vnets"
+ url: "/api2/json/cluster/sdn/vnets",
},
sorters: {
property: 'vnet',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
let reload = () => store.load();
let run_editor = function() {
let rec = sm.getSelection()[0];
- let win = Ext.create('PVE.sdn.VnetEdit',{
+ let win = Ext.create('PVE.sdn.VnetEdit', {
autoShow: true,
onlineHelp: 'pvesdn_config_vnet',
vnet: rec.data.vnet,
let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/cluster/sdn/vnets/',
- callback: reload
+ callback: reload,
});
Ext.apply(me, {
reloadStore: reload,
selModel: sm,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
tbar: [
{
type: 'vnet',
});
win.on('destroy', reload);
- }
+ },
},
remove_btn,
edit_btn,
{
header: 'ID',
flex: 2,
- dataIndex: 'vnet'
+ dataIndex: 'vnet',
},
{
header: gettext('Alias'),
header: 'MAC',
flex: 1,
dataIndex: 'mac',
- }
+ },
],
listeners: {
activate: reload,
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
- }
+ },
}, function() {
Ext.define('pve-sdn-vnet', {
'vnet',
'zone',
],
- idProperty: 'vnet'
+ idProperty: 'vnet',
});
});
stateId: 'grid-sdnzone-content',
viewConfig: {
trackOver: false,
- loadMask: false
+ loadMask: false,
},
features: [
{
ftype: 'grouping',
- groupHeaderTpl: '{name} ({rows.length} Item{[values.rows.length > 1 ? "s" : ""]})'
- }
+ groupHeaderTpl: '{name} ({rows.length} Item{[values.rows.length > 1 ? "s" : ""]})',
+ },
],
initComponent : function() {
var me = this;
}
var baseurl = "/nodes/" + nodename + "/sdn/zones/" + zone + "/content";
- var store = Ext.create('Ext.data.Store',{
+ var store = Ext.create('Ext.data.Store', {
model: 'pve-sdnzone-content',
groupField: 'content',
proxy: {
type: 'proxmox',
- url: '/api2/json' + baseurl
+ url: '/api2/json' + baseurl,
},
sorters: {
property: 'vnet',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var sm = Ext.create('Ext.selection.RowModel', {});
header: 'VNet',
flex: 1,
sortable: true,
- dataIndex: 'vnet'
+ dataIndex: 'vnet',
},
{
header: gettext('Status'),
},
],
listeners: {
- activate: reload
- }
+ activate: reload,
+ },
});
me.callParent();
- }
+ },
}, function() {
Ext.define('pve-sdnzone-content', {
return value;
}
return PVE.Utils.format_sdnvnet_type(value, {}, record);
- }
- }
+ },
+ },
],
- idProperty: 'vnet'
+ idProperty: 'vnet',
});
});
zone: sid,
autoShow: true,
listeners: {
- destroy: this.reloadStore
- }
+ destroy: this.reloadStore,
+ },
});
},
model: 'pve-sdn-zone',
proxy: {
type: 'proxmox',
- url: "/api2/json/cluster/sdn/zones"
+ url: "/api2/json/cluster/sdn/zones",
},
sorters: {
property: 'zone',
- order: 'DESC'
+ order: 'DESC',
},
});
text: gettext('Edit'),
disabled: true,
selModel: sm,
- handler: run_editor
+ handler: run_editor,
});
let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
selModel: sm,
baseurl: '/cluster/sdn/zones/',
- callback: reload
+ callback: reload,
});
// else we cannot dynamically generate the add menu handlers
addMenuItems.push({
text: PVE.Utils.format_sdnzone_type(type),
iconCls: 'fa fa-fw fa-' + zone.faIcon,
- handler: addHandleGenerator(type)
+ handler: addHandleGenerator(type),
});
}
reloadStore: reload,
selModel: sm,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
tbar: [
{
text: gettext('Add'),
menu: new Ext.menu.Menu({
- items: addMenuItems
- })
+ items: addMenuItems,
+ }),
},
remove_btn,
edit_btn,
{
header: 'ID',
flex: 2,
- dataIndex: 'zone'
+ dataIndex: 'zone',
},
{
header: gettext('Type'),
flex: 1,
dataIndex: 'type',
- renderer: PVE.Utils.format_sdnzone_type
+ renderer: PVE.Utils.format_sdnzone_type,
},
{
header: 'MTU',
],
listeners: {
activate: reload,
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
- }
+ },
});
var ipanel = Ext.create(me.paneltype, {
type: me.type,
isCreate: me.isCreate,
- controllerid: me.controllerid
+ controllerid: me.controllerid,
});
Ext.apply(me, {
subject: PVE.Utils.format_sdncontroller_type(me.type),
isAdd: true,
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
values.enable = values.disable ? 0 : 1;
ipanel.setValues(values);
- }
+ },
});
}
- }
+ },
});
maxLength: 8,
value: me.controllerid || '',
fieldLabel: 'ID',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
maxValue: 4294967295,
value: 65000,
fieldLabel: 'ASN #',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
name: 'peers',
fieldLabel: gettext('Peers'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
name: 'gateway-external-peers',
fieldLabel: gettext('External Gateway Peers'),
- allowBlank: true
+ allowBlank: true,
},
{
xtype: 'pveNodeSelector',
name: 'gateway-nodes',
fieldLabel: gettext('Gateway Nodes'),
multiSelect: true,
- autoSelect: false
+ autoSelect: false,
},
];
me.callParent();
- }
+ },
});
var me = this;
me.callParent();
- }
+ },
});
Ext.define('PVE.sdn.zones.BaseEdit', {
var ipanel = Ext.create(me.paneltype, {
type: me.type,
isCreate: me.isCreate,
- zone: me.zone
+ zone: me.zone,
});
Ext.apply(me, {
subject: PVE.Utils.format_sdnzone_type(me.type),
isAdd: true,
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
values.enable = values.disable ? 0 : 1;
ipanel.setValues(values);
- }
+ },
});
}
- }
+ },
});
maxLength: 8,
value: me.zone || '',
fieldLabel: 'ID',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
minValue: 1,
maxValue: 16000000,
fieldLabel: 'VRF-VXLAN Tag',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'pveSDNControllerSelector',
fieldLabel: gettext('Controller'),
name: 'controller',
value: '',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
fieldLabel: 'MTU',
skipEmptyText: true,
allowBlank: true,
- emptyText: 'auto'
+ emptyText: 'auto',
},
{
xtype: 'pveNodeSelector',
fieldLabel: gettext('Nodes'),
emptyText: gettext('All') + ' (' + gettext('No restrictions') +')',
multiSelect: true,
- autoSelect: false
+ autoSelect: false,
},
];
me.callParent();
- }
+ },
});
maxLength: 8,
value: me.zone || '',
fieldLabel: 'ID',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
minValue: 0,
maxValue: 4096,
fieldLabel: gettext('Service VLAN'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxKVComboBox',
fieldLabel: 'MTU',
skipEmptyText: true,
allowBlank: true,
- emptyText: 'auto'
+ emptyText: 'auto',
},
{
xtype: 'pveNodeSelector',
fieldLabel: gettext('Nodes'),
emptyText: gettext('All') + ' (' + gettext('No restrictions') +')',
multiSelect: true,
- autoSelect: false
+ autoSelect: false,
},
];
me.callParent();
- }
+ },
});
maxLength: 10,
value: me.zone || '',
fieldLabel: 'ID',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxintegerfield',
fieldLabel: 'MTU',
skipEmptyText: true,
allowBlank: true,
- emptyText: 'auto'
+ emptyText: 'auto',
},
{
xtype: 'pveNodeSelector',
fieldLabel: gettext('Nodes'),
emptyText: gettext('All') + ' (' + gettext('No restrictions') +')',
multiSelect: true,
- autoSelect: false
+ autoSelect: false,
},
];
me.callParent();
- }
+ },
});
maxLength: 10,
value: me.zone || '',
fieldLabel: 'ID',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
fieldLabel: 'MTU',
skipEmptyText: true,
allowBlank: true,
- emptyText: 'auto'
+ emptyText: 'auto',
},
{
xtype: 'pveNodeSelector',
fieldLabel: gettext('Nodes'),
emptyText: gettext('All') + ' (' + gettext('No restrictions') +')',
multiSelect: true,
- autoSelect: false
+ autoSelect: false,
},
];
me.callParent();
- }
+ },
});
name: 'zone',
value: me.zone || '',
fieldLabel: 'ID',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
fieldLabel: 'MTU',
skipEmptyText: true,
allowBlank: true,
- emptyText: 'auto'
+ emptyText: 'auto',
},
{
xtype: 'pveNodeSelector',
fieldLabel: gettext('Nodes'),
emptyText: gettext('All') + ' (' + gettext('No restrictions') +')',
multiSelect: true,
- autoSelect: false
+ autoSelect: false,
},
];
me.callParent();
- }
+ },
});
nodename: nodename,
volid: rec.data.volid,
volidText: PVE.Utils.render_storage_content(rec.data.volid, {}, rec),
- vmtype: vmtype
+ vmtype: vmtype,
});
win.show();
win.on('destroy', reload);
- }
+ },
},
{
xtype: 'proxmoxButton',
text: gettext('Show Configuration'),
disabled: true,
selModel: sm,
- handler: function(b,e,rec) {
+ handler: function(b, e, rec) {
var win = Ext.create('PVE.window.BackupConfig', {
volume: rec.data.volid,
- pveSelNode: me.pveSelNode
+ pveSelNode: me.pveSelNode,
});
win.show();
- }
+ },
},
pruneButton,
];
header: gettext('Verify State'),
dataIndex: 'verification',
renderer: PVE.Utils.render_backup_verification,
- }
+ },
};
}
value: me.storageId || '',
fieldLabel: 'ID',
vtype: 'StorageId',
- allowBlank: false
+ allowBlank: false,
});
me.column2 = me.column2 || [];
fieldLabel: gettext('Nodes'),
emptyText: gettext('All') + ' (' + gettext('No restrictions') +')',
multiSelect: true,
- autoSelect: false
+ autoSelect: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'enable',
checked: true,
uncheckedValue: 0,
- fieldLabel: gettext('Enable')
- }
+ fieldLabel: gettext('Enable'),
+ },
);
me.callParent();
- }
+ },
});
Ext.define('PVE.panel.StoragePruneInputPanel', {
}
// always delete old 'maxfiles' on edit, we map it to keep-last on window load
return {
- delete: ['prune-backups','maxfiles'],
+ delete: ['prune-backups', 'maxfiles'],
};
}
let options = { 'prune-backups': retention };
title: gettext('General'),
type: me.type,
isCreate: me.isCreate,
- storageId: me.storageId
+ storageId: me.storageId,
});
Ext.apply(me, {
me.query('inputpanel').forEach(panel => {
panel.setValues(values);
});
- }
+ },
});
}
- }
+ },
});
title: gettext('Summary'),
xtype: 'pveStorageSummary',
iconCls: 'fa fa-book',
- itemId: 'summary'
- }
+ itemId: 'summary',
+ },
];
var caps = Ext.state.Manager.get('GuiCap');
title: Ext.String.format(
gettext("Storage {0} on node {1}"),
`'${storeid}'`,
- `'${nodename}'`
+ `'${nodename}'`,
),
- hstateid: 'storagetab'
+ hstateid: 'storagetab',
});
if (caps.storage['Datastore.Allocate'] ||
title: gettext('Permissions'),
iconCls: 'fa fa-unlock',
itemId: 'permissions',
- path: '/storage/' + storeid
+ path: '/storage/' + storeid,
});
}
me.callParent();
- }
+ },
});
onlineHelp: 'storage_cephfs',
viewModel: {
- type: 'cephstorage'
+ type: 'cephstorage',
},
setValues: function(values) {
bind: {
disabled: '{pveceph}',
submitValue: '{!pveceph}',
- hidden: '{pveceph}'
+ hidden: '{pveceph}',
},
fieldLabel: 'Monitor(s)',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'displayfield',
reference: 'monhost',
bind: {
disabled: '{!pveceph}',
- hidden: '{!pveceph}'
+ hidden: '{!pveceph}',
},
value: '',
- fieldLabel: 'Monitor(s)'
+ fieldLabel: 'Monitor(s)',
},
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
value: 'admin',
bind: {
disabled: '{pveceph}',
- submitValue: '{!pveceph}'
+ submitValue: '{!pveceph}',
},
fieldLabel: gettext('User name'),
- allowBlank: true
- }
+ allowBlank: true,
+ },
);
me.column2 = [
name: 'content',
value: 'backup',
multiSelect: true,
- allowBlank: false
+ allowBlank: false,
},
];
reference: 'pvecephRef',
bind : {
disabled: '{!pvecephPossible}',
- value: '{pveceph}'
+ value: '{pveceph}',
},
checked: true,
uncheckedValue: 0,
submitValue: false,
hidden: !me.isCreate,
- boxLabel: gettext('Use Proxmox VE managed hyper-converged cephFS')
+ boxLabel: gettext('Use Proxmox VE managed hyper-converged cephFS'),
}];
me.callParent();
- }
+ },
});
name: 'path',
value: '',
fieldLabel: gettext('Directory'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'pveContentTypeSelector',
value: 'images',
multiSelect: true,
fieldLabel: gettext('Content'),
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
me.column2 = [
xtype: 'proxmoxcheckbox',
name: 'shared',
uncheckedValue: 0,
- fieldLabel: gettext('Shared')
+ fieldLabel: gettext('Shared'),
},
];
me.callParent();
- }
+ },
});
matchFieldWidth: false,
listConfig: {
loadingText: 'Scanning...',
- width: 350
+ width: 350,
},
doRawQuery: function() {
},
fields: [ 'volname' ],
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/scan/glusterfs'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/scan/glusterfs',
+ },
});
store.sort('volname', 'ASC');
Ext.apply(me, {
- store: store
+ store: store,
});
me.callParent();
- }
+ },
});
Ext.define('PVE.storage.GlusterFsInputPanel', {
volumeField.setServer(value);
volumeField.setValue('');
}
- }
- }
+ },
+ },
},
{
xtype: me.isCreate ? 'proxmoxtextfield' : 'displayfield',
name: 'server2',
value: '',
fieldLabel: gettext('Second Server'),
- allowBlank: true
+ allowBlank: true,
},
{
xtype: me.isCreate ? 'pveGlusterFsScan' : 'displayfield',
name: 'volume',
value: '',
fieldLabel: 'Volume name',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'pveContentTypeSelector',
value: 'images',
multiSelect: true,
fieldLabel: gettext('Content'),
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
me.callParent();
- }
+ },
});
matchFieldWidth: false,
listConfig: {
loadingText: gettext('Scanning...'),
- width: 350
+ width: 350,
},
doRawQuery: function() {
},
fields: [ 'target', 'portal' ],
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/scan/iscsi'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/scan/iscsi',
+ },
});
store.sort('target', 'ASC');
Ext.apply(me, {
- store: store
+ store: store,
});
me.callParent();
- }
+ },
});
Ext.define('PVE.storage.IScsiInputPanel', {
exportField.setPortal(value);
exportField.setValue('');
}
- }
- }
+ },
+ },
},
{
readOnly: !me.isCreate,
name: 'target',
value: '',
fieldLabel: 'Target',
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
me.column2 = [
xtype: 'checkbox',
name: 'luns',
checked: true,
- fieldLabel: gettext('Use LUNs directly')
- }
+ fieldLabel: gettext('Use LUNs directly'),
+ },
];
me.callParent();
- }
+ },
});
Ext.Msg.show({
title: gettext('Cannot remove disk image.'),
icon: Ext.Msg.ERROR,
- msg: msg
+ msg: msg,
});
return;
}
title: Ext.String.format(gettext("Destroy '{0}'"), rec.data.volid),
showProgress: true,
url: url,
- item: { type: 'Image', id: vmid }
+ item: { type: 'Image', id: vmid },
}).show();
win.on('destroy', reload);
- }
+ },
},
];
me.useCustomRemoveButton = true;
fields: [ 'vg', 'size', 'free' ],
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/scan/lvm'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/scan/lvm',
+ },
});
store.sort('vg', 'ASC');
Ext.apply(me, {
store: store,
listConfig: {
- loadingText: gettext('Scanning...')
- }
+ loadingText: gettext('Scanning...'),
+ },
});
me.callParent();
- }
+ },
});
Ext.define('PVE.storage.BaseStorageSelector', {
autoLoad: {
addRecords: true,
params: {
- type: 'iscsi'
- }
+ type: 'iscsi',
+ },
},
fields: [ 'storage', 'type', 'content',
{
} else {
return me.existingGroupsText;
}
- }
+ },
}],
proxy: {
type: 'proxmox',
- url: '/api2/json/storage/'
- }
+ url: '/api2/json/storage/',
+ },
});
store.loadData([{ storage: '' }], true);
store.sort('storage', 'ASC');
Ext.apply(me, {
- store: store
+ store: store,
});
me.callParent();
- }
+ },
});
Ext.define('PVE.storage.LVMInputPanel', {
disabled: !!me.isCreate,
value: '',
fieldLabel: gettext('Volume group'),
- allowBlank: false
+ allowBlank: false,
});
if (me.isCreate) {
var vgField = Ext.create('PVE.storage.VgSelector', {
name: 'vgname',
fieldLabel: gettext('Volume group'),
- allowBlank: false
+ allowBlank: false,
});
var baseField = Ext.createWidget('pveFileSelector', {
nodename: 'localhost',
storageContent: 'images',
fieldLabel: gettext('Base volume'),
- allowBlank: false
+ allowBlank: false,
});
me.column1.push({
baseField.setDisabled(true);
}
baseField.setStorage(value);
- }
- }
+ },
+ },
});
me.column1.push(baseField);
name: 'content',
value: ['images', 'rootdir'],
multiSelect: true,
- allowBlank: false
+ allowBlank: false,
});
me.column2 = [
xtype: 'proxmoxcheckbox',
name: 'shared',
uncheckedValue: 0,
- fieldLabel: gettext('Shared')
- }
+ fieldLabel: gettext('Shared'),
+ },
];
me.callParent();
- }
+ },
});
fields: [ 'lv' ],
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/scan/lvmthin'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/scan/lvmthin',
+ },
});
store.sort('lv', 'ASC');
Ext.apply(me, {
store: store,
listConfig: {
- loadingText: gettext('Scanning...')
- }
+ loadingText: gettext('Scanning...'),
+ },
});
me.callParent();
- }
+ },
});
Ext.define('PVE.storage.BaseVGSelector', {
fields: [ 'vg', 'size', 'free'],
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/scan/lvm'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/scan/lvm',
+ },
});
Ext.apply(me, {
store: store,
listConfig: {
- loadingText: gettext('Scanning...')
- }
+ loadingText: gettext('Scanning...'),
+ },
});
me.callParent();
- }
+ },
});
Ext.define('PVE.storage.LvmThinInputPanel', {
disabled: !!me.isCreate,
value: '',
fieldLabel: gettext('Volume group'),
- allowBlank: false
+ allowBlank: false,
});
var thinpoolField = Ext.createWidget(me.isCreate ? 'textfield' : 'displayfield', {
disabled: !!me.isCreate,
value: '',
fieldLabel: gettext('Thin Pool'),
- allowBlank: false
+ allowBlank: false,
});
if (me.isCreate) {
var vgField = Ext.create('PVE.storage.TPoolSelector', {
name: 'thinpool',
fieldLabel: gettext('Thin Pool'),
- allowBlank: false
+ allowBlank: false,
});
me.column1.push({
vgField.setVG(value);
vgField.setValue('');
}
- }
- }
+ },
+ },
});
me.column1.push(vgField);
name: 'content',
value: ['images', 'rootdir'],
multiSelect: true,
- allowBlank: false
+ allowBlank: false,
});
me.column2 = [];
me.callParent();
- }
+ },
});
matchFieldWidth: false,
listConfig: {
loadingText: gettext('Scanning...'),
- width: 350
+ width: 350,
},
doRawQuery: function() {
},
fields: [ 'path', 'options' ],
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/scan/nfs'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/scan/nfs',
+ },
});
store.sort('path', 'ASC');
Ext.apply(me, {
- store: store
+ store: store,
});
me.callParent();
- }
+ },
});
Ext.define('PVE.storage.NFSInputPanel', {
exportField.setServer(value);
exportField.setValue('');
}
- }
- }
+ },
+ },
},
{
xtype: me.isCreate ? 'pveNFSScan' : 'displayfield',
name: 'export',
value: '',
fieldLabel: 'Export',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'pveContentTypeSelector',
value: 'images',
multiSelect: true,
fieldLabel: gettext('Content'),
- allowBlank: false
- }
+ allowBlank: false,
+ },
];
me.advancedColumn1 = [
['3', '3'],
['4', '4'],
['4.1', '4.1'],
- ['4.2', '4.2']
- ]
- }
+ ['4.2', '4.2'],
+ ],
+ },
];
me.callParent();
- }
+ },
});
data: {
pveceph: true,
- pvecephPossible: true
- }
+ pvecephPossible: true,
+ },
});
Ext.define('PVE.storage.Ceph.Controller', {
control: {
'#': {
- afterrender: 'queryMonitors'
+ afterrender: 'queryMonitors',
},
'textfield[name=username]': {
- disable: 'resetField'
+ disable: 'resetField',
},
'displayfield[name=monhost]': {
- enable: 'queryMonitors'
+ enable: 'queryMonitors',
},
'textfield[name=monhost]': {
disable: 'resetField',
- enable: 'resetField'
- }
+ enable: 'resetField',
+ },
},
resetField: function(field) {
field.reset();
vm.set('pveceph', false);
vm.set('pvecephPossible', false);
}
- }
+ },
});
- }
+ },
});
Ext.define('PVE.storage.RBDInputPanel', {
onlineHelp: 'ceph_rados_block_devices',
viewModel: {
- type: 'cephstorage'
+ type: 'cephstorage',
},
setValues: function(values) {
bind: {
disabled: '{!pveceph}',
submitValue: '{pveceph}',
- hidden: '{!pveceph}'
+ hidden: '{!pveceph}',
},
fieldLabel: gettext('Pool'),
- allowBlank: false
- },{
+ allowBlank: false,
+ }, {
xtype: 'textfield',
name: 'pool',
value: 'rbd',
bind: {
disabled: '{pveceph}',
submitValue: '{!pveceph}',
- hidden: '{pveceph}'
+ hidden: '{pveceph}',
},
fieldLabel: gettext('Pool'),
- allowBlank: false
+ allowBlank: false,
});
} else {
me.column1.push({
nodename: me.nodename,
name: 'pool',
fieldLabel: gettext('Pool'),
- allowBlank: false
+ allowBlank: false,
});
}
bind: {
disabled: '{pveceph}',
submitValue: '{!pveceph}',
- hidden: '{pveceph}'
+ hidden: '{pveceph}',
},
value: '',
fieldLabel: 'Monitor(s)',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'displayfield',
reference: 'monhost',
bind: {
disabled: '{!pveceph}',
- hidden: '{!pveceph}'
+ hidden: '{!pveceph}',
},
value: '',
- fieldLabel: 'Monitor(s)'
+ fieldLabel: 'Monitor(s)',
},
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'username',
bind: {
disabled: '{pveceph}',
- submitValue: '{!pveceph}'
+ submitValue: '{!pveceph}',
},
value: 'admin',
fieldLabel: gettext('User name'),
- allowBlank: true
- }
+ allowBlank: true,
+ },
);
me.column2 = [
name: 'content',
value: ['images'],
multiSelect: true,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'krbd',
uncheckedValue: 0,
- fieldLabel: 'KRBD'
- }
+ fieldLabel: 'KRBD',
+ },
];
me.columnB = [{
reference: 'pvecephRef',
bind : {
disabled: '{!pvecephPossible}',
- value: '{pveceph}'
+ value: '{pveceph}',
},
checked: true,
uncheckedValue: 0,
submitValue: false,
hidden: !me.isCreate,
- boxLabel: gettext('Use Proxmox VE managed hyper-converged ceph pool')
+ boxLabel: gettext('Use Proxmox VE managed hyper-converged ceph pool'),
}];
me.callParent();
- }
+ },
});
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
defaults: {
xtype: 'pveInfoWidget',
- padding: '0 30 5 30'
+ padding: '0 30 5 30',
},
items: [
{
xtype: 'box',
- height: 30
+ height: 30,
},
{
itemId: 'enabled',
title: gettext('Enabled'),
printBar: false,
textField: 'disabled',
- renderer: Proxmox.Utils.format_neg_boolean
+ renderer: Proxmox.Utils.format_neg_boolean,
},
{
itemId: 'active',
title: gettext('Active'),
printBar: false,
textField: 'active',
- renderer: Proxmox.Utils.format_boolean
+ renderer: Proxmox.Utils.format_boolean,
},
{
itemId: 'content',
title: gettext('Content'),
printBar: false,
textField: 'content',
- renderer: PVE.Utils.format_content_types
+ renderer: PVE.Utils.format_content_types,
},
{
itemId: 'type',
title: gettext('Type'),
printBar: false,
textField: 'type',
- renderer: PVE.Utils.format_storage_type
+ renderer: PVE.Utils.format_storage_type,
},
{
xtype: 'box',
- height: 10
+ height: 10,
},
{
itemId: 'usage',
title: gettext('Usage'),
valueField: 'used',
- maxField: 'total'
- }
+ maxField: 'total',
+ },
],
updateTitle: function() {
return;
- }
+ },
});
tbar: [
'->',
{
- xtype: 'proxmoxRRDTypeSelector'
- }
+ xtype: 'proxmoxRRDTypeSelector',
+ },
],
layout: {
- type: 'column'
+ type: 'column',
},
defaults: {
padding: 5,
- columnWidth: 1
+ columnWidth: 1,
},
initComponent: function() {
var me = this;
var rstore = Ext.create('Proxmox.data.ObjectStore', {
url: "/api2/json/nodes/" + nodename + "/storage/" + storage + "/status",
- interval: 1000
+ interval: 1000,
});
var rrdstore = Ext.create('Proxmox.data.RRDStore', {
rrdurl: "/api2/json/nodes/" + nodename + "/storage/" + storage + "/rrddata",
- model: 'pve-rrd-storage'
+ model: 'pve-rrd-storage',
});
Ext.apply(me, {
{
xtype: 'pveStorageStatusView',
pveSelNode: me.pveSelNode,
- rstore: rstore
+ rstore: rstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Usage'),
- fields: ['total','used'],
+ fields: ['total', 'used'],
fieldTitles: ['Total Size', 'Used Size'],
- store: rrdstore
- }
+ store: rrdstore,
+ },
],
listeners: {
activate: function() { rstore.startUpdate(); rrdstore.startUpdate(); },
- destroy: function() { rstore.stopUpdate(); rrdstore.stopUpdate(); }
- }
+ destroy: function() { rstore.stopUpdate(); rrdstore.stopUpdate(); },
+ },
});
me.callParent();
- }
+ },
});
stateful: true,
stateId: 'grid-template-selector',
viewConfig: {
- trackOver: false
+ trackOver: false,
},
initComponent : function() {
var me = this;
groupField: 'section',
proxy: {
type: 'proxmox',
- url: '/api2/json' + baseurl
- }
+ url: '/api2/json' + baseurl,
+ },
});
var sm = Ext.create('Ext.selection.RowModel', {});
- var groupingFeature = Ext.create('Ext.grid.feature.Grouping',{
- groupHeaderTpl: '{[ "Section: " + values.name ]} ({rows.length} Item{[values.rows.length > 1 ? "s" : ""]})'
+ var groupingFeature = Ext.create('Ext.grid.feature.Grouping', {
+ groupHeaderTpl: '{[ "Section: " + values.name ]} ({rows.length} Item{[values.rows.length > 1 ? "s" : ""]})',
});
var reload = function() {
return (rec.data['package'].toLowerCase().indexOf(value) !== -1)
|| (rec.data.headline.toLowerCase().indexOf(value) !== -1);
});
- }
- }
- }
+ },
+ },
+ },
],
features: [ groupingFeature ],
columns: [
{
header: gettext('Type'),
width: 80,
- dataIndex: 'type'
+ dataIndex: 'type',
},
{
header: gettext('Package'),
flex: 1,
- dataIndex: 'package'
+ dataIndex: 'package',
},
{
header: gettext('Version'),
width: 80,
- dataIndex: 'version'
+ dataIndex: 'version',
},
{
header: gettext('Description'),
flex: 1.5,
renderer: Ext.String.htmlEncode,
- dataIndex: 'headline'
- }
+ dataIndex: 'headline',
+ },
],
listeners: {
- afterRender: reload
- }
+ afterRender: reload,
+ },
});
me.callParent();
- }
+ },
}, function() {
extend: 'Ext.data.Model',
fields: [
'template', 'type', 'package', 'version', 'headline', 'infopage',
- 'description', 'os', 'section'
+ 'description', 'os', 'section',
],
- idProperty: 'template'
+ idProperty: 'template',
});
});
var grid = Ext.create('PVE.grid.TemplateSelector', {
border: false,
scrollable: true,
- nodename: me.nodename
+ nodename: me.nodename,
});
var sm = grid.getSelectionModel();
url: '/nodes/' + me.nodename + '/aplinfo',
params: {
storage: me.storage,
- template: rec.data.template
+ template: rec.data.template,
},
method: 'POST',
failure: function (response, opts) {
Ext.create('Proxmox.window.TaskViewer', {
upid: upid,
listeners: {
- destroy: me.reloadGrid
- }
+ destroy: me.reloadGrid,
+ },
}).show();
me.close();
- }
+ },
});
- }
+ },
});
Ext.apply(me, {
items: grid,
- buttons: [ submitBtn ]
+ buttons: [ submitBtn ],
});
me.callParent();
- }
+ },
});
Ext.define('PVE.storage.TemplateView', {
me.store.load();
}
- var templateButton = Ext.create('Proxmox.button.Button',{
+ var templateButton = Ext.create('Proxmox.button.Button', {
itemId: 'tmpl-btn',
text: gettext('Templates'),
handler: function() {
var win = Ext.create('PVE.storage.TemplateDownload', {
nodename: nodename,
storage: storage,
- reloadGrid: reload
+ reloadGrid: reload,
});
win.show();
- }
+ },
});
me.tbar = [ templateButton ];
data: {
isLIO: false,
isComstar: true,
- hasWriteCacheOption: true
- }
+ hasWriteCacheOption: true,
+ },
},
controller: {
xclass: 'Ext.app.ViewController',
control: {
'field[name=iscsiprovider]': {
- change: 'changeISCSIProvider'
- }
+ change: 'changeISCSIProvider',
+ },
},
changeISCSIProvider: function(f, newVal, oldVal) {
var vm = this.getViewModel();
vm.set('isLIO', newVal === 'LIO');
vm.set('isComstar', newVal === 'comstar');
vm.set('hasWriteCacheOption', newVal === 'comstar' || newVal === 'istgt');
- }
+ },
},
onGetValues: function(values) {
name: 'portal',
value: '',
fieldLabel: gettext('Portal'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'pool',
value: '',
fieldLabel: gettext('Pool'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'blocksize',
value: '4k',
fieldLabel: gettext('Block Size'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
name: 'target',
value: '',
fieldLabel: gettext('Target'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
value: '',
fieldLabel: gettext('Target group'),
bind: me.isCreate ? { disabled: '{!isComstar}' } : { hidden: '{!isComstar}' },
- allowBlank: true
- }
+ allowBlank: true,
+ },
];
me.column2 = [
name: 'iscsiprovider',
value: 'comstar',
fieldLabel: gettext('iSCSI Provider'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'sparse',
checked: false,
uncheckedValue: 0,
- fieldLabel: gettext('Thin provision')
+ fieldLabel: gettext('Thin provision'),
},
{
xtype: 'proxmoxcheckbox',
checked: true,
bind: me.isCreate ? { disabled: '{!hasWriteCacheOption}' } : { hidden: '{!hasWriteCacheOption}' },
uncheckedValue: 0,
- fieldLabel: gettext('Write cache')
+ fieldLabel: gettext('Write cache'),
},
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
value: '',
bind: me.isCreate ? { disabled: '{!isComstar}' } : { hidden: '{!isComstar}' },
fieldLabel: gettext('Host group'),
- allowBlank: true
+ allowBlank: true,
},
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
value: '',
bind: me.isCreate ? { disabled: '{!isLIO}' } : { hidden: '{!isLIO}' },
allowBlank: false,
- fieldLabel: gettext('Target portal group')
- }
+ fieldLabel: gettext('Target portal group'),
+ },
];
me.callParent();
- }
+ },
});
queryMode: 'local',
editable: false,
listConfig: {
- loadingText: gettext('Scanning...')
+ loadingText: gettext('Scanning...'),
},
initComponent : function() {
var me = this;
fields: [ 'pool', 'size', 'free' ],
proxy: {
type: 'proxmox',
- url: '/api2/json/nodes/' + me.nodename + '/scan/zfs'
- }
+ url: '/api2/json/nodes/' + me.nodename + '/scan/zfs',
+ },
});
store.sort('pool', 'ASC');
Ext.apply(me, {
- store: store
+ store: store,
});
me.callParent();
- }
+ },
});
Ext.define('PVE.storage.ZFSPoolInputPanel', {
me.column1.push(Ext.create('PVE.storage.ZFSPoolSelector', {
name: 'pool',
fieldLabel: gettext('ZFS Pool'),
- allowBlank: false
+ allowBlank: false,
}));
} else {
me.column1.push(Ext.createWidget('displayfield', {
name: 'pool',
value: '',
fieldLabel: gettext('ZFS Pool'),
- allowBlank: false
+ allowBlank: false,
}));
}
name: 'content',
value: ['images', 'rootdir'],
multiSelect: true,
- allowBlank: false
+ allowBlank: false,
});
me.column2 = [
{
name: 'sparse',
checked: false,
uncheckedValue: 0,
- fieldLabel: gettext('Thin provision')
+ fieldLabel: gettext('Thin provision'),
},
{
xtype: 'textfield',
name: 'blocksize',
emptyText: '8k',
fieldLabel: gettext('Block Size'),
- allowBlank: true
- }
+ allowBlank: true,
+ },
];
me.callParent();
- }
+ },
});
typeDefaults: {
node: {
iconCls: 'fa fa-building',
- text: gettext('Nodes')
+ text: gettext('Nodes'),
},
pool: {
iconCls: 'fa fa-tags',
- text: gettext('Resource Pool')
+ text: gettext('Resource Pool'),
},
storage: {
iconCls: 'fa fa-database',
- text: gettext('Storage')
+ text: gettext('Storage'),
},
sdn: {
iconCls: 'fa fa-th',
- text: gettext('SDN')
+ text: gettext('SDN'),
},
qemu: {
iconCls: 'fa fa-desktop',
- text: gettext('Virtual Machine')
+ text: gettext('Virtual Machine'),
},
lxc: {
//iconCls: 'x-tree-node-lxc',
iconCls: 'fa fa-cube',
- text: gettext('LXC Container')
+ text: gettext('LXC Container'),
},
template: {
- iconCls: 'fa fa-file-o'
- }
- }
+ iconCls: 'fa fa-file-o',
+ },
+ },
},
useArrows: true,
} else {
groupinfo = {
type: groupby,
- id : groupby + "/" + v
+ id : groupby + "/" + v,
};
if (groupby !== 'type') {
groupinfo[groupby] = v;
var pdata = {
dataIndex: {},
- updateCount: 0
+ updateCount: 0,
};
var store = Ext.create('Ext.data.TreeStore', {
expanded: true,
id: 'root',
text: gettext('Datacenter'),
- iconCls: 'fa fa-server'
- }
+ iconCls: 'fa fa-server',
+ },
});
var stateid = 'rid';
// tree item has been updated
var fields = [
'text', 'running', 'template', 'status',
- 'qmpstatus', 'hastate', 'lock'
+ 'qmpstatus', 'hastate', 'lock',
];
var field;
store: store,
viewConfig: {
// note: animate cause problems with applyState
- animate: false
+ animate: false,
},
//useArrows: true,
//rootVisible: false,
me.allowSelection = true;
return allow;
},
- itemdblclick: PVE.Utils.openTreeConsole
+ itemdblclick: PVE.Utils.openTreeConsole,
},
setViewFilter: function(view) {
me.viewFilter = view;
} else {
sm.deselectAll();
}
- }
+ },
});
me.callParent();
rstore.on("load", updateTree);
rstore.startUpdate();
//rstore.stopUpdate();
- }
+ },
});
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskProgress', { upid: upid });
win.show();
- }
+ },
});
},
}
me.load_task.delay(load_delay);
- }
+ },
});
// if we do not have the permissions, we don't have to check
}
let res = response.result.data;
vm.set('snapshotFeature', !!res.hasFeature);
- }
+ },
});
},
let rec = view.getSelection()[0];
return Ext.String.format(
gettext('Are you sure you want to remove entry {0}'),
- `'${rec.data.name}'`
+ `'${rec.data.name}'`,
);
},
handler: 'remove',
name: 'order',
calculate: function(data) {
return data.snaptime || (data.name === 'current' ? 'ZZZ' : data.snapstate);
- }
- }
+ },
+ },
],
columns: [
} else {
return value;
}
- }
+ },
},
{
text: gettext('RAM'),
if (record.data.name !== 'current') {
return Proxmox.Utils.format_boolean(value);
}
- }
+ },
},
{
text: gettext('Date') + "/" + gettext("Status"),
return record.data.snapstate;
}
if (value) {
- return Ext.Date.format(value,'Y-m-d H:i:s');
+ return Ext.Date.format(value, 'Y-m-d H:i:s');
}
- }
+ },
},
{
text: gettext('Description'),
} else {
return Ext.String.htmlEncode(value);
}
- }
- }
+ },
+ },
],
});
} else if (!compressionSelector.getEditable()) {
compressionSelector.setDisabled(false);
}
- }
+ },
},
});
storagesel.setValue(me.storage);
border: false,
fieldDefaults: {
labelWidth: 100,
- anchor: '100%'
+ anchor: '100%',
},
items: [
storagesel,
xtype: 'pveBackupModeSelector',
fieldLabel: gettext('Mode'),
value: 'snapshot',
- name: 'mode'
+ name: 'mode',
},
compressionSelector,
{
xtype: 'textfield',
fieldLabel: gettext('Send email to'),
name: 'mailto',
- emptyText: Proxmox.Utils.noneText
- }
- ]
+ emptyText: Proxmox.Utils.noneText,
+ },
+ ],
});
var form = me.formPanel.getForm();
storage: storage,
vmid: me.vmid,
mode: values.mode,
- remove: 0
+ remove: 0,
};
if ( values.mailto ) {
params: params,
method: 'POST',
failure: function (response, opts) {
- Ext.Msg.alert('Error',response.htmlStatus);
+ Ext.Msg.alert('Error', response.htmlStatus);
},
success: function(response, options) {
// close later so we reload the grid
listeners: {
close: function() {
me.close();
- }
- }
+ },
+ },
});
win.show();
- }
+ },
});
- }
+ },
});
var helpBtn = Ext.create('Proxmox.button.Help', {
onlineHelp: 'chapter_vzdump',
listenToGlobalEvent: false,
- hidden: false
+ hidden: false,
});
var title = gettext('Backup') + " " +
layout: 'auto',
border: false,
items: [ me.formPanel ],
- buttons: [ helpBtn, '->', submitBtn ]
+ buttons: [ helpBtn, '->', submitBtn ],
});
me.callParent();
- }
+ },
});
'background-color': 'white',
'white-space': 'pre',
'font-family': 'monospace',
- padding: '5px'
- }
+ padding: '5px',
+ },
},
initComponent: function() {
url: "/nodes/" + nodename + "/vzdump/extractconfig",
method: 'GET',
params: {
- volume: me.volume
+ volume: me.volume,
},
failure: function(response, opts) {
me.close();
Ext.Msg.alert('Error', response.htmlStatus);
},
- success: function(response,options) {
+ success: function(response, options) {
me.show();
me.down('#configtext').update(Ext.htmlEncode(response.result.data));
- }
+ },
});
- }
+ },
});
width: 800,
modal: true,
layout: {
- type: 'fit'
+ type: 'fit',
},
border: false,
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskViewer', {
- upid: upid
+ upid: upid,
});
win.show();
me.hide();
win.on('destroy', function() {
me.close();
});
- }
+ },
});
},
disallowedNodes: [me.nodename],
fieldLabel: gettext('Target node'),
allowBlank: false,
- onlineValidator: true
+ onlineValidator: true,
},
{
xtype: 'proxmoxintegerfield',
maxValue: 100,
value: 1,
fieldLabel: gettext('Parallel jobs'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'fieldcontainer',
uncheckedValue: 0,
listeners: {
change: (cb, val) => me.down('#localdiskwarning').setVisible(val),
- }
+ },
},
{
xtype: 'displayfield',
userCls: 'pmx-hint',
value: 'Warning: Running CTs will be migrated in Restart Mode.',
- hidden: true // only visible if running container chosen
- }
+ hidden: true, // only visible if running container chosen
+ },
);
} else if (me.action === 'startall') {
items.push({
xtype: 'hiddenfield',
name: 'force',
- value: 1
+ value: 1,
});
}
});
me.down('#lxcwarning').setVisible(showWarning);
}
- }
- }
+ },
+ },
});
me.formPanel = Ext.create('Ext.form.Panel', {
border: false,
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
fieldDefaults: {
labelWidth: 300,
- anchor: '100%'
+ anchor: '100%',
},
- items: items
+ items: items,
});
var form = me.formPanel.getForm();
handler: function() {
form.isValid();
me.submit(form.getValues());
- }
+ },
});
Ext.apply(me, {
items: [ me.formPanel ],
- buttons: [ submitBtn ]
+ buttons: [ submitBtn ],
});
me.callParent();
submitBtn.setDisabled(!valid);
});
form.isValid();
- }
+ },
});
layout: {
align: 'stretch',
pack: 'center',
- type: 'vbox'
+ type: 'vbox',
},
viewModel: {
data: {
- isInstalled: false
+ isInstalled: false,
},
formulas: {
buttonText: function (get){
Ext.String.format(gettext('{0} is not installed on this node.'), 'Ceph') + '<br>' +
gettext('Would you like to install it now?') + '</p>';
}
- }
- }
+ },
+ },
},
items: [
{
bind: {
- html: '{windowText}'
+ html: '{windowText}',
},
border: false,
padding: 5,
- bodyCls: 'install-mask'
+ bodyCls: 'install-mask',
},
{
xtype: 'button',
bind: {
- text: '{buttonText}'
+ text: '{buttonText}',
},
viewModel: {},
cbind: {
- nodename: '{nodename}'
+ nodename: '{nodename}',
},
handler: function() {
var me = this.up('pveCephInstallWindow');
- var win = Ext.create('PVE.ceph.CephInstallWizard',{
- nodename: me.nodename
+ var win = Ext.create('PVE.ceph.CephInstallWizard', {
+ nodename: me.nodename,
});
win.getViewModel().set('isInstalled', this.getViewModel().get('isInstalled'));
win.show();
- me.mon(win,'beforeClose', function(){
+ me.mon(win, 'beforeClose', function(){
me.fireEvent("cephInstallWindowClosed");
me.close();
});
- }
- }
- ]
+ },
+ },
+ ],
});
xclass: 'Ext.app.ViewController',
control: {
'panel[reference=cloneform]': {
- validitychange: 'disableSubmit'
- }
+ validitychange: 'disableSubmit',
+ },
},
disableSubmit: function(form) {
this.lookupReference('submitBtn').setDisabled(!form.isValid());
- }
+ },
},
statics: {
guestType: guestType,
vmid: vmid,
isTemplate: isTemplate,
- hasSnapshots: hasSnapshots
+ hasSnapshots: hasSnapshots,
}).show();
- }
+ },
});
- }
+ },
},
create_clone: function(values) {
},
success: function(response, options) {
me.close();
- }
+ },
});
},
me.lookupReference('targetsel').allowedNodes = res.nodes;
me.lookupReference('targetsel').validate();
- }
+ },
});
},
listeners: {
change: function(f, value) {
me.lookupReference('hdstorage').setTargetNode(value);
- }
- }
+ },
+ },
});
var modelist = [['copy', gettext('Full Clone')]];
guestType: me.guestType,
value: '',
loadNextFreeID: true,
- validateExists: false
+ validateExists: false,
},
{
xtype: 'textfield',
name: 'name',
allowBlank: true,
- fieldLabel: me.guestType === 'lxc' ? gettext('Hostname') : gettext('Name')
+ fieldLabel: me.guestType === 'lxc' ? gettext('Hostname') : gettext('Name'),
},
{
xtype: 'pvePoolSelector',
fieldLabel: gettext('Resource Pool'),
name: 'pool',
value: '',
- allowBlank: true
- }
+ allowBlank: true,
+ },
);
col2.push({
change: function(t, value) {
me.updateVisibility();
me.verifyFeature();
- }
- }
+ },
+ },
},
{
xtype: 'PVE.form.SnapshotSelector',
listeners: {
change: function(f, value) {
me.verifyFeature();
- }
- }
+ },
+ },
},
{
xtype: 'pveDiskStorageSelector',
allowBlank: true,
storageContent: me.guestType === 'qemu' ? 'images' : 'rootdir',
emptyText: gettext('Same as source'),
- disabled: me.isTemplate ? true : false // because default mode is clone for templates
+ disabled: me.isTemplate ? true : false, // because default mode is clone for templates
});
var formPanel = Ext.create('Ext.form.Panel', {
defaultType: 'container',
fieldDefaults: {
labelWidth: 100,
- anchor: '100%'
+ anchor: '100%',
},
items: [
{
flex: 1,
padding: '0 10 0 0',
layout: 'anchor',
- items: col1
+ items: col1,
},
{
flex: 1,
padding: '0 0 0 10',
layout: 'anchor',
- items: col2
- }
- ]
+ items: col2,
+ },
+ ],
});
Ext.apply(me, {
xtype: 'proxmoxHelpButton',
listenToGlobalEvent: false,
hidden: false,
- onlineHelp: me.onlineHelp
+ onlineHelp: me.onlineHelp,
},
'->',
{
if (cloneForm.isValid()) {
me.create_clone(cloneForm.getValues());
}
- }
+ },
} ],
- items: [ formPanel ]
+ items: [ formPanel ],
});
me.callParent();
me.verifyFeature();
- }
+ },
});
subject: gettext('Firewall'),
cbindData: {
- defaultValue: 0
+ defaultValue: 0,
},
width: 350,
uncheckedValue: 0,
cbind: {
defaultValue: '{defaultValue}',
- checked: '{defaultValue}'
+ checked: '{defaultValue}',
},
deleteDefaultValue: false,
- fieldLabel: gettext('Firewall')
+ fieldLabel: gettext('Firewall'),
},
{
xtype: 'displayfield',
name: 'warning',
userCls: 'pmx-hint',
value: gettext('Warning: Firewall still disabled at datacenter level!'),
- hidden: true
- }
+ hidden: true,
+ },
],
beforeShow: function() {
if (!response.result.data.enable) {
me.down('displayfield[name=warning]').setVisible(true);
}
- }
+ },
});
- }
+ },
});
name: 'enable',
reference: 'enable',
fieldLabel: gettext('Enable'),
- value: true
+ value: true,
},
{
layout: 'hbox',
maxValue: 99,
allowBlank: false,
flex: 2,
- value: 1
+ value: 1,
},
{
xtype: 'box',
- html: '<div style="margin: auto; padding: 2.5px;"><b>/</b></div>'
+ html: '<div style="margin: auto; padding: 2.5px;"><b>/</b></div>',
},
{
xtype: 'proxmoxKVComboBox',
['hour', 'hour'], ['day', 'day']],
allowBlank: false,
flex: 1,
- value: 'second'
- }
- ]
+ value: 'second',
+ },
+ ],
},
{
xtype: 'numberfield',
fieldLabel: gettext('Log burst limit'),
minValue: 1,
maxValue: 99,
- value: 5
- }
+ value: 5,
+ },
],
onGetValues: function(values) {
}
}
me.callParent([properties]);
- }
+ },
});
Ext.define('PVE.FirewallLograteEdit', {
subject: gettext('Log rate limit'),
items: [{
- xtype: 'pveFirewallLograteInputPanel'
+ xtype: 'pveFirewallLograteInputPanel',
}],
- autoLoad: true
+ autoLoad: true,
});
} else {
me.success(data);
}
- }
+ },
});
},
Proxmox.LoggedOut = false;
Proxmox.Utils.authClear();
me.getView().show();
- }
+ },
});
win.show();
},
var msg = Ext.Msg.show({
title: 'U2F: '+gettext('Verification'),
message: gettext('Please press the button on your U2F Device'),
- buttons: []
+ buttons: [],
});
var chlg = data.U2FChallenge;
var key = {
version: chlg.version,
- keyHandle: chlg.keyHandle
+ keyHandle: chlg.keyHandle,
};
u2f.sign(chlg.appId, chlg.challenge, [key], function(res) {
msg.close();
failure: function(resp, opts) {
Proxmox.Utils.authClear();
me.failure(resp);
- }
+ },
});
},
pf.focus(false);
}
}
- }
+ },
},
'field[name=lang]': {
change: function(f, value) {
Ext.util.Cookies.set('PVELangCookie', value, dt);
this.getView().mask(gettext('Please wait...'), 'x-mask-loading');
window.location.reload();
- }
+ },
},
'button[reference=loginButton]': {
- click: 'onLogon'
+ click: 'onLogon',
},
'#': {
show: function() {
var pwField = this.lookupReference('passwordField');
pwField.focus();
}
- }
- }
- }
+ },
+ },
+ },
},
width: 400,
fieldDefaults: {
labelAlign: 'right',
- allowBlank: false
+ allowBlank: false,
},
items: [
name: 'username',
itemId: 'usernameField',
reference: 'usernameField',
- stateId: 'login-username'
+ stateId: 'login-username',
},
{
xtype: 'textfield',
inputType: 'password',
fieldLabel: gettext('Password'),
name: 'password',
- reference: 'passwordField'
+ reference: 'passwordField',
},
{
xtype: 'pmxRealmComboBox',
- name: 'realm'
+ name: 'realm',
},
{
xtype: 'proxmoxLanguageSelector',
value: Ext.util.Cookies.get('PVELangCookie') || Proxmox.defaultLang || 'en',
name: 'lang',
reference: 'langField',
- submitValue: false
- }
+ submitValue: false,
+ },
],
buttons: [
{
stateId: 'login-saveusername',
labelWidth: 250,
labelAlign: 'right',
- submitValue: false
+ submitValue: false,
},
{
text: gettext('Login'),
- reference: 'loginButton'
- }
- ]
- }]
+ reference: 'loginButton',
+ },
+ ],
+ }],
});
Ext.define('PVE.window.TFALoginWindow', {
extend: 'Ext.window.Window',
var view = me.getView();
view.onCancel();
view.close();
- }
+ },
},
items: [
name: 'otp',
itemId: 'otpField',
reference: 'otpField',
- allowBlank: false
- }
+ allowBlank: false,
+ },
],
buttons: [
{
text: gettext('Login'),
reference: 'loginButton',
- handler: 'login'
+ handler: 'login',
},
{
text: gettext('Cancel'),
- handler: 'cancel'
- }
- ]
+ handler: 'cancel',
+ },
+ ],
});
running: false,
qemu: {
onlineHelp: 'qm_migration',
- commonName: 'VM'
+ commonName: 'VM',
},
lxc: {
onlineHelp: 'pct_migration',
- commonName: 'CT'
+ commonName: 'CT',
},
migration: {
possible: true,
mode: undefined,
allowedNodes: undefined,
overwriteLocalResourceCheck: false,
- hasLocalResources: false
- }
+ hasLocalResources: false,
+ },
},
} else {
return false;
}
- }
- }
+ },
+ },
},
controller: {
validityChange: function(panel, isValid) {
this.getViewModel().set('migration.possible', isValid);
this.checkMigratePreconditions();
- }
- }
+ },
+ },
},
init: function(view) {
view.setTitle(
- Ext.String.format('{0} {1} {2}', gettext('Migrate'), vm.get(view.vmtype).commonName, view.vmid)
+ Ext.String.format('{0} {1} {2}', gettext('Migrate'), vm.get(view.vmtype).commonName, view.vmid),
);
me.lookup('proxmoxHelpButton').setHelpConfig({
- onlineHelp: vm.get(view.vmtype).onlineHelp
+ onlineHelp: vm.get(view.vmtype).onlineHelp,
});
me.checkMigratePreconditions();
me.lookup('formPanel').isValid();
var values = me.lookup('formPanel').getValues();
var params = {
- target: values.target
+ target: values.target,
};
if (vm.get('migration.mode')) {
Ext.create('Proxmox.window.TaskViewer', {
upid: upid,
- extraTitle: extraTitle
+ extraTitle: extraTitle,
}).show();
view.close();
- }
+ },
});
},
migration.preconditions.push({
text: 'Storage (' + missing_storages + ') not available on selected target. ' +
'Start VM to use live storage migration or select other target node',
- severity: 'error'
+ severity: 'error',
});
}
}
migration.preconditions.push({
text: Ext.String.format('Can\'t migrate VM with local resources: {0}',
migrateStats.local_resources.join(', ')),
- severity: 'error'
+ severity: 'error',
});
} else {
migration.preconditions.push({
text: Ext.String.format('Migrate VM with local resources: {0}. ' +
'This might fail if resources aren\'t available on the target node.',
migrateStats.local_resources.join(', ')),
- severity: 'warning'
+ severity: 'warning',
});
}
}
migration.possible = false;
migration.preconditions.push({
text: "Can't live migrate VM with local cloudinit disk, use shared storage instead",
- severity: 'error'
+ severity: 'error',
});
} else {
return;
migration.possible = false;
migration.preconditions.push({
text: "Can't migrate VM with local CD/DVD",
- severity: 'error'
+ severity: 'error',
});
}
} else {
migration.preconditions.push({
text: Ext.String.format('Migration with local disk might take long: {0} {1}',
disk.volid, size_string),
- severity: 'warning'
+ severity: 'warning',
});
}
});
vm.set('migration', migration);
- }
+ },
});
},
checkLxcPreconditions: function(resetMigrationPossible) {
if (vm.get('running')) {
vm.set('migration.mode', 'restart');
}
- }
+ },
},
modal: true,
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
border: false,
items: [
name: 'source',
fieldLabel: gettext('Source node'),
bind: {
- value: '{nodename}'
- }
+ value: '{nodename}',
+ },
},
{
xtype: 'displayfield',
reference: 'migrationMode',
fieldLabel: gettext('Mode'),
bind: {
- value: '{setMigrationMode}'
- }
- }]
+ value: '{setMigrationMode}',
+ },
+ }],
},
{
xtype: 'container',
disallowedNodes: undefined,
onlineValidator: true,
listeners: {
- change: 'onTargetChange'
- }
+ change: 'onTargetChange',
+ },
},
{
xtype: 'pveStorageSelector',
autoSelect: false,
emptyText: gettext('Current layout'),
bind: {
- hidden: '{setStorageselectorHidden}'
- }
+ hidden: '{setStorageselectorHidden}',
+ },
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Force'),
autoEl: {
tag: 'div',
- 'data-qtip': 'Overwrite local resources unavailable check'
+ 'data-qtip': 'Overwrite local resources unavailable check',
},
bind: {
hidden: '{setLocalResourceCheckboxHidden}',
- value: '{migration.overwriteLocalResourceCheck}'
+ value: '{migration.overwriteLocalResourceCheck}',
},
listeners: {
- change: {fn: 'checkMigratePreconditions', extraArg: true}
- }
- }]
- }
- ]
+ change: {fn: 'checkMigratePreconditions', extraArg: true},
+ },
+ }],
+ },
+ ],
},
{
xtype: 'gridpanel',
return v;
}
},
- width: 35
+ width: 35,
},
{
text: 'Info',
dataIndex: 'text',
cellWrap: true,
- flex: 1
+ flex: 1,
}],
bind: {
hidden: '{!migration.preconditions.length}',
fields: ['severity', 'text'],
data: '{migration.preconditions}',
sorters: 'text',
- }
- }
- }
+ },
+ },
+ },
],
buttons: [
reference: 'proxmoxHelpButton',
onlineHelp: 'pct_migration',
listenToGlobalEvent: false,
- hidden: false
+ hidden: false,
},
'->',
{
text: gettext('Migrate'),
handler: 'startMigration',
bind: {
- disabled: '{!migration.possible}'
- }
- }
- ]
+ disabled: '{!migration.possible}',
+ },
+ },
+ ],
});
IDfield = Ext.create('Ext.form.field.Display', {
name: 'vmid',
value: me.vmid,
- fieldLabel: (me.vmtype === 'lxc') ? 'CT' : 'VM'
+ fieldLabel: (me.vmtype === 'lxc') ? 'CT' : 'VM',
});
} else {
IDfield = Ext.create('PVE.form.GuestIDSelector', {
name: 'vmid',
guestType: me.vmtype,
loadNextFreeID: true,
- validateExists: false
+ validateExists: false,
});
}
{
xtype: 'displayfield',
value: me.volidText || me.volid,
- fieldLabel: gettext('Source')
+ fieldLabel: gettext('Source'),
},
storagesel,
IDfield,
emptyText: gettext('Defaults to target storage restore limit'),
autoEl: {
tag: 'div',
- 'data-qtip': gettext("Use '0' to disable all bandwidth limits.")
- }
+ 'data-qtip': gettext("Use '0' to disable all bandwidth limits."),
+ },
},
{
xtype: 'fieldcontainer',
flex: 1,
autoEl: {
tag: 'div',
- 'data-qtip': gettext('Autogenerate unique properties, e.g., MAC addresses')
+ 'data-qtip': gettext('Autogenerate unique properties, e.g., MAC addresses'),
},
- checked: false
+ checked: false,
},
{
xtype: 'proxmoxcheckbox',
flex: 1,
fieldLabel: gettext('Start after restore'),
labelWidth: 105,
- checked: false
+ checked: false,
}],
},
];
xtype: 'proxmoxcheckbox',
name: 'unprivileged',
value: true,
- fieldLabel: gettext('Unprivileged container')
+ fieldLabel: gettext('Unprivileged container'),
});
}
border: false,
fieldDefaults: {
labelWidth: 100,
- anchor: '100%'
+ anchor: '100%',
},
- items: items
+ items: items,
});
var form = me.formPanel.getForm();
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskViewer', {
- upid: upid
+ upid: upid,
});
win.show();
me.close();
- }
+ },
});
};
var params = {
vmid: me.vmid || values.vmid,
- force: me.vmid ? 1 : 0
+ force: me.vmid ? 1 : 0,
};
if (values.unique) { params.unique = 1; }
if (values.start) { params.start = 1; }
} else {
doRestore(url, params);
}
- }
+ },
});
form.on('validitychange', function(f, valid) {
layout: 'auto',
border: false,
items: [ me.formPanel ],
- buttons: [ submitBtn ]
+ buttons: [ submitBtn ],
});
me.callParent();
- }
+ },
});
config: {
item: {
id: undefined,
- type: undefined
+ type: undefined,
},
url: undefined,
- params: {}
+ params: {},
},
getParams: function() {
if (!removeButton.isDisabled() && event.getKey() == event.ENTER) {
removeButton.fireEvent('click', removeButton, event);
}
- }
+ },
},
'button[reference=removeButton]': {
click: function() {
listeners: {
destroy: function () {
view.close();
- }
- }
+ },
+ },
});
win.show();
} else {
view.close();
}
- }
+ },
});
- }
- }
- }
+ },
+ },
+ },
},
items: [
xtype: 'component',
cls: [ Ext.baseCSSPrefix + 'message-box-icon',
Ext.baseCSSPrefix + 'message-box-warning',
- Ext.baseCSSPrefix + 'dlg-icon']
+ Ext.baseCSSPrefix + 'dlg-icon'],
},
{
xtype: 'container',
flex: 1,
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [
{
xtype: 'component',
- reference: 'messageCmp'
+ reference: 'messageCmp',
},
{
itemId: 'confirmField',
name: 'confirm',
labelWidth: 300,
hideTrigger: true,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
checked: false,
autoEl: {
tag: 'div',
- 'data-qtip': gettext('Remove from replication & backup jobs and HA resource configuration.')
- }
- }
- ]
- }
+ 'data-qtip': gettext('Remove from replication & backup jobs and HA resource configuration.'),
+ },
+ },
+ ],
+ },
],
buttons: [
{
reference: 'removeButton',
text: gettext('Remove'),
- disabled: true
- }
+ disabled: true,
+ },
],
initComponent : function() {
msg = gettext('Please enter the ID to confirm') +
' (' + item.id + ')';
confirmField.setFieldLabel(msg);
- }
+ },
});
{
xtype: 'proxmoxHelpButton',
onlineHelp: 'gui_my_settings',
- hidden: false
+ hidden: false,
},
'->',
{
text: gettext('Close'),
handler: function() {
this.up('window').close();
- }
- }
+ },
+ },
],
layout: 'hbox',
control: {
'#xtermjs form': {
dirtychange: 'set_button_status',
- validitychange: 'set_button_status'
+ validitychange: 'set_button_status',
},
'#xtermjs button': {
click: function(button) {
field.resetOriginalValue();
});
me.set_button_status();
- }
+ },
},
'button[name=reset]': {
click: function () {
}
window.location.reload();
- }
+ },
},
'button[name=clear-username]': {
click: function () {
usernamefield.setValue(Proxmox.Utils.noneText);
sp.clear('login-username');
- }
+ },
},
'grid[reference=dashboard-storages]': {
selectionchange: function(grid, selected) {
});
me.getSelectionModel().select(items);
me.resumeEvent('selectionchange');
- }
+ },
},
'field[reference=summarycolumns]': {
change: function(el, newValue) {
var sp = Ext.state.Manager.getProvider();
sp.set('summarycolumns', newValue);
- }
+ },
},
'field[reference=guestNotesCollapse]': {
change: function(e, v) {
Ext.state.Manager.getProvider().set('guest-notes-collapse', v);
},
},
- }
+ },
},
items: [{
margin: '5',
layout: {
type: 'vbox',
- align: 'left'
+ align: 'left',
},
defaults: {
width: '100%',
- margin: '0 0 10 0'
+ margin: '0 0 10 0',
},
items: [
{
xtype: 'displayfield',
fieldLabel: gettext('Dashboard Storages'),
labelAlign: 'left',
- labelWidth: '50%'
+ labelWidth: '50%',
},
{
xtype: 'grid',
maxHeight: 150,
reference: 'dashboard-storages',
selModel: {
- selType: 'checkboxmodel'
+ selType: 'checkboxmodel',
},
columns: [{
header: gettext('Name'),
dataIndex: 'storage',
- flex: 1
- },{
+ flex: 1,
+ }, {
header: gettext('Node'),
dataIndex: 'node',
- flex: 1
+ flex: 1,
}],
store: {
type: 'diff',
rstore: PVE.data.ResourceStore,
filters: [{
property: 'type',
- value: 'storage'
+ value: 'storage',
}],
- sorters: [ 'node','storage']
- }
+ sorters: [ 'node', 'storage'],
+ },
},
{
xtype: 'box',
- autoEl: { tag: 'hr'}
+ autoEl: { tag: 'hr'},
},
{
xtype: 'container',
stateId: 'login-username',
reference: 'savedUserName',
flex: 1,
- value: ''
+ value: '',
},
{
xtype: 'button',
text: gettext('Reset'),
name: 'clear-username',
},
- ]
+ ],
},
{
xtype: 'box',
- autoEl: { tag: 'hr'}
+ autoEl: { tag: 'hr'},
},
{
xtype: 'container',
tooltip: gettext('Reset all layout changes (for example, column widths)'),
name: 'reset',
},
- ]
+ ],
},
{
xtype: 'box',
- autoEl: { tag: 'hr'}
+ autoEl: { tag: 'hr'},
},
{
xtype: 'proxmoxKVComboBox',
['auto', 'auto (Collapse if empty)'],
],
},
- ]
+ ],
},
{
xtype: 'container',
width: '100%',
// right margin ensures that the right border of the fieldsets
// is shown
- margin: '0 2 10 0'
+ margin: '0 2 10 0',
},
items:[
{
border: false,
layout: {
type: 'vbox',
- algin: 'left'
+ algin: 'left',
},
defaults: {
width: '100%',
name: 'fontFamily',
reference: 'fontFamily',
emptyText: Proxmox.Utils.defaultText,
- fieldLabel: gettext('Font-Family')
+ fieldLabel: gettext('Font-Family'),
},
{
xtype: 'proxmoxintegerfield',
name: 'fontSize',
reference: 'fontSize',
minValue: 1,
- fieldLabel: gettext('Font-Size')
+ fieldLabel: gettext('Font-Size'),
},
{
xtype: 'numberfield',
name: 'letterSpacing',
reference: 'letterSpacing',
emptyText: Proxmox.Utils.defaultText,
- fieldLabel: gettext('Letter Spacing')
+ fieldLabel: gettext('Letter Spacing'),
},
{
xtype: 'numberfield',
minValue: 0.1,
reference: 'lineHeight',
emptyText: Proxmox.Utils.defaultText,
- fieldLabel: gettext('Line Height')
+ fieldLabel: gettext('Line Height'),
},
{
xtype: 'container',
layout: {
type: 'hbox',
- pack: 'end'
+ pack: 'end',
},
defaults: {
margin: '0 0 0 5',
xtype: 'button',
reference: 'xtermreset',
disabled: true,
- text: gettext('Reset')
+ text: gettext('Reset'),
},
{
xtype: 'button',
reference: 'xtermsave',
disabled: true,
- text: gettext('Save')
- }
- ]
- }
- ]
- }]
- },{
+ text: gettext('Save'),
+ },
+ ],
+ },
+ ],
+ }],
+ }, {
xtype: 'fieldset',
title: gettext('noVNC Settings'),
items: [
inputValue: 'scale',
boxLabel: 'Local Scaling',
checked: true,
- },{
+ }, {
xtype: 'radiofield',
name: 'noVNCScalingField',
inputValue: 'off',
boxLabel: 'Off',
margin: '0 0 0 10',
- }
+ },
],
listeners: {
change: function(el, newValue, undefined) {
var sp = Ext.state.Manager.getProvider();
sp.set('novnc-scaling', newValue.noVNCScalingField);
- }
+ },
},
},
- ]
+ ],
},
- ]
+ ],
}],
});
let res = response.result.data;
let enabled = PVE.Parser.parsePropertyString(res.agent, 'enabled');
vm.set('guestAgentEnabled', !!PVE.Parser.parseBoolean(enabled.enabled));
- }
+ },
});
}
value: me.snapname,
fieldLabel: gettext('Name'),
vtype: 'ConfigId',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'displayfield',
disabled: me.isCreate,
name: 'snaptime',
renderer: PVE.Utils.render_timestamp_human_readable,
- fieldLabel: gettext('Timestamp')
+ fieldLabel: gettext('Timestamp'),
},
{
xtype: 'proxmoxcheckbox',
uncheckedValue: 0,
defaultValue: 0,
checked: 1,
- fieldLabel: gettext('Include RAM')
+ fieldLabel: gettext('Include RAM'),
},
{
xtype: 'textareafield',
grow: true,
editable: !me.viewonly,
name: 'description',
- fieldLabel: gettext('Description')
+ fieldLabel: gettext('Description'),
},
{
xtype: 'displayfield',
sorters: [
{
property : 'key',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
columns: [
{
header: gettext('Value'),
flex: 1,
dataIndex: 'value',
- }
- ]
- }
+ },
+ ],
+ },
];
me.url = `/nodes/${me.nodename}/${me.type}/${me.vmid}/snapshot`;
summarystore.fireEvent('refresh', summarystore);
me.setValues(response.result.data);
- }
+ },
});
- }
+ },
});
name: 'order',
defaultValue: '',
emptyText: 'any',
- fieldLabel: gettext('Start/Shutdown order')
+ fieldLabel: gettext('Start/Shutdown order'),
},
{
xtype: 'textfield',
name: 'up',
defaultValue: '',
emptyText: 'default',
- fieldLabel: gettext('Startup delay')
+ fieldLabel: gettext('Startup delay'),
},
{
xtype: 'textfield',
name: 'down',
defaultValue: '',
emptyText: 'default',
- fieldLabel: gettext('Shutdown timeout')
- }
+ fieldLabel: gettext('Shutdown timeout'),
+ },
];
me.callParent();
- }
+ },
});
Ext.define('PVE.window.StartupEdit', {
Ext.applyIf(me, {
subject: gettext('Start/Shutdown order'),
fieldDefaults: {
- labelWidth: 120
+ labelWidth: 120,
},
- items: [ ipanel ]
+ items: [ ipanel ],
});
me.callParent();
var i, confid;
me.vmconfig = response.result.data;
ipanel.setStartup(me.vmconfig.startup);
- }
+ },
});
- }
+ },
});
margins: '5 5 0 5',
fieldDefaults: {
labelWidth: 100,
- anchor: '100%'
+ anchor: '100%',
},
items: [{
itemId: 'wizcontent',
},
tabchange: function(tp, newcard, oldcard) {
tabchange(tp, newcard, oldcard);
- }
+ },
},
- items: tabs
- }]
- }
+ items: tabs,
+ }],
+ },
],
fbar: [
{
xtype: 'proxmoxHelpButton',
- itemId: 'help'
+ itemId: 'help',
},
'->',
{
});
sp.set('proxmox-advanced-cb', val);
- }
- }
+ },
+ },
},
{
text: gettext('Back'),
if (ntab) {
tp.setActiveTab(ntab);
}
- }
+ },
},
{
text: gettext('Next'),
tp.setActiveTab(ntab);
}
- }
+ },
},
{
text: gettext('Finish'),
var tp = me.down('#wizcontent');
var atab = tp.getActiveTab();
atab.onSubmit();
- }
- }
- ]
+ },
+ },
+ ],
});
me.callParent();
field.on('change', validcheck);
field.on('validitychange', validcheck);
});
- }
+ },
});
projects / pve-manager.git / commitdiff