// ExtJS related things
-PVE.Utils.toolkit = 'extjs';
+Proxmox.Utils.toolkit = 'extjs';
// do not send '_dc' parameter
Ext.Ajax.disableCaching = false;
// custom Vtypes
Ext.apply(Ext.form.field.VTypes, {
IPAddress: function(v) {
- return PVE.Utils.IP4_match.test(v);
+ return Proxmox.Utils.IP4_match.test(v);
},
IPAddressText: gettext('Example') + ': 192.168.1.1',
IPAddressMask: /[\d\.]/i,
IPCIDRAddress: function(v) {
- var result = PVE.Utils.IP4_cidr_match.exec(v);
+ var result = Proxmox.Utils.IP4_cidr_match.exec(v);
// limits according to JSON Schema see
// pve-common/src/PVE/JSONSchema.pm
return (result !== null && result[1] >= 8 && result[1] <= 32);
IPCIDRAddressMask: /[\d\.\/]/i,
IP6Address: function(v) {
- return PVE.Utils.IP6_match.test(v);
+ return Proxmox.Utils.IP6_match.test(v);
},
IP6AddressText: gettext('Example') + ': 2001:DB8::42',
IP6AddressMask: /[A-Fa-f0-9:]/,
IP6CIDRAddress: function(v) {
- var result = PVE.Utils.IP6_cidr_match.exec(v);
+ var result = Proxmox.Utils.IP6_cidr_match.exec(v);
// limits according to JSON Schema see
// pve-common/src/PVE/JSONSchema.pm
return (result !== null && result[1] >= 8 && result[1] <= 120);
IP6PrefixLengthMask: /[0-9]/,
IP64Address: function(v) {
- return PVE.Utils.IP64_match.test(v);
+ return Proxmox.Utils.IP64_match.test(v);
},
IP64AddressText: gettext('Example') + ': 192.168.1.1 2001:DB8::42',
IP64AddressMask: /[A-Fa-f0-9\.:]/,
HttpProxyText: gettext('Example') + ": http://username:password@host:port/",
DnsName: function(v) {
- return PVE.Utils.DnsName_match.test(v);
+ return Proxmox.Utils.DnsName_match.test(v);
},
DnsNameText: gettext('This is not a valid DNS name'),
continue;
}
- if (!PVE.Utils.HostPort_match.test(list[i]) &&
- !PVE.Utils.HostPortBrackets_match.test(list[i]) &&
- !PVE.Utils.IP6_dotnotation_match.test(list[i])) {
+ if (!Proxmox.Utils.HostPort_match.test(list[i]) &&
+ !Proxmox.Utils.HostPortBrackets_match.test(list[i]) &&
+ !Proxmox.Utils.IP6_dotnotation_match.test(list[i])) {
return false;
}
}
return fa.join(', ');
},
- network_iface_types: {
- eth: gettext("Network Device"),
- bridge: 'Linux Bridge',
- bond: 'Linux Bond',
- OVSBridge: 'OVS Bridge',
- OVSBond: 'OVS Bond',
- OVSPort: 'OVS Port',
- OVSIntPort: 'OVS IntPort'
- },
-
- render_network_iface_type: function(value) {
- return PVE.Utils.network_iface_types[value] ||
- PVE.Utils.unknownText;
- },
-
render_qemu_bios: function(value) {
if (!value) {
- return PVE.Utils.defaultText + ' (SeaBIOS)';
+ return Proxmox.Utils.defaultText + ' (SeaBIOS)';
} else if (value === 'seabios') {
return "SeaBIOS";
} else if (value === 'ovmf') {
render_scsihw: function(value) {
if (!value) {
- return PVE.Utils.defaultText + ' (LSI 53C895A)';
+ return Proxmox.Utils.defaultText + ' (LSI 53C895A)';
} else if (value === 'lsi') {
return 'LSI 53C895A';
} else if (value === 'lsi53c810') {
},
render_kvm_language: function (value) {
- if (!value) {
- return PVE.Utils.defaultText;
+ if (!value || value === '__default__') {
+ return Proxmox.Utils.defaultText;
}
var text = PVE.Utils.kvm_keymaps[value];
if (text) {
render_console_viewer: function(value) {
if (!value || value === '__default__') {
- return PVE.Utils.defaultText + ' (HTML5)';
+ return Proxmox.Utils.defaultText + ' (HTML5)';
} else if (value === 'vv') {
return 'SPICE (remote-viewer)';
} else if (value === 'html5') {
}
},
- language_map: {
- zh_CN: 'Chinese',
- ca: 'Catalan',
- da: 'Danish',
- en: 'English',
- eu: 'Euskera (Basque)',
- fr: 'French',
- de: 'German',
- it: 'Italian',
- ja: 'Japanese',
- nb: 'Norwegian (Bokmal)',
- nn: 'Norwegian (Nynorsk)',
- fa: 'Persian (Farsi)',
- pl: 'Polish',
- pt_BR: 'Portuguese (Brazil)',
- ru: 'Russian',
- sl: 'Slovenian',
- es: 'Spanish',
- sv: 'Swedish',
- tr: 'Turkish'
- },
-
- render_language: function (value) {
- if (!value) {
- return PVE.Utils.defaultText + ' (English)';
- }
- var text = PVE.Utils.language_map[value];
- if (text) {
- return text + ' (' + value + ')';
- }
- return value;
- },
-
- language_array: function() {
- var data = [['__default__', PVE.Utils.render_language('')]];
- Ext.Object.each(PVE.Utils.language_map, function(key, value) {
- data.push([key, PVE.Utils.render_language(value)]);
- });
-
- return data;
- },
-
render_kvm_vga_driver: function (value) {
if (!value) {
- return PVE.Utils.defaultText;
+ return Proxmox.Utils.defaultText;
}
var text = PVE.Utils.kvm_vga_drivers[value];
if (text) {
return res;
},
- authOK: function() {
- return Ext.util.Cookies.get('PVEAuthCookie');
- },
-
- authClear: function() {
- Ext.util.Cookies.clear("PVEAuthCookie");
- },
-
- // fixme: remove - not needed?
- gridLineHeigh: function() {
- return 21;
-
- //if (Ext.isGecko)
- //return 23;
- //return 21;
- },
-
- extractRequestError: function(result, verbose) {
- var msg = gettext('Successful');
-
- if (!result.success) {
- msg = gettext("Unknown error");
- if (result.message) {
- msg = result.message;
- if (result.status) {
- msg += ' (' + result.status + ')';
- }
- }
- if (verbose && Ext.isObject(result.errors)) {
- msg += "<br>";
- Ext.Object.each(result.errors, function(prop, desc) {
- msg += "<br><b>" + Ext.htmlEncode(prop) + "</b>: " +
- Ext.htmlEncode(desc);
- });
- }
- }
-
- return msg;
- },
-
extractFormActionError: function(action) {
var msg;
switch (action.failureType) {
break;
case Ext.form.action.Action.LOAD_FAILURE:
case Ext.form.action.Action.SERVER_INVALID:
- msg = PVE.Utils.extractRequestError(action.result, true);
+ msg = Proxmox.Utils.extractRequestError(action.result, true);
break;
}
return msg;
},
- // Ext.Ajax.request
- API2Request: function(reqOpts) {
-
- var newopts = Ext.apply({
- waitMsg: gettext('Please wait...')
- }, reqOpts);
-
- if (!newopts.url.match(/^\/api2/)) {
- newopts.url = '/api2/extjs' + newopts.url;
- }
- delete newopts.callback;
-
- var createWrapper = function(successFn, callbackFn, failureFn) {
- Ext.apply(newopts, {
- success: function(response, options) {
- if (options.waitMsgTarget) {
- if (PVE.Utils.toolkit === 'touch') {
- options.waitMsgTarget.setMasked(false);
- } else {
- options.waitMsgTarget.setLoading(false);
- }
- }
- var result = Ext.decode(response.responseText);
- response.result = result;
- if (!result.success) {
- response.htmlStatus = PVE.Utils.extractRequestError(result, true);
- Ext.callback(callbackFn, options.scope, [options, false, response]);
- Ext.callback(failureFn, options.scope, [response, options]);
- return;
- }
- Ext.callback(callbackFn, options.scope, [options, true, response]);
- Ext.callback(successFn, options.scope, [response, options]);
- },
- failure: function(response, options) {
- if (options.waitMsgTarget) {
- if (PVE.Utils.toolkit === 'touch') {
- options.waitMsgTarget.setMasked(false);
- } else {
- options.waitMsgTarget.setLoading(false);
- }
- }
- response.result = {};
- try {
- response.result = Ext.decode(response.responseText);
- } catch(e) {}
- var msg = gettext('Connection error') + ' - server offline?';
- if (response.aborted) {
- msg = gettext('Connection error') + ' - aborted.';
- } else if (response.timedout) {
- msg = gettext('Connection error') + ' - Timeout.';
- } else if (response.status && response.statusText) {
- msg = gettext('Connection error') + ' ' + response.status + ': ' + response.statusText;
- }
- response.htmlStatus = msg;
- Ext.callback(callbackFn, options.scope, [options, false, response]);
- Ext.callback(failureFn, options.scope, [response, options]);
- }
- });
- };
-
- createWrapper(reqOpts.success, reqOpts.callback, reqOpts.failure);
-
- var target = newopts.waitMsgTarget;
- if (target) {
- if (PVE.Utils.toolkit === 'touch') {
- target.setMasked({ xtype: 'loadmask', message: newopts.waitMsg} );
- } else {
- // Note: ExtJS bug - this does not work when component is not rendered
- target.setLoading(newopts.waitMsg);
- }
- }
- Ext.Ajax.request(newopts);
- },
-
- assemble_field_data: function(values, data) {
- if (Ext.isObject(data)) {
- Ext.Object.each(data, function(name, val) {
- if (values.hasOwnProperty(name)) {
- var bucket = values[name];
- if (!Ext.isArray(bucket)) {
- bucket = values[name] = [bucket];
- }
- if (Ext.isArray(val)) {
- values[name] = bucket.concat(val);
- } else {
- bucket.push(val);
- }
- } else {
- values[name] = val;
- }
- });
- }
- },
-
- checked_command: function(orig_cmd) {
- PVE.Utils.API2Request({
- url: '/nodes/localhost/subscription',
- method: 'GET',
- //waitMsgTarget: me,
- failure: function(response, opts) {
- Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- },
- success: function(response, opts) {
- var data = response.result.data;
-
- if (data.status !== 'Active') {
- Ext.Msg.show({
- title: gettext('No valid subscription'),
- icon: Ext.Msg.WARNING,
- msg: PVE.Utils.noSubKeyHtml,
- buttons: Ext.Msg.OK,
- callback: function(btn) {
- if (btn !== 'ok') {
- return;
- }
- orig_cmd();
- }
- });
- } else {
- orig_cmd();
- }
- }
- });
- },
-
- task_desc_table: {
- diskinit: [ 'Disk', gettext('Initialize Disk with GPT') ],
- vncproxy: [ 'VM/CT', gettext('Console') ],
- spiceproxy: [ 'VM/CT', gettext('Console') + ' (Spice)' ],
- vncshell: [ '', gettext('Shell') ],
- spiceshell: [ '', gettext('Shell') + ' (Spice)' ],
- qmsnapshot: [ 'VM', gettext('Snapshot') ],
- qmrollback: [ 'VM', gettext('Rollback') ],
- qmdelsnapshot: [ 'VM', gettext('Delete Snapshot') ],
- qmcreate: [ 'VM', gettext('Create') ],
- qmrestore: [ 'VM', gettext('Restore') ],
- qmdestroy: [ 'VM', gettext('Destroy') ],
- qmigrate: [ 'VM', gettext('Migrate') ],
- qmclone: [ 'VM', gettext('Clone') ],
- qmmove: [ 'VM', gettext('Move disk') ],
- qmtemplate: [ 'VM', gettext('Convert to template') ],
- qmstart: [ 'VM', gettext('Start') ],
- qmstop: [ 'VM', gettext('Stop') ],
- qmreset: [ 'VM', gettext('Reset') ],
- qmshutdown: [ 'VM', gettext('Shutdown') ],
- qmsuspend: [ 'VM', gettext('Suspend') ],
- qmresume: [ 'VM', gettext('Resume') ],
- qmconfig: [ 'VM', gettext('Configure') ],
- vzsnapshot: [ 'CT', gettext('Snapshot') ],
- vzrollback: [ 'CT', gettext('Rollback') ],
- vzdelsnapshot: [ 'CT', gettext('Delete Snapshot') ],
- vzcreate: ['CT', gettext('Create') ],
- vzrestore: ['CT', gettext('Restore') ],
- vzdestroy: ['CT', gettext('Destroy') ],
- vzmigrate: [ 'CT', gettext('Migrate') ],
- vzclone: [ 'CT', gettext('Clone') ],
- vztemplate: [ 'CT', gettext('Convert to template') ],
- vzstart: ['CT', gettext('Start') ],
- vzstop: ['CT', gettext('Stop') ],
- vzmount: ['CT', gettext('Mount') ],
- vzumount: ['CT', gettext('Unmount') ],
- vzshutdown: ['CT', gettext('Shutdown') ],
- vzsuspend: [ 'CT', gettext('Suspend') ],
- vzresume: [ 'CT', gettext('Resume') ],
- hamigrate: [ 'HA', gettext('Migrate') ],
- hastart: [ 'HA', gettext('Start') ],
- hastop: [ 'HA', gettext('Stop') ],
- srvstart: ['SRV', gettext('Start') ],
- srvstop: ['SRV', gettext('Stop') ],
- srvrestart: ['SRV', gettext('Restart') ],
- srvreload: ['SRV', gettext('Reload') ],
- cephcreatemon: ['Ceph Monitor', gettext('Create') ],
- cephdestroymon: ['Ceph Monitor', gettext('Destroy') ],
- cephcreateosd: ['Ceph OSD', gettext('Create') ],
- cephdestroyosd: ['Ceph OSD', gettext('Destroy') ],
- cephcreatepool: ['Ceph Pool', gettext('Create') ],
- cephdestroypool: ['Ceph Pool', gettext('Destroy') ],
- imgcopy: ['', gettext('Copy data') ],
- imgdel: ['', gettext('Erase data') ],
- download: ['', gettext('Download') ],
- vzdump: ['', gettext('Backup') ],
- aptupdate: ['', gettext('Update package database') ],
- startall: [ '', gettext('Start all VMs and Containers') ],
- stopall: [ '', gettext('Stop all VMs and Containers') ],
- migrateall: [ '', gettext('Migrate all VMs and Containers') ]
- },
-
- format_task_description: function(type, id) {
- var farray = PVE.Utils.task_desc_table[type];
- if (!farray) {
- return type;
- }
- var prefix = farray[0];
- var text = farray[1];
- if (prefix) {
- return prefix + ' ' + id + ' - ' + text;
- }
- return text;
- },
-
- parse_task_upid: function(upid) {
- var task = {};
-
- var res = upid.match(/^UPID:(\S+):([0-9A-Fa-f]{8}):([0-9A-Fa-f]{8,9}):([0-9A-Fa-f]{8}):([^:\s]+):([^:\s]*):([^:\s]+):$/);
- if (!res) {
- throw "unable to parse upid '" + upid + "'";
- }
- task.node = res[1];
- task.pid = parseInt(res[2], 16);
- task.pstart = parseInt(res[3], 16);
- task.starttime = parseInt(res[4], 16);
- task.type = res[5];
- task.id = res[6];
- task.user = res[7];
-
- task.desc = PVE.Utils.format_task_description(task.type, task.id);
-
- return task;
- },
-
- format_size: function(size) {
- /*jslint confusion: true */
-
- var units = ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi', 'Yi'];
- var num = 0;
-
- while (size >= 1024 && ((num++)+1) < units.length) {
- size = size / 1024;
- }
-
- return size.toFixed((num > 0)?2:0) + " " + units[num] + "B";
- },
-
- format_html_bar: function(per, text) {
-
- return "<div class='pve-bar-wrap'>" + text + "<div class='pve-bar-border'>" +
- "<div class='pve-bar-inner' style='width:" + per + "%;'></div>" +
- "</div></div>";
-
- },
-
- format_cpu_bar: function(per1, per2, text) {
-
- return "<div class='pve-bar-border'>" +
- "<div class='pve-bar-inner' style='width:" + per1 + "%;'></div>" +
- "<div class='pve-bar-inner2' style='width:" + per2 + "%;'></div>" +
- "<div class='pve-bar-text'>" + text + "</div>" +
- "</div>";
- },
-
- format_large_bar: function(per, text) {
-
- if (!text) {
- text = per.toFixed(1) + "%";
- }
-
- return "<div class='pve-largebar-border'>" +
- "<div class='pve-largebar-inner' style='width:" + per + "%;'></div>" +
- "<div class='pve-largebar-text'>" + text + "</div>" +
- "</div>";
- },
-
- format_duration_long: function(ut) {
-
- var days = Math.floor(ut / 86400);
- ut -= days*86400;
- var hours = Math.floor(ut / 3600);
- ut -= hours*3600;
- var mins = Math.floor(ut / 60);
- ut -= mins*60;
-
- var hours_str = '00' + hours.toString();
- hours_str = hours_str.substr(hours_str.length - 2);
- var mins_str = "00" + mins.toString();
- mins_str = mins_str.substr(mins_str.length - 2);
- var ut_str = "00" + ut.toString();
- ut_str = ut_str.substr(ut_str.length - 2);
-
- if (days) {
- var ds = days > 1 ? PVE.Utils.daysText : PVE.Utils.dayText;
- return days.toString() + ' ' + ds + ' ' +
- hours_str + ':' + mins_str + ':' + ut_str;
- } else {
- return hours_str + ':' + mins_str + ':' + ut_str;
- }
- },
-
format_duration_short: function(ut) {
if (ut < 60) {
return days.toFixed(1) + 'd';
},
- yesText: gettext('Yes'),
- noText: gettext('No'),
- enabledText: gettext('Enabled'),
- disabledText: gettext('Disabled'),
- noneText: gettext('none'),
- errorText: gettext('Error'),
- unknownText: gettext('Unknown'),
- defaultText: gettext('Default'),
- daysText: gettext('days'),
- dayText: gettext('day'),
- runningText: gettext('running'),
- stoppedText: gettext('stopped'),
- neverText: gettext('never'),
- totalText: gettext('Total'),
- usedText: gettext('Used'),
- directoryText: gettext('Directory'),
imagesText: gettext('Disk image'),
backupFileText: gettext('VZDump backup file'),
vztmplText: gettext('Container template'),
isoImageText: gettext('ISO image'),
containersText: gettext('Container'),
- stateText: gettext('State'),
- groupText: gettext('Group'),
-
- format_expire: function(date) {
- if (!date) {
- return PVE.Utils.neverText;
- }
- return Ext.Date.format(date, "Y-m-d");
- },
format_storage_type: function(value, md, record) {
if (value === 'rbd' && record) {
value = (record.get('monhost')?'rbd_ext':'pveceph');
}
if (value === 'dir') {
- return PVE.Utils.directoryText;
+ return Proxmox.Utils.directoryText;
} else if (value === 'nfs') {
return 'NFS';
} else if (value === 'glusterfs') {
} else if (value === 'drbd') {
return 'DRBD';
} else {
- return PVE.Utils.unknownText;
- }
- },
-
- format_boolean_with_default: function(value) {
- if (Ext.isDefined(value) && value !== '__default__') {
- return value ? PVE.Utils.yesText : PVE.Utils.noText;
+ return Proxmox.Utils.unknownText;
}
- return PVE.Utils.defaultText;
- },
-
- format_boolean: function(value) {
- return value ? PVE.Utils.yesText : PVE.Utils.noText;
- },
-
- format_neg_boolean: function(value) {
- return !value ? PVE.Utils.yesText : PVE.Utils.noText;
- },
-
- format_enabled_toggle: function(value) {
- return value ? PVE.Utils.enabledText :PVE.Utils.disabledText;
},
format_ha: function(value) {
- var text = PVE.Utils.noneText;
+ var text = Proxmox.Utils.noneText;
if (value.managed) {
- text = value.state || PVE.Utils.noneText;
+ text = value.state || Proxmox.Utils.noneText;
- text += ', ' + PVE.Utils.groupText + ': ';
- text += value.group || PVE.Utils.noneText;
+ text += ', ' + Proxmox.Utils.groupText + ': ';
+ text += value.group || Proxmox.Utils.noneText;
}
return text;
return '';
}
- return PVE.Utils.format_size(value);
+ return Proxmox.Utils.format_size(value);
},
render_bandwidth: function(value) {
return '';
}
- return PVE.Utils.format_size(value) + '/s';
- },
-
- render_timestamp: function(value, metaData, record, rowIndex, colIndex, store) {
- var servertime = new Date(value * 1000);
- return Ext.Date.format(servertime, 'Y-m-d H:i:s');
+ return Proxmox.Utils.format_size(value) + '/s';
},
render_timestamp_human_readable: function(value) {
return fa + value;
},
- render_uptime: function(value, metaData, record, rowIndex, colIndex, store) {
-
- var uptime = value;
-
- if (uptime === undefined) {
- return '';
- }
-
- if (uptime <= 0) {
- return '-';
- }
-
- return PVE.Utils.format_duration_long(uptime);
- },
-
render_support_level: function(value, metaData, record) {
return PVE.Utils.support_level_hash[value] || '-';
},
var type = record.data.type;
var id = record.data.id;
- return PVE.Utils.format_task_description(type, id);
+ return Proxmox.Utils.format_task_description(type, id);
},
/* render functions for new status panel */
return PVE.Utils.render_size_usage(record.used, record.total);
},
- dialog_title: function(subject, create, isAdd) {
- if (create) {
- if (isAdd) {
- return gettext('Add') + ': ' + subject;
- } else {
- return gettext('Create') + ': ' + subject;
- }
- } else {
- return gettext('Edit') + ': ' + subject;
- }
- },
-
windowHostname: function() {
- return window.location.hostname.replace(PVE.Utils.IP6_bracket_match,
+ return window.location.hostname.replace(Proxmox.Utils.IP6_bracket_match,
function(m, addr, offset, original) { return addr; });
},
if (viewer === 'html5') {
PVE.Utils.openVNCViewer(vmtype, vmid, nodename, vmname);
} else if (viewer === 'xtermjs') {
- PVE.Utils.openXtermJSviewer(vmtype, vmid, nodename, vmname);
+ Proxmox.Utils.openXtermJsViewer(vmtype, vmid, nodename, vmname);
} else if (viewer === 'vv') {
var url;
var params = { proxy: PVE.Utils.windowHostname() };
return dv;
},
- openXtermJSviewer: function(vmtype, vmid, nodename, vmname) {
- var url = Ext.urlEncode({
- console: vmtype, // kvm, lxc, upgrade or shell
- xtermjs: 1,
- vmid: vmid,
- vmname: vmname,
- node: nodename
- });
- var nw = window.open("?" + url, '_blank', 'toolbar=no,location=no,status=no,menubar=no,resizable=yes,width=800,height=420');
- nw.focus();
- },
-
openVNCViewer: function(vmtype, vmid, nodename, vmname) {
var url = Ext.urlEncode({
console: vmtype, // kvm, lxc, upgrade or shell
}
};
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: url,
params: params,
method: 'POST',
});
},
- // comp.setLoading() is buggy in ExtJS 4.0.7, so we
- // use el.mask() instead
- setErrorMask: function(comp, msg) {
- var el = comp.el;
- if (!el) {
- return;
- }
- if (!msg) {
- el.unmask();
- } else {
- if (msg === true) {
- el.mask(gettext("Loading..."));
- } else {
- el.mask(msg);
- }
- }
- },
-
- monStoreErrors: function(me, store) {
- me.mon(store, 'beforeload', function(s, operation, eOpts) {
- if (!me.loadCount) {
- me.loadCount = 0; // make sure it is numeric
- PVE.Utils.setErrorMask(me, true);
- }
- });
-
- // only works with 'pve' proxy
- me.mon(store.proxy, 'afterload', function(proxy, request, success) {
- me.loadCount++;
-
- if (success) {
- PVE.Utils.setErrorMask(me, false);
- return;
- }
-
- var msg;
- /*jslint nomen: true */
- var operation = request._operation;
- var error = operation.getError();
- if (error.statusText) {
- msg = error.statusText + ' (' + error.status + ')';
- } else {
- msg = gettext('Connection error');
- }
- PVE.Utils.setErrorMask(me, msg);
- });
- },
-
openTreeConsole: function(tree, record, item, index, e) {
e.stopEvent();
var nodename = record.data.node;
var vmid = record.data.vmid;
var vmname = record.data.name;
if (record.data.type === 'qemu' && !record.data.template) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + nodename + '/qemu/' + vmid + '/status/current',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
}
menu.showAt(event.getXY());
- }},
+ },
// helper for deleting field which are set to there default values
delete_if_default: function(values, fieldname, default_val, create) {
delete values[fieldname];
}
- },
+ }
+},
singleton: true,
constructor: function() {
var me = this;
Ext.apply(me, me.utilities);
-
- var IPV4_OCTET = "(?:25[0-5]|(?:[1-9]|1[0-9]|2[0-4])?[0-9])";
- var IPV4_REGEXP = "(?:(?:" + IPV4_OCTET + "\\.){3}" + IPV4_OCTET + ")";
- var IPV6_H16 = "(?:[0-9a-fA-F]{1,4})";
- var IPV6_LS32 = "(?:(?:" + IPV6_H16 + ":" + IPV6_H16 + ")|" + IPV4_REGEXP + ")";
-
-
- me.IP4_match = new RegExp("^(?:" + IPV4_REGEXP + ")$");
- me.IP4_cidr_match = new RegExp("^(?:" + IPV4_REGEXP + ")\/([0-9]{1,2})$");
-
- var IPV6_REGEXP = "(?:" +
- "(?:(?:" + "(?:" + IPV6_H16 + ":){6})" + IPV6_LS32 + ")|" +
- "(?:(?:" + "::" + "(?:" + IPV6_H16 + ":){5})" + IPV6_LS32 + ")|" +
- "(?:(?:(?:" + IPV6_H16 + ")?::" + "(?:" + IPV6_H16 + ":){4})" + IPV6_LS32 + ")|" +
- "(?:(?:(?:(?:" + IPV6_H16 + ":){0,1}" + IPV6_H16 + ")?::" + "(?:" + IPV6_H16 + ":){3})" + IPV6_LS32 + ")|" +
- "(?:(?:(?:(?:" + IPV6_H16 + ":){0,2}" + IPV6_H16 + ")?::" + "(?:" + IPV6_H16 + ":){2})" + IPV6_LS32 + ")|" +
- "(?:(?:(?:(?:" + IPV6_H16 + ":){0,3}" + IPV6_H16 + ")?::" + "(?:" + IPV6_H16 + ":){1})" + IPV6_LS32 + ")|" +
- "(?:(?:(?:(?:" + IPV6_H16 + ":){0,4}" + IPV6_H16 + ")?::" + ")" + IPV6_LS32 + ")|" +
- "(?:(?:(?:(?:" + IPV6_H16 + ":){0,5}" + IPV6_H16 + ")?::" + ")" + IPV6_H16 + ")|" +
- "(?:(?:(?:(?:" + IPV6_H16 + ":){0,7}" + IPV6_H16 + ")?::" + ")" + ")" +
- ")";
-
- me.IP6_match = new RegExp("^(?:" + IPV6_REGEXP + ")$");
- me.IP6_cidr_match = new RegExp("^(?:" + IPV6_REGEXP + ")\/([0-9]{1,3})$");
- me.IP6_bracket_match = new RegExp("^\\[(" + IPV6_REGEXP + ")\\]");
-
- me.IP64_match = new RegExp("^(?:" + IPV6_REGEXP + "|" + IPV4_REGEXP + ")$");
-
- var DnsName_REGEXP = "(?:(([a-zA-Z0-9]([a-zA-Z0-9\\-]*[a-zA-Z0-9])?)\\.)*([A-Za-z0-9]([A-Za-z0-9\\-]*[A-Za-z0-9])?))";
- me.DnsName_match = new RegExp("^" + DnsName_REGEXP + "$");
-
- me.HostPort_match = new RegExp("^(" + IPV4_REGEXP + "|" + DnsName_REGEXP + ")(:\\d+)?$");
- me.HostPortBrackets_match = new RegExp("^\\[(?:" + IPV6_REGEXP + "|" + IPV4_REGEXP + "|" + DnsName_REGEXP + ")\\](:\\d+)?$");
- me.IP6_dotnotation_match = new RegExp("^" + IPV6_REGEXP + "(\\.\\d+)?$");
}
+
});
showLogin: function() {
var me = this;
- PVE.Utils.authClear();
+ Proxmox.Utils.authClear();
PVE.UserName = null;
me.loginData = null;
handler: function(data) {
me.login = null;
me.updateLoginData(data);
- PVE.Utils.checked_command(function() {}); // display subscription status
+ Proxmox.Utils.checked_command(function() {}); // display subscription status
}
});
}
me.callParent();
- if (!PVE.Utils.authOK()) {
+ if (!Proxmox.Utils.authOK()) {
me.showLogin();
} else {
if (me.loginData) {
Ext.TaskManager.start({
run: function() {
- var ticket = PVE.Utils.authOK();
+ var ticket = Proxmox.Utils.authOK();
if (!ticket || !PVE.UserName) {
return;
}
var cur = lay.getActiveItem();
if (comp) {
- PVE.Utils.setErrorMask(cont, false);
+ Proxmox.Utils.setErrorMask(cont, false);
comp.border = false;
cont.add(comp);
if (cur !== null && lay.getNext()) {
if (loginData) {
PVE.data.ResourceStore.startUpdate();
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/version',
method: 'GET',
success: function(response) {
load: function() {
var me = this;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: me.url,
waitMsgTarget: me,
failure: function(response, opts) {
load: function() {
var me = this;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: me.url,
waitMsgTarget: me,
failure: function(response, opts) {
sorters: [{ property: 'name'}]
});
- PVE.Utils.monStoreErrors(me, rstore);
+ Proxmox.Utils.monStoreErrors(me, rstore);
var service_cmd = function(cmd) {
var rec = sm.getSelection()[0];
Ext.Msg.alert(gettext('Error'), "entry has no host");
return;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: "/nodes/" + rec.data.host + "/ceph/" + cmd,
method: 'POST',
params: { service: "mon." + rec.data.name },
return;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: "/nodes/" + rec.data.host + "/ceph/mon/" +
rec.data.name,
method: 'DELETE',
header: gettext('Quorum'),
width: 70,
sortable: false,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
dataIndex: 'quorum'
},
{
header: gettext('Size'),
width: 60,
sortable: false,
- renderer: PVE.Utils.format_size,
+ renderer: Proxmox.Utils.format_size,
dataIndex: 'size'
},
{
var set_button_status; // defined later
var reload = function() {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: "/nodes/" + nodename + "/ceph/osd",
waitMsgTarget: me,
method: 'GET',
failure: function(response, opts) {
- PVE.Utils.setErrorMask(me, response.htmlStatus);
+ Proxmox.Utils.setErrorMask(me, response.htmlStatus);
},
success: function(response, opts) {
sm.deselectAll();
if (!(rec && (rec.data.id >= 0) && rec.data.host)) {
return;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: "/nodes/" + rec.data.host + "/ceph/osd/" +
rec.data.id + '/' + cmd,
waitMsgTarget: me,
if (!(rec && rec.data.name && rec.data.host)) {
return;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: "/nodes/" + rec.data.host + "/ceph/" + cmd,
params: { service: rec.data.name },
waitMsgTarget: me,
var noout_btn = new Ext.Button({
text: gettext('Set noout'),
handler: function() {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: "/nodes/" + nodename + "/ceph/flags/noout",
waitMsgTarget: me,
method: noout ? 'DELETE' : 'POST',
var store = Ext.create('PVE.data.DiffStore', { rstore: rstore });
- PVE.Utils.monStoreErrors(me, rstore);
+ Proxmox.Utils.monStoreErrors(me, rstore);
var create_btn = new Ext.Button({
text: gettext('Create'),
me.version = me.sp.get('ceph-version');
me.change_version(me.version);
- PVE.Utils.monStoreErrors(me,me.store);
+ Proxmox.Utils.monStoreErrors(me,me.store);
me.mon(me.store, 'load', me.updateAll, me);
me.on('destroy', me.store.stopUpdate);
me.store.startUpdate();
running: {
header: gettext('Online'),
type: 'boolean',
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
hidden: true,
convert: function(value, record) {
var info = record.data;
type: 'integer',
hidden: true,
sortable: true,
- renderer: PVE.Utils.format_size,
+ renderer: Proxmox.Utils.format_size,
width: 100
},
diskwrite: {
type: 'integer',
hidden: true,
sortable: true,
- renderer: PVE.Utils.format_size,
+ renderer: Proxmox.Utils.format_size,
width: 100
},
netin: {
type: 'integer',
hidden: true,
sortable: true,
- renderer: PVE.Utils.format_size,
+ renderer: Proxmox.Utils.format_size,
width: 100
},
netout: {
type: 'integer',
hidden: true,
sortable: true,
- renderer: PVE.Utils.format_size,
+ renderer: Proxmox.Utils.format_size,
width: 100
},
template: {
uptime: {
header: gettext('Uptime'),
type: 'integer',
- renderer: PVE.Utils.render_uptime,
+ renderer: Proxmox.Utils.render_uptime,
sortable: true,
width: 110
},
throw 'unknown data type';
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/access/acl',
params: params,
method: 'PUT',
}
});
- PVE.Utils.monStoreErrors(me, store);
+ Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
deleteEmpty: !me.isCreate,
value: '',
fieldLabel: gettext('TFA'),
- comboItems: [ ['__default__', PVE.Utils.noneText], ['oath', 'OATH'], ['yubico', 'Yubico']],
+ comboItems: [ ['__default__', Proxmox.Utils.noneText], ['oath', 'OATH'], ['yubico', 'Yubico']],
listeners: {
change: function(f, value) {
if (!me.rendered) {
name: 'oath_step',
value: '',
minValue: 10,
- emptyText: PVE.Utils.defaultText + ' (30)',
+ emptyText: Proxmox.Utils.defaultText + ' (30)',
submitEmptyText: false,
hidden: true,
fieldLabel: 'OATH time step'
value: '',
minValue: 6,
maxValue: 8,
- emptyText: PVE.Utils.defaultText + ' (6)',
+ emptyText: Proxmox.Utils.defaultText + ' (6)',
submitEmptyText: false,
hidden: true,
fieldLabel: 'OATH password length'
onGetValues: function(values) {
if (!values.port) {
if (!me.isCreate) {
- PVE.Utils.assemble_field_data(values, { 'delete': 'port' });
+ Proxmox.Utils.assemble_field_data(values, { 'delete': 'port' });
}
delete values.port;
}
dataIndex: 'uptime',
renderer: function(value) {
if (value) {
- return PVE.Utils.runningText;
+ return Proxmox.Utils.runningText;
} else {
- return PVE.Utils.stoppedText;
+ return Proxmox.Utils.stoppedText;
}
}
},
onGetValues: function(values) {
if (!values.node) {
if (!me.isCreate) {
- PVE.Utils.assemble_field_data(values, { 'delete': 'node' });
+ Proxmox.Utils.assemble_field_data(values, { 'delete': 'node' });
}
delete values.node;
}
}
});
- PVE.Utils.monStoreErrors(me, store);
+ Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
edit_btn, remove_btn
];
- PVE.Utils.monStoreErrors(me, store);
+ Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
cluster.text = gettext("Cluster") + ": ";
cluster.text += item.data.name + ", ";
cluster.text += gettext("Quorate") + ": ";
- cluster.text += PVE.Utils.format_boolean(item.data.quorate);
+ cluster.text += Proxmox.Utils.format_boolean(item.data.quorate);
if (item.data.quorate != 1) {
cluster.iconCls = PVE.Utils.get_health_icon('critical', true);
}
sortable: true,
dataIndex: 'uptime',
align: 'right',
- renderer: PVE.Utils.render_uptime
+ renderer: Proxmox.Utils.render_uptime
}
],
xtype: 'proxmoxtextfield',
name: 'http_proxy',
vtype: 'HttpProxy',
- emptyText: PVE.Utils.noneText,
+ emptyText: Proxmox.Utils.noneText,
deleteEmpty: true,
value: '',
fieldLabel: gettext('HTTP proxy')
name: 'mac_prefix',
regex: /^[a-f0-9]{2}(?::[a-f0-9]{2}){0,2}:?$/i,
regexText: gettext('Example') + ': 02:8f',
- emptyText: PVE.Utils.noneText,
+ emptyText: Proxmox.Utils.noneText,
deleteEmpty: true,
value: '',
fieldLabel: gettext('MAC address prefix')
required: true,
renderer: function(value) {
if (!value) {
- return PVE.Utils.noneText;
+ return Proxmox.Utils.noneText;
}
return value;
}
required: true,
renderer: function(value) {
if (!value) {
- return PVE.Utils.noneText;
+ return Proxmox.Utils.noneText;
}
return value;
}
edit_btn, remove_btn
];
- PVE.Utils.monStoreErrors(me, store);
+ Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
return value.replace(/\,/g, ' ');
};
- PVE.Utils.monStoreErrors(me, store);
+ Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
width: 80,
sortable: true,
dataIndex: 'shared',
- renderer: PVE.Utils.format_boolean
+ renderer: Proxmox.Utils.format_boolean
},
{
header: gettext('Enabled'),
width: 80,
sortable: true,
dataIndex: 'disable',
- renderer: PVE.Utils.format_neg_boolean
+ renderer: Proxmox.Utils.format_neg_boolean
}
],
listeners: {
var me = this;
var reload = function() {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/localhost/subscription',
method: 'GET',
waitMsgTarget: me,
header: gettext("Description"),
dataIndex: 'upid',
flex: 1,
- renderer: PVE.Utils.render_upid
+ renderer: Proxmox.Utils.render_upid
},
{
header: gettext("Status"),
return 'OK';
}
// metaData.attr = 'style="color:red;"';
- return PVE.Utils.errorText + ': ' + value;
+ return Proxmox.Utils.errorText + ': ' + value;
}
}
],
header: gettext('Enabled'),
width: 80,
sortable: true,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
dataIndex: 'enable'
},
{
header: gettext('Expire'),
width: 80,
sortable: true,
- renderer: PVE.Utils.format_expire,
+ renderer: Proxmox.Utils.format_expire,
dataIndex: 'expire'
},
{
header: gettext('Active'),
width: 60,
dataIndex: 'active',
- renderer: PVE.Utils.format_boolean
+ renderer: Proxmox.Utils.format_boolean
},
{
header: gettext('Comment'),
extend: 'PVE.form.KVComboBox',
alias: ['widget.CPUModelSelector'],
comboItems: [
- ['__default__', PVE.Utils.defaultText + ' (kvm64)'],
+ ['__default__', Proxmox.Utils.defaultText + ' (kvm64)'],
['486', '486'],
['athlon', 'athlon'],
['core2duo', 'core2duo'],
extend: 'PVE.form.KVComboBox',
alias: ['widget.CacheTypeSelector'],
comboItems: [
- ['__default__', PVE.Utils.defaultText + " (" + gettext('No cache') + ")"],
+ ['__default__', Proxmox.Utils.defaultText + " (" + gettext('No cache') + ")"],
['directsync', 'Direct sync'],
['writethrough', 'Write through'],
['writeback', 'Write back'],
extend: 'PVE.form.KVComboBox',
alias: ['widget.pveCompressionSelector'],
comboItems: [
- ['0', PVE.Utils.noneText],
+ ['0', Proxmox.Utils.noneText],
['lzo', 'LZO (' + gettext('fast') + ')'],
['gzip', 'GZIP (' + gettext('good') + ')']
]
header: gettext('Size'),
width: 100,
dataIndex: 'size',
- renderer: PVE.Utils.format_size
+ renderer: Proxmox.Utils.format_size
}
]
}
xtype: 'gridpanel',
focusOnToFront: false,
floating: true,
- emptyText: PVE.Utils.noneText,
+ emptyText: Proxmox.Utils.noneText,
width: 600,
height: 400,
scrollable: {
if (!Ext.isDefined(me.validateExists)) {
return;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: { vmid: newValue },
url: '/cluster/nextid',
method: 'GET',
me.callParent();
if (me.loadNextFreeID) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/cluster/nextid',
method: 'GET',
success: function(response, opts) {
Ext.define('PVE.form.LanguageSelector', {
extend: 'PVE.form.KVComboBox',
alias: ['widget.pveLanguageSelector'],
- comboItems: PVE.Utils.language_array()
+ comboItems: Proxmox.Utils.language_array()
});
header: gettext('Avail'),
width: 80,
dataIndex: 'avail',
- renderer: PVE.Utils.format_size
+ renderer: Proxmox.Utils.format_size
},
{
header: gettext('Capacity'),
width: 80,
dataIndex: 'total',
- renderer: PVE.Utils.format_size
+ renderer: Proxmox.Utils.format_size
}
]
},
{
header: gettext('Size'),
width: 100,
- renderer: PVE.Utils.format_size,
+ renderer: Proxmox.Utils.format_size,
dataIndex: 'size'
}
]
header: text,
required: true,
defaultValue: defaultValue || 0,
- renderer: PVE.Utils.format_enabled_toggle,
+ renderer: Proxmox.Utils.format_enabled_toggle,
editor: {
xtype: 'pveWindowEdit',
subject: text,
header: text,
required: true,
renderer: function(value) {
- return value || PVE.Utils.defaultText;
+ return value || Proxmox.Utils.defaultText;
},
editor: {
xtype: 'pveWindowEdit',
return;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: me.base_url + "/" + from,
method: 'PUT',
params: { moveto: to },
delete rule.pos;
delete rule.errors;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: me.base_url + '/' + pos.toString(),
method: 'PUT',
params: rule,
}
}));
- PVE.Utils.monStoreErrors(me, rstore);
+ Proxmox.Utils.monStoreErrors(me, rstore);
Ext.applyIf(me, {
store: store,
dataIndex: 'uptime',
renderer: function(value) {
if (value) {
- return PVE.Utils.runningText;
+ return Proxmox.Utils.runningText;
} else {
- return PVE.Utils.stoppedText;
+ return Proxmox.Utils.stoppedText;
}
}
},
throw "unknown resource type";
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/pools/' + me.pool,
method: 'PUT',
params: params,
var me = this.getView();
var controller = this;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: "/api2/extjs/nodes/" + me.nodename + "/replication/" + rec.data.id + "/schedule_now",
method: 'POST',
waitMsgTarget: me,
return gettext('syncing');
}
- return PVE.Utils.render_timestamp(value);
+ return Proxmox.Utils.render_timestamp(value);
}
},
{
return gettext('pending');
}
- return PVE.Utils.render_timestamp(value);
+ return Proxmox.Utils.render_timestamp(value);
}
}
);
return;
}
- PVE.Utils.monStoreErrors(me, me.rstore);
+ Proxmox.Utils.monStoreErrors(me, me.rstore);
me.on('destroy', me.rstore.stopUpdate);
me.rstore.startUpdate();
header: 'restricted',
width: 100,
sortable: true,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
dataIndex: 'restricted'
},
{
header: 'nofailback',
width: 100,
sortable: true,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
dataIndex: 'nofailback'
},
{
hidden: true
});
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/cluster/config/nodes',
method: 'GET',
failure: function(response) {
throw "no store given";
}
- PVE.Utils.monStoreErrors(me, me.rstore);
+ Proxmox.Utils.monStoreErrors(me, me.rstore);
var store = Ext.create('PVE.data.DiffStore', {
rstore: me.rstore,
throw "no rstore given";
}
- PVE.Utils.monStoreErrors(me, me.rstore);
+ Proxmox.Utils.monStoreErrors(me, me.rstore);
var store = Ext.create('PVE.data.DiffStore', {
rstore: me.rstore,
var vmname = me.pveSelNode.data.name;
var vm_command = function(cmd, params) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + nodename + '/lxc/' + vmid + "/status/" + cmd,
method: 'POST',
// hidde: suspended,
// disabled: stopped || suspended,
// handler: function() {
-// var msg = PVE.Utils.format_task_description('vzsuspend', vmid);
+// var msg = Proxmox.Utils.format_task_description('vzsuspend', vmid);
// Ext.Msg.confirm(gettext('Confirm'), msg, function(btn) {
// if (btn !== 'yes') {
// return;
iconCls: 'fa fa-fw fa-power-off',
disabled: stopped || suspended,
handler: function() {
- var msg = PVE.Utils.format_task_description('vzshutdown', vmid);
+ var msg = Proxmox.Utils.format_task_description('vzshutdown', vmid);
Ext.Msg.confirm(gettext('Confirm'), msg, function(btn) {
if (btn !== 'yes') {
return;
iconCls: 'fa fa-fw fa-stop',
disabled: stopped,
handler: function() {
- var msg = PVE.Utils.format_task_description('vzstop', vmid);
+ var msg = Proxmox.Utils.format_task_description('vzstop', vmid);
Ext.Msg.confirm(gettext('Confirm'), msg, function(btn) {
if (btn !== 'yes') {
return;
// text: gettext('Convert to template'),
// icon: '/pve2/images/forward.png',
// handler: function() {
-// var msg = PVE.Utils.format_task_description('vztemplate', vmid);
+// var msg = Proxmox.Utils.format_task_description('vztemplate', vmid);
// Ext.Msg.confirm(gettext('Confirm'), msg, function(btn) {
// if (btn !== 'yes') {
// return;
// }
//
-// PVE.Utils.API2Request({
+// Proxmox.Utils.API2Request({
// url: '/nodes/' + nodename + '/lxc/' + vmid + '/template',
// method: 'POST',
// failure: function(response, opts) {
});
var vm_command = function(cmd, params) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: base_url + "/status/" + cmd,
waitMsgTarget: me,
var stopBtn = Ext.create('Ext.menu.Item',{
text: gettext('Stop'),
disabled: !caps.vms['VM.PowerMgmt'],
- confirmMsg: PVE.Utils.format_task_description('vzstop', vmid),
+ confirmMsg: Proxmox.Utils.format_task_description('vzstop', vmid),
dangerous: true,
handler: function() {
vm_command("stop");
var shutdownBtn = Ext.create('PVE.button.Split', {
text: gettext('Shutdown'),
disabled: !caps.vms['VM.PowerMgmt'] || !running,
- confirmMsg: PVE.Utils.format_task_description('vzshutdown', vmid),
+ confirmMsg: Proxmox.Utils.format_task_description('vzshutdown', vmid),
handler: function() {
vm_command('shutdown');
},
delete kv.password;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + nodename + '/lxc',
waitMsgTarget: me,
method: 'POST',
var me = this;
var params = { disk: disk, size: '+' + size + 'G' };
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + me.nodename + '/lxc/' + me.vmid + '/resize',
waitMsgTarget: me,
load: function() {
var me = this;
- PVE.Utils.setErrorMask(me, true);
+ Proxmox.Utils.setErrorMask(me, true);
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: me.url,
failure: function(response, opts) {
- PVE.Utils.setErrorMask(me, gettext('Error') + ': ' + response.htmlStatus);
+ Proxmox.Utils.setErrorMask(me, gettext('Error') + ': ' + response.htmlStatus);
},
success: function(response, opts) {
- PVE.Utils.setErrorMask(me, false);
+ Proxmox.Utils.setErrorMask(me, false);
var result = Ext.decode(response.responseText);
var data = result.data || {};
me.dataCache = data;
"'" + rec.data.id + "'");
},
handler: function(btn, event, rec) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: me.url,
waitMsgTarget: me,
method: 'PUT',
header: gettext('Firewall'),
width: 80,
dataIndex: 'firewall',
- renderer: PVE.Utils.format_boolean
+ renderer: Proxmox.Utils.format_boolean
},
{
header: gettext('VLAN Tag'),
onboot: {
header: gettext('Start at boot'),
defaultValue: '',
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'pveWindowEdit',
subject: gettext('Start at boot'),
},
ostype: {
header: gettext('OS Type'),
- defaultValue: PVE.Utils.unknownText
+ defaultValue: Proxmox.Utils.unknownText
},
arch: {
header: gettext('Architecture'),
- defaultValue: PVE.Utils.unknownText
+ defaultValue: Proxmox.Utils.unknownText
},
console: {
header: '/dev/console',
defaultValue: 1,
- renderer: PVE.Utils.format_enabled_toggle,
+ renderer: Proxmox.Utils.format_enabled_toggle,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'pveWindowEdit',
subject: '/dev/console',
deleteEmpty: true,
value: '__default__',
comboItems: [
- ['__default__', PVE.Utils.defaultText + " (tty)"],
+ ['__default__', Proxmox.Utils.defaultText + " (tty)"],
['tty', "/dev/tty[X]"],
['console', "/dev/console"],
['shell', "shell"]
protection: {
header: gettext('Protection'),
defaultValue: false,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'pveWindowEdit',
subject: gettext('Protection'),
},
unprivileged: {
header: gettext('Unprivileged container'),
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
defaultValue: 0
}
};
defaultValue: 512,
tdCls: 'pve-itype-icon-memory',
renderer: function(value) {
- return PVE.Utils.format_size(value*1024*1024);
+ return Proxmox.Utils.format_size(value*1024*1024);
}
},
swap: {
defaultValue: 512,
tdCls: 'pve-itype-icon-swap',
renderer: function(value) {
- return PVE.Utils.format_size(value*1024*1024);
+ return Proxmox.Utils.format_size(value*1024*1024);
}
},
cores: {
},
rootfs: {
header: gettext('Root Disk'),
- defaultValue: PVE.Utils.noneText,
+ defaultValue: Proxmox.Utils.noneText,
editor: mpeditor,
tdCls: 'pve-itype-icon-storage'
},
};
var run_remove = function(b, e, rec) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/api2/extjs/' + baseurl,
waitMsgTarget: me,
method: 'PUT',
params.description = descr;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + me.nodename + '/lxc/' + me.vmid + "/snapshot",
waitMsgTarget: me,
update_snapshot: function(snapname, descr) {
var me = this;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: { description: descr },
url: '/nodes/' + me.nodename + '/lxc/' + me.vmid + "/snapshot/" +
snapname + '/config',
}
// else load data
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/lxc/' + me.vmid + "/snapshot/" +
me.snapname + '/config',
waitMsgTarget: me,
reload: function(repeat) {
var me = this;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/lxc/' + me.vmid + '/snapshot',
method: 'GET',
failure: function(response, opts) {
- PVE.Utils.setErrorMask(me, response.htmlStatus);
+ Proxmox.Utils.setErrorMask(me, response.htmlStatus);
me.load_task.delay(me.load_delay);
},
success: function(response, opts) {
- PVE.Utils.setErrorMask(me, false);
+ Proxmox.Utils.setErrorMask(me, false);
var digest = 'invalid';
var idhash = {};
var root = { name: '__root', expanded: true, children: [] };
}
});
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/lxc/' + me.vmid + '/feature',
params: { feature: 'snapshot' },
method: 'GET',
selModel: sm,
enableFn: valid_snapshot_rollback,
confirmMsg: function(rec) {
- return PVE.Utils.format_task_description('vzrollback', me.vmid) +
+ return Proxmox.Utils.format_task_description('vzrollback', me.vmid) +
" '" + rec.data.name + "'";
},
handler: function(btn, event) {
}
var snapname = rec.data.name;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/lxc/' + me.vmid + '/snapshot/' + snapname + '/rollback',
method: 'POST',
waitMsgTarget: me,
}
var snapname = rec.data.name;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/lxc/' + me.vmid + '/snapshot/' + snapname,
method: 'DELETE',
waitMsgTarget: me,
// width: 50,
// renderer: function(value, metaData, record) {
// if (record.data.name !== 'current') {
-// return PVE.Utils.format_boolean(value);
+// return Proxmox.Utils.format_boolean(value);
// }
// }
// },
});
var node_command = function(cmd) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: { command: cmd },
url: '/nodes/' + nodename + '/status',
method: 'POST',
}
}
- return v || PVE.Utils.noText;
+ return v || Proxmox.Utils.noText;
},
dataIndex: 'used'
},
width: 100,
align: 'right',
sortable: true,
- renderer: PVE.Utils.format_size,
+ renderer: Proxmox.Utils.format_size,
dataIndex: 'size'
},
{
align: 'right',
renderer: function(value) {
if (value) {
- return PVE.Utils.yesText;
+ return Proxmox.Utils.yesText;
} else {
- return PVE.Utils.noText;
+ return Proxmox.Utils.noText;
}
},
dataIndex: 'gpt'
handler: function() {
var rec = sm.getSelection()[0];
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/api2/extjs/nodes/' + nodename + '/disks/initgpt',
waitMsgTarget: me,
method: 'POST',
});
me.loadCount = 1; // avoid duplicate loadmask
- PVE.Utils.monStoreErrors(me, store);
+ Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
var grid = me.down('#smarts');
var text = me.down('#text');
- PVE.Utils.monStoreErrors(grid, me.store);
+ Proxmox.Utils.monStoreErrors(grid, me.store);
me.mon(me.store, 'load', function(s, records, success) {
if (success && records.length > 0) {
var rec = records[0];
updateTitle: function() {
var me = this;
- var uptime = PVE.Utils.render_uptime(me.getRecordValue('uptime'));
+ var uptime = Proxmox.Utils.render_uptime(me.getRecordValue('uptime'));
me.setTitle(me.pveSelNode.data.node + ' (' + gettext('Uptime') + ': ' + uptime + ')');
}
items: view
});
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/api2/extjs/nodes/' + me.nodename + '/report',
method: 'GET',
waitMsgTarget: me,
},
checktime: {
header: gettext('Last checked'),
- renderer: PVE.Utils.render_timestamp
+ renderer: Proxmox.Utils.render_timestamp
},
nextduedate: {
header: gettext('Next due date')
{
text: gettext('Check'),
handler: function() {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: { force: 1 },
url: baseurl,
method: 'POST',
{
text: gettext('System Report'),
handler: function() {
- PVE.Utils.checked_command(function (){ me.showReport(); });
+ Proxmox.Utils.checked_command(function (){ me.showReport(); });
}
}
],
items: [ view ]
});
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
waitMsgTarget: me,
url: "/nodes/" + nodename + "/apt/versions",
method: 'GET',
var version_btn = new Ext.Button({
text: gettext('Package versions'),
handler: function(){
- PVE.Utils.checked_command(function() { me.showVersions(); });
+ Proxmox.Utils.checked_command(function() { me.showVersions(); });
}
});
var text = "";
if (Number(uptime) > 0) {
- text = " (" + gettext('Uptime') + ': ' + PVE.Utils.format_duration_long(uptime)
+ text = " (" + gettext('Uptime') + ': ' + Proxmox.Utils.format_duration_long(uptime)
+ ')';
}
Ext.Array.each(me.query('[isFormField]'), function(field) {
if (!dirtyOnly || field.isDirty()) {
- PVE.Utils.assemble_field_data(values, field.getSubmitData());
+ Proxmox.Utils.assemble_field_data(values, field.getSubmitData());
}
});
req_params.since = Ext.Date.format(me.since_date, 'Y-m-d');
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: me.url,
params: req_params,
method: 'GET',
success: function(response) {
- PVE.Utils.setErrorMask(me, false);
+ Proxmox.Utils.setErrorMask(me, false);
var list = response.result.data;
var total = response.result.total;
var first = 0, last = 0;
},
failure: function(response) {
var msg = response.htmlStatus;
- PVE.Utils.setErrorMask(me, msg);
+ Proxmox.Utils.setErrorMask(me, msg);
}
});
},
load: function() {
var me = this;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: me.url,
waitMsgTarget: me,
failure: function(response, opts) {
throw "no title given";
}
- PVE.Utils.monStoreErrors(me, me.rstore);
+ Proxmox.Utils.monStoreErrors(me, me.rstore);
me.callParent();
me.list.push(['d', 'CD-ROM']);
me.list.push(['n', gettext('Network')]);
- me.list.push(['__none__', PVE.Utils.noneText]);
+ me.list.push(['__none__', Proxmox.Utils.noneText]);
me.recomputeList();
statics: {
// display a snapshot selector only if needed
wrap: function(nodename, vmid, isTemplate) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + nodename + '/qemu/' + vmid +'/snapshot',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
}
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/clone',
waitMsgTarget: me,
params.snapname = snapname;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
waitMsgTarget: me,
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/feature',
params: params,
var vmname = me.pveSelNode.data.name;
var vm_command = function(cmd, params) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + nodename + '/qemu/' + vmid + "/status/" + cmd,
method: 'POST',
hidden: suspended,
disabled: stopped || suspended,
handler: function() {
- var msg = PVE.Utils.format_task_description('qmsuspend', vmid);
+ var msg = Proxmox.Utils.format_task_description('qmsuspend', vmid);
Ext.Msg.confirm(gettext('Confirm'), msg, function(btn) {
if (btn !== 'yes') {
return;
iconCls: 'fa fa-fw fa-power-off',
disabled: stopped || suspended,
handler: function() {
- var msg = PVE.Utils.format_task_description('qmshutdown', vmid);
+ var msg = Proxmox.Utils.format_task_description('qmshutdown', vmid);
Ext.Msg.confirm(gettext('Confirm'), msg, function(btn) {
if (btn !== 'yes') {
return;
iconCls: 'fa fa-fw fa-stop',
disabled: stopped,
handler: function() {
- var msg = PVE.Utils.format_task_description('qmstop', vmid);
+ var msg = Proxmox.Utils.format_task_description('qmstop', vmid);
Ext.Msg.confirm(gettext('Confirm'), msg, function(btn) {
if (btn !== 'yes') {
return;
iconCls: 'fa fa-fw fa-file-o',
hidden: !caps.vms['VM.Allocate'],
handler: function() {
- var msg = PVE.Utils.format_task_description('qmtemplate', vmid);
+ var msg = Proxmox.Utils.format_task_description('qmtemplate', vmid);
Ext.Msg.confirm(gettext('Confirm'), msg, function(btn) {
if (btn !== 'yes') {
return;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + nodename + '/qemu/' + vmid + '/template',
method: 'POST',
failure: function(response, opts) {
text: gettext('Console'),
iconCls: 'fa fa-fw fa-terminal',
handler: function() {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + nodename + '/qemu/' + vmid + '/status/current',
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
});
var vm_command = function(cmd, params) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: base_url + '/status/' + cmd,
waitMsgTarget: me,
xtype: 'pveMenuItem',
iconCls: 'fa fa-fw fa-file-o',
hidden: caps.vms['VM.Allocate'] ? false : true,
- confirmMsg: PVE.Utils.format_task_description('qmtemplate', vmid),
+ confirmMsg: Proxmox.Utils.format_task_description('qmtemplate', vmid),
handler: function() {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: base_url + '/template',
waitMsgTarget: me,
method: 'POST',
text: gettext('Shutdown'),
disabled: !caps.vms['VM.PowerMgmt'] || !running,
hidden: template,
- confirmMsg: PVE.Utils.format_task_description('qmshutdown', vmid),
+ confirmMsg: Proxmox.Utils.format_task_description('qmshutdown', vmid),
handler: function() {
vm_command('shutdown');
},
text: gettext('Stop'),
disabled: !caps.vms['VM.PowerMgmt'],
dangerous: true,
- confirmMsg: PVE.Utils.format_task_description('qmstop', vmid),
+ confirmMsg: Proxmox.Utils.format_task_description('qmstop', vmid),
handler: function() {
vm_command("stop", { timeout: 30 });
},
},{
text: gettext('Reset'),
disabled: !caps.vms['VM.PowerMgmt'],
- confirmMsg: PVE.Utils.format_task_description('qmreset', vmid),
+ confirmMsg: Proxmox.Utils.format_task_description('qmreset', vmid),
handler: function() {
vm_command("reset");
},
var nodename = kv.nodename;
delete kv.nodename;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + nodename + '/qemu',
waitMsgTarget: me,
method: 'POST',
params['delete'] = 1;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/move_disk',
waitMsgTarget: me,
var me = this;
var params = { disk: disk, size: '+' + size + 'G' };
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/resize',
waitMsgTarget: me,
renderer: function(value, metaData, record) {
var balloon = me.getObjectValue('balloon');
if (balloon) {
- return PVE.Utils.format_size(balloon*1024*1024) + "/" +
- PVE.Utils.format_size(value*1024*1024);
+ return Proxmox.Utils.format_size(balloon*1024*1024) + "/" +
+ Proxmox.Utils.format_size(value*1024*1024);
}
- return PVE.Utils.format_size(value*1024*1024);
+ return Proxmox.Utils.format_size(value*1024*1024);
}
},
sockets: {
return msg;
},
handler: function(b, e, rec) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/api2/extjs/' + baseurl,
waitMsgTarget: me,
method: 'PUT',
var rowdef = me.rows[rec.data.key] || {};
var keys = rowdef.multiKey || [ rec.data.key ];
var revert = keys.join(',');
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/api2/extjs/' + baseurl,
waitMsgTarget: me,
method: 'PUT',
labelAlign: 'right',
labelWidth: labelWidth,
allowBlank: true,
- emptyText: PVE.Utils.defaultText + ' (1000)',
+ emptyText: Proxmox.Utils.defaultText + ' (1000)',
submitEmptyText: false
}
];
var executeCmd = function(cmd) {
addLine("# " + Ext.htmlEncode(cmd));
refresh();
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: { command: cmd },
url: '/nodes/' + nodename + '/qemu/' + vmid + "/monitor",
method: 'POST',
onboot: {
header: gettext('Start at boot'),
defaultValue: '',
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'pveWindowEdit',
subject: gettext('Start at boot'),
tablet: {
header: gettext('Use tablet for pointer'),
defaultValue: true,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.HWType'] ? {
xtype: 'pveWindowEdit',
subject: gettext('Use tablet for pointer'),
acpi: {
header: gettext('ACPI support'),
defaultValue: true,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.HWType'] ? {
xtype: 'pveWindowEdit',
subject: gettext('ACPI support'),
kvm: {
header: gettext('KVM hardware virtualization'),
defaultValue: true,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.HWType'] ? {
xtype: 'pveWindowEdit',
subject: gettext('KVM hardware virtualization'),
freeze: {
header: gettext('Freeze CPU at startup'),
defaultValue: false,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.PowerMgmt'] ? {
xtype: 'pveWindowEdit',
subject: gettext('Freeze CPU at startup'),
localtime: {
header: gettext('Use local time for RTC'),
defaultValue: false,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'pveWindowEdit',
subject: gettext('Use local time for RTC'),
agent: {
header: gettext('Qemu Agent'),
defaultValue: false,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'pveWindowEdit',
subject: gettext('Qemu Agent'),
protection: {
header: gettext('Protection'),
defaultValue: false,
- renderer: PVE.Utils.format_boolean,
+ renderer: Proxmox.Utils.format_boolean,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'pveWindowEdit',
subject: gettext('Protection'),
var keys = rowdef.multiKey || [ rec.data.key ];
var revert = keys.join(',');
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/api2/extjs/' + baseurl,
waitMsgTarget: me,
method: 'PUT',
listeners: {
'change' : function(field, newValue) {
if (newValue == 'ovmf') {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url : me.url,
method : 'GET',
failure : function(response, opts) {
params.description = descr;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + "/snapshot",
waitMsgTarget: me,
update_snapshot: function(snapname, descr) {
var me = this;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: { description: descr },
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + "/snapshot/" +
snapname + '/config',
}
// else load data
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + "/snapshot/" +
me.snapname + '/config',
waitMsgTarget: me,
reload: function(repeat) {
var me = this;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/snapshot',
method: 'GET',
failure: function(response, opts) {
- PVE.Utils.setErrorMask(me, response.htmlStatus);
+ Proxmox.Utils.setErrorMask(me, response.htmlStatus);
me.load_task.delay(me.load_delay);
},
success: function(response, opts) {
- PVE.Utils.setErrorMask(me, false);
+ Proxmox.Utils.setErrorMask(me, false);
var digest = 'invalid';
var idhash = {};
var root = { name: '__root', expanded: true, children: [] };
}
});
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/feature',
params: { feature: 'snapshot' },
method: 'GET',
selModel: sm,
enableFn: valid_snapshot_rollback,
confirmMsg: function(rec) {
- return PVE.Utils.format_task_description('qmrollback', me.vmid) +
+ return Proxmox.Utils.format_task_description('qmrollback', me.vmid) +
" '" + rec.data.name + "'";
},
handler: function(btn, event) {
}
var snapname = rec.data.name;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/snapshot/' + snapname + '/rollback',
method: 'POST',
waitMsgTarget: me,
}
var snapname = rec.data.name;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/qemu/' + me.vmid + '/snapshot/' + snapname,
method: 'DELETE',
waitMsgTarget: me,
width: 50,
renderer: function(value, metaData, record) {
if (record.data.name !== 'current') {
- return PVE.Utils.format_boolean(value);
+ return Proxmox.Utils.format_boolean(value);
}
}
},
var template = me.pveSelNode.data.template;
var vm_command = function(cmd, params) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + nodename + '/qemu/' + vmid + "/status/" + cmd,
method: 'POST',
store.load();
};
- PVE.Utils.monStoreErrors(me, store);
+ Proxmox.Utils.monStoreErrors(me, store);
Ext.apply(me, {
store: store,
disabled: true,
selModel: sm,
handler: function(button, event, rec) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/aplinfo',
params: {
storage: me.storage,
var updateProgress = function(per, bytes) {
var text = (per * 100).toFixed(2) + '%';
if (bytes) {
- text += " (" + PVE.Utils.format_size(bytes) + ')';
+ text += " (" + Proxmox.Utils.format_size(bytes) + ')';
}
pbar.updateProgress(per, text);
};
var msg = gettext('Error') + " " + xhr.status.toString() + ": " + Ext.htmlEncode(xhr.statusText);
var result = Ext.decode(xhr.responseText);
result.message = msg;
- var htmlStatus = PVE.Utils.extractRequestError(result, true);
+ var htmlStatus = Proxmox.Utils.extractRequestError(result, true);
Ext.Msg.alert(gettext('Error'), htmlStatus, function(btn) {
me.close();
});
me.statusStore.load();
};
- PVE.Utils.monStoreErrors(me, store);
+ Proxmox.Utils.monStoreErrors(me, store);
var templateButton = Ext.create('Proxmox.button.Button',{
itemId: 'tmpl-btn',
{
header: gettext('Size'),
width: 100,
- renderer: PVE.Utils.format_size,
+ renderer: Proxmox.Utils.format_size,
dataIndex: 'size'
}
],
title: gettext('Enabled'),
printBar: false,
textField: 'disabled',
- renderer: PVE.Utils.format_neg_boolean
+ renderer: Proxmox.Utils.format_neg_boolean
},
{
itemId: 'active',
title: gettext('Active'),
printBar: false,
textField: 'active',
- renderer: PVE.Utils.format_boolean
+ renderer: Proxmox.Utils.format_boolean
},
{
itemId: 'content',
xtype: 'textfield',
fieldLabel: gettext('Send email to'),
name: 'mailto',
- emptyText: PVE.Utils.noneText
+ emptyText: Proxmox.Utils.noneText
}
]
});
params.compress = values.compress;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: '/nodes/' + me.nodename + '/vzdump',
params: params,
method: 'POST',
me.callParent();
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: "/nodes/" + nodename + "/vzdump/extractconfig",
method: 'GET',
params: {
submit: function(params) {
var me = this;
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + me.nodename + '/' + "/" + me.action,
waitMsgTarget: me,
form.getFields().each(function(field) {
if (!field.up('inputpanel') && (!dirtyOnly || field.isDirty())) {
- PVE.Utils.assemble_field_data(values, field.getSubmitData());
+ Proxmox.Utils.assemble_field_data(values, field.getSubmitData());
}
});
Ext.Array.each(me.query('inputpanel'), function(panel) {
- PVE.Utils.assemble_field_data(values, panel.getValues(dirtyOnly));
+ Proxmox.Utils.assemble_field_data(values, panel.getValues(dirtyOnly));
});
return values;
values = undefined;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: url,
waitMsgTarget: me,
method: me.method || (me.backgroundDelay ? 'POST' : 'PUT'),
createWrapper(options.success);
- PVE.Utils.API2Request(newopts);
+ Proxmox.Utils.API2Request(newopts);
},
initComponent : function() {
var twoColumn = items[0].column1 || items[0].column2;
if (me.subject && !me.title) {
- me.title = PVE.Utils.dialog_title(me.subject, me.isCreate, me.isAdd);
+ me.title = Proxmox.Utils.dialog_title(me.subject, me.isCreate, me.isAdd);
}
if (me.isCreate) {
params[view.liveMode] = 1;
}
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
params: params,
url: '/nodes/' + view.nodename + '/' + view.vmtype + '/' + view.vmid + '/migrate',
waitMsgTarget: view,
var form = me.formPanel.getForm();
var doRestore = function(url, params) {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: url,
params: params,
method: 'POST',
params.ostemplate = me.volid;
params.restore = 1;
if (values.unprivileged) { params.unprivileged = 1; }
- msg = PVE.Utils.format_task_description('vzrestore', params.vmid);
+ msg = Proxmox.Utils.format_task_description('vzrestore', params.vmid);
} else if (me.vmtype === 'qemu') {
url = '/nodes/' + me.nodename + '/qemu';
params.archive = me.volid;
- msg = PVE.Utils.format_task_description('qmrestore', params.vmid);
+ msg = Proxmox.Utils.format_task_description('qmrestore', params.vmid);
} else {
throw 'unknown VM type';
}
'button[reference=removeButton]': {
click: function() {
var view = this.getView();
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: view.getUrl() + view.getParams(),
method: 'DELETE',
waitMsgTarget: view,
var msg;
if (item.type === 'VM') {
- msg = PVE.Utils.format_task_description('qmdestroy', item.id);
+ msg = Proxmox.Utils.format_task_description('qmdestroy', item.id);
} else if (item.type === 'CT') {
- msg = PVE.Utils.format_task_description('vzdestroy', item.id);
+ msg = Proxmox.Utils.format_task_description('vzdestroy', item.id);
} else if (item.type === 'CephPool') {
- msg = PVE.Utils.format_task_description('cephdestroypool', item.id);
+ msg = Proxmox.Utils.format_task_description('cephdestroypool', item.id);
} else {
throw "unknown item type specified";
}
var me = this;
var sp = Ext.state.Manager.getProvider();
- var username = sp.get('login-username') || PVE.Utils.noneText;
+ var username = sp.get('login-username') || Proxmox.Utils.noneText;
me.lookupReference('savedUserName').setValue(username);
}
},
var usernamefield = me.lookupReference('savedUserName');
var sp = Ext.state.Manager.getProvider();
- usernamefield.setValue(PVE.Utils.noneText);
+ usernamefield.setValue(Proxmox.Utils.noneText);
sp.clear('login-username');
}
},
throw "no task specified";
}
- var task = PVE.Utils.parse_task_upid(me.upid);
+ var task = Proxmox.Utils.parse_task_upid(me.upid);
var statstore = Ext.create('PVE.data.ObjectStore', {
url: "/api2/json/nodes/" + task.node + "/tasks/" + me.upid + "/status",
}
});
- var descr = PVE.Utils.format_task_description(task.type, task.id);
+ var descr = Proxmox.Utils.format_task_description(task.type, task.id);
Ext.apply(me, {
title: "Task: " + descr,
throw "no task specified";
}
- var task = PVE.Utils.parse_task_upid(me.upid);
+ var task = Proxmox.Utils.parse_task_upid(me.upid);
var statgrid;
starttime: {
header: gettext('Start Time'),
required: true,
- renderer: PVE.Utils.render_timestamp
+ renderer: Proxmox.Utils.render_timestamp
},
upid: {
header: gettext('Unique task ID')
me.on('destroy', statstore.stopUpdate);
var stop_task = function() {
- PVE.Utils.API2Request({
+ Proxmox.Utils.API2Request({
url: "/nodes/" + task.node + "/tasks/" + me.upid,
waitMsgTarget: me,
method: 'DELETE',
form.getFields().each(function(field) {
if (!field.up('inputpanel') && (!dirtyOnly || field.isDirty())) {
- PVE.Utils.assemble_field_data(values, field.getSubmitData());
+ Proxmox.Utils.assemble_field_data(values, field.getSubmitData());
}
});
Ext.Array.each(me.query('inputpanel'), function(panel) {
- PVE.Utils.assemble_field_data(values, panel.getValues(dirtyOnly));
+ Proxmox.Utils.assemble_field_data(values, panel.getValues(dirtyOnly));
});
return values;
};
if (me.subject && !me.title) {
- me.title = PVE.Utils.dialog_title(me.subject, true, false);
+ me.title = Proxmox.Utils.dialog_title(me.subject, true, false);
}
Ext.apply(me, {
}
},
itemTpl: '{name}' +
- '<br><small>Online: {[PVE.Utils.format_boolean(values.online)]}</small>' +
+ '<br><small>Online: {[Proxmox.Utils.format_boolean(values.online)]}</small>' +
'<br><small>Support: {[PVE.Utils.render_support_level(values.level)]}</small>'
}
]
}
} else if (el.type === "cluster") {
me.summary.nodes = el.nodes;
- me.summary.quorate = PVE.Utils.format_boolean(el.quorate);
+ me.summary.quorate = Proxmox.Utils.format_boolean(el.quorate);
me.summary.cluster_name = el.name;
}
});
'<tr><td>Version:</td><td>{pveversion}</td></tr>',
'<tr><td>Memory:</td><td>{[this.meminfo(values)]}</td></tr>',
'<tr><td>CPU:</td><td>{[this.cpuinfo(values)]}</td></tr>',
- '<tr><td>Uptime:</td><td>{[PVE.Utils.format_duration_long(values.uptime)]}</td></tr>',
+ '<tr><td>Uptime:</td><td>{[Proxmox.Utils.format_duration_long(values.uptime)]}</td></tr>',
'</table>',
{
meminfo: function(values) {
if (!d) {
return '-';
}
- return PVE.Utils.format_size(d.used || 0) + " of " + PVE.Utils.format_size(d.total);
+ return Proxmox.Utils.format_size(d.used || 0) + " of " + Proxmox.Utils.format_size(d.total);
},
cpuinfo: function(values) {
if (!values.cpuinfo) {
if (!values.uptime) {
return '-';
}
- return PVE.Utils.format_size(values.mem);
+ return Proxmox.Utils.format_size(values.mem);
},
cpuinfo: function(values) {
if (!values.uptime) {
'<small>node: {node}<br /> Status: {[this.status(values)]}</small>',
{
desc: function(values) {
- return PVE.Utils.format_task_description(values.type, values.id);
+ return Proxmox.Utils.format_task_description(values.type, values.id);
},
status: function(values) {
return Ext.String.ellipsis(values.status, 160);
kv.push({ key: gettext('Taskstatus'), value: d.status });
kv.push({ key: gettext('Node'), value: d.node });
kv.push({ key: gettext('User'), value: d.user });
- kv.push({ key: gettext('Starttime'), value: PVE.Utils.render_timestamp(d.starttime) });
+ kv.push({ key: gettext('Starttime'), value: Proxmox.Utils.render_timestamp(d.starttime) });
me.setMasked(false);
statusCmp.setData(kv);
me.nodename = match[1];
me.upid = match[2];
- me.taskInfo = PVE.Utils.parse_task_upid(me.upid);
+ me.taskInfo = Proxmox.Utils.parse_task_upid(me.upid);
me.down('titlebar').setTitle(me.taskInfo.desc);
// Sencha Touch related things
-PVE.Utils.toolkit = 'touch',
+Proxmox.Utils.toolkit = 'touch',
Ext.Ajax.setDisableCaching(false);
'<tr><td>Status:</td><td>{[this.status(values)]}</td></tr>',
'<tr><td>Memory:</td><td>{[this.meminfo(values)]}</td></tr>',
'<tr><td>CPU:</td><td>{[this.cpuinfo(values)]}</td></tr>',
- '<tr><td>Uptime:</td><td>{[PVE.Utils.format_duration_long' +
+ '<tr><td>Uptime:</td><td>{[Proxmox.Utils.format_duration_long' +
'(values.uptime)]}</td></tr>',
'</table>',
{
if (!Ext.isDefined(values.mem)) {
return '-';
}
- return PVE.Utils.format_size(values.mem || 0) + " of " +
- PVE.Utils.format_size(values.maxmem);
+ return Proxmox.Utils.format_size(values.mem || 0) + " of " +
+ Proxmox.Utils.format_size(values.maxmem);
},
cpuinfo: function(values) {
if (!Ext.isDefined(values.cpu)) {
},
showLogin: function() {
- PVE.Utils.authClear();
+ Proxmox.Utils.authClear();
PVE.UserName = null;
PVE.Workspace.loginData = null;
var comp;
- if (!PVE.Utils.authOK()) {
+ if (!Proxmox.Utils.authOK()) {
comp = Ext.create('PVE.Login', {});
} else {
Ext.Array.each(PVE.Workspace.pages, function(p, index) {
projects / pve-manager.git / commitdiff