var history_change_cb = function(token) {
//console.log("HC " + token);
if (!token) {
- var res = window.confirm('Are you sure you want to navigate away from this page?');
+ var res = window.confirm(gettext('Are you sure you want to navigate away from this page?'));
if (res){
// process text value and close...
Ext.History.back();
me.callParent(arguments);
}
}
-});
\ No newline at end of file
+});
},
kvm_vga_drivers: {
- std: 'Standard VGA',
- vmware: 'VMWare compatible',
+ std: gettext('Standard VGA'),
+ vmware: gettext('VMWare compatible'),
cirrus: 'Cirrus Logic GD5446',
qxl: 'SPICE',
- serial0: 'Serial terminal 0',
- serial1: 'Serial terminal 1',
- serial2: 'Serial terminal 2',
- serial3: 'Serial terminal 3'
+ serial0: gettext('Serial terminal') + ' 0',
+ serial1: gettext('Serial terminal') + ' 1',
+ serial2: gettext('Serial terminal') + ' 2',
+ serial3: gettext('Serial terminal') + ' 3'
},
render_kvm_language: function (value) {
method: 'GET',
//waitMsgTarget: me,
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, opts) {
var data = response.result.data;
if (data.status !== 'Active') {
Ext.Msg.show({
- title: 'No valid subscription',
+ title: gettext('No valid subscription'),
icon: Ext.Msg.WARNING,
msg: PVE.Utils.noSubKeyHtml,
buttons: Ext.Msg.OK,
return 'Directory';
} else if (value === 'nfs') {
return 'NFS';
- } else if (value === 'glusterfs') {
- return 'GlusterFS';
} else if (value === 'lvm') {
return 'LVM';
} else if (value === 'iscsi') {
content = {
border: false,
bodyPadding: 10,
- html: 'Error: No such console type'
+ html: gettext('Error: No such console type')
};
}
width: 100
},
maxcpu: {
- header: 'maxcpu',
+ header: gettext('maxcpu'),
type: 'integer',
hidden: true,
sortable: true,
width: 60
},
diskread: {
- header: 'Total Disk Read',
+ header: gettext('Total Disk Read'),
type: 'integer',
hidden: true,
sortable: true,
width: 100
},
diskwrite: {
- header: 'Total Disk Write',
+ header: gettext('Total Disk Write'),
type: 'integer',
hidden: true,
sortable: true,
width: 100
},
netin: {
- header: 'Total NetIn',
+ header: gettext('Total NetIn'),
type: 'integer',
hidden: true,
sortable: true,
width: 100
},
netout: {
- header: 'Total NetOut',
+ header: gettext('Total NetOut'),
type: 'integer',
hidden: true,
sortable: true,
width: 100
},
template: {
- header: 'template',
+ header: gettext('Template'),
type: 'integer',
hidden: true,
sortable: true,
if (me.authType === 'ad') {
- me.subject = 'Active Directory Server';
+ me.subject = gettext('Active Directory Server');
column1.push({
xtype: 'textfield',
name: 'domain',
- fieldLabel: 'Domain',
+ fieldLabel: gettext('Domain'),
emptyText: 'company.net',
allowBlank: false
});
} else if (me.authType === 'ldap') {
- me.subject = 'LDAP Server';
+ me.subject = gettext('LDAP Server');
column1.push({
xtype: 'textfield',
name: 'base_dn',
- fieldLabel: 'Base Domain Name',
+ fieldLabel: gettext('Base Domain Name'),
emptyText: 'CN=Users,DC=Company,DC=net',
allowBlank: false
});
xtype: 'textfield',
name: 'user_attr',
emptyText: 'uid / sAMAccountName',
- fieldLabel: 'User Attribute Name',
+ fieldLabel: gettext('User Attribute Name'),
allowBlank: false
});
menu: new Ext.menu.Menu({
items: [
{
- text: 'Active Directory Server',
+ text: gettext('Active Directory server'),
handler: function() {
var win = Ext.create('PVE.dc.AuthEdit', {
authType: 'ad'
}
},
{
- text: 'LDAP Server',
+ text: gettext('LDAP Server'),
handler: function() {
var win = Ext.create('PVE.dc.AuthEdit',{
authType: 'ldap'
xtype: 'pvecheckbox',
name: 'autostart',
checked: true,
- fieldLabel: 'autostart'
+ fieldLabel: gettext('Autostart')
}
]
});
var me = this;
Ext.applyIf(me, {
- subject: 'HTTP proxy',
+ subject: gettext('HTTP proxy'),
items: {
xtype: 'pvetextfield',
name: 'http_proxy',
emptyText: gettext('Do not use any proxy'),
deleteEmpty: true,
value: '',
- fieldLabel: 'HTTP proxy'
+ fieldLabel: gettext('HTTP proxy')
}
});
required: true
},
http_proxy: {
- header: 'HTTP proxy',
+ header: gettext('HTTP proxy'),
editor: 'PVE.dc.HttpProxyEdit',
required: true,
renderer: function(value) {
editor = 'PVE.storage.DirEdit';
} else if (type === 'nfs') {
editor = 'PVE.storage.NFSEdit';
- } else if (type === 'glusterfs') {
- editor = 'PVE.storage.GlusterFsEdit';
} else if (type === 'lvm') {
editor = 'PVE.storage.LVMEdit';
} else if (type === 'iscsi') {
menu: new Ext.menu.Menu({
items: [
{
- text: 'Directory',
+ text: gettext('Directory'),
iconCls: 'pve-itype-icon-itype',
handler: function() {
var win = Ext.create('PVE.storage.DirEdit', {});
},
{
- text: 'LVM group',
+ text: gettext('LVM group'),
handler: function() {
var win = Ext.create('PVE.storage.LVMEdit', {});
win.on('destroy', reload);
}
},
{
- text: 'NFS share',
+ text: gettext('NFS share'),
iconCls: 'pve-itype-icon-node',
handler: function() {
var win = Ext.create('PVE.storage.NFSEdit', {});
}
},
{
- text: 'iSCSI target',
+ text: gettext('iSCSI target'),
iconCls: 'pve-itype-icon-node',
handler: function() {
var win = Ext.create('PVE.storage.IScsiEdit', {});
win.show();
}
},
- {
- text: 'GlusterFS volume',
- iconCls: 'pve-itype-icon-node',
- handler: function() {
- var win = Ext.create('PVE.storage.GlusterFsEdit', {});
- win.on('destroy', reload);
- win.show();
- }
- },
{
text: 'RBD',
iconCls: 'pve-itype-icon-node',
method: 'GET',
waitMsgTarget: me,
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
- me.update("Unable to load subscription status: " + response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
+ me.update(gettext('Unable to load subscription status') + ": " + response.htmlStatus);
},
success: function(response, opts) {
var data = response.result.data;
me.callParent();
}
-});
\ No newline at end of file
+});
{
xtype: 'textfield',
name: 'email',
- fieldLabel: 'E-Mail',
+ fieldLabel: gettext('E-Mail'),
vtype: 'email'
},
{
var me = this;
me.data = [
- ['snapshot', 'Snapshot'],
- ['suspend', 'Suspend'],
- ['stop', 'Stop']
+ ['snapshot', gettext('Snapshot')],
+ ['suspend', gettext('Suspend')],
+ ['stop', gettext('Stop')]
];
me.callParent();
listConfig: {
columns: [
{
- header: 'Bridge',
+ header: gettext('Bridge'),
dataIndex: 'iface',
hideable: false,
flex: 1
var me = this;
me.data = [
- ['', 'Default (kvm64)'],
+ ['', gettext('Default') + ' (kvm64)'],
['486', '486'],
['athlon', 'athlon'],
['core2duo', 'core2duo'],
var me = this;
me.data = [
- ['', 'Default (No cache)'],
+ ['', gettext('Default') + " (" + gettext('No cache') + ")"],
['directsync', 'Direct sync'],
['writethrough', 'Write through'],
['writeback', 'Write back'],
- ['unsafe', 'Write back (unsafe)'],
- ['none', 'No cache']
+ ['unsafe', 'Write back (' + gettext('unsafe') + ')'],
+ ['none', gettext('No cache')]
];
me.callParent();
var me = this;
Ext.apply(me, {
- fieldLabel: 'Bus/Device',
+ fieldLabel: gettext('Bus/Device'),
layout: 'hbox',
height: 22, // hack: set to same height as other fields
defaults: {
me.callParent();
}
-});
\ No newline at end of file
+});
var me = this;
me.data = [
- ['raw', 'Raw disk image (raw)'],
- ['qcow2', 'QEMU image format (qcow2)'],
- ['vmdk', 'VMware image format (vmdk)']
+ ['raw', gettext('Raw disk image') + ' (raw)')],
+ ['qcow2', gettext('QEMU image format') + ' (qcow2)'],
+ ['vmdk', gettext('VMware image format') + ' (vmdk)']
];
me.callParent();
listConfig: {
columns: [
{
- header: 'Name',
+ header: gettext('Name'),
dataIndex: 'text',
hideable: false,
flex: 1
},
{
- header: 'Format',
+ header: gettext('Format'),
width: 60,
dataIndex: 'format'
},
{
- header: 'Size',
+ header: gettext('Size'),
width: 60,
dataIndex: 'size',
renderer: PVE.Utils.format_size
me.setStorage(me.storage, me.nodename);
}
-});
\ No newline at end of file
+});
},
{
id: 'comment',
- header: 'Comment',
+ header: gettext('Comment'),
sortable: false,
dataIndex: 'comment',
flex: 1
me.data = [
['e1000', 'Intel E1000'],
- ['virtio', 'VirtIO (paravirtualized)'],
+ ['virtio', 'VirtIO (' + gettext('paravirtualized') + ')'],
['rtl8139', 'Realtec RTL8139']
];
listConfig: {
columns: [
{
- header: 'Node',
+ header: gettext('Node'),
dataIndex: 'node',
sortable: true,
hideable: false,
flex: 1
},
{
- header: 'Memory usage',
+ header: gettext('Memory usage'),
renderer: PVE.Utils.render_mem_usage,
sortable: true,
width: 100,
dataIndex: 'mem'
},
{
- header: 'CPU usage',
+ header: gettext('CPU usage'),
renderer: PVE.Utils.render_cpu,
sortable: true,
width: 100,
},
{
id: 'comment',
- header: 'Comment',
+ header: gettext('Comment'),
sortable: false,
dataIndex: 'comment',
flex: 1
});
Ext.apply(me, {
- fieldLabel: 'Realm',
+ fieldLabel: gettext('Realm'),
name: 'realm',
store: realmstore,
queryMode: 'local',
}
});
}
-});
\ No newline at end of file
+});
listConfig: {
columns: [
{
- header: 'Snapshot',
+ header: gettext('Snapshot'),
dataIndex: 'name',
hideable: false,
flex: 1
listConfig: {
columns: [
{
- header: 'Name',
+ header: gettext('Name'),
dataIndex: 'storage',
hideable: false,
flex: 1
},
{
- header: 'Type',
+ header: gettext('Type'),
width: 60,
dataIndex: 'type'
},
{
- header: 'Avail',
+ header: gettext('Avail'),
width: 80,
dataIndex: 'avail',
renderer: PVE.Utils.format_size
},
{
- header: 'Capacity',
+ header: gettext('Capacity'),
width: 80,
dataIndex: 'total',
renderer: PVE.Utils.format_size
flex: 1
},
{
- header: 'Name',
+ header: gettext('Name'),
sortable: true,
renderer: render_full_name,
dataIndex: 'firstname',
},
{
id: 'comment',
- header: 'Comment',
+ header: gettext('Comment'),
sortable: false,
dataIndex: 'comment',
flex: 1
method: 'GET',
success: function(response, opts) {
if (me.validateExists === true) {
- me.markInvalid("This VM ID does not exists.");
+ me.markInvalid(gettext('This VM ID does not exists'));
}
},
failure: function(response, opts) {
if (me.validateExists === false) {
- me.markInvalid("This VM ID is already in use.");
+ me.markInvalid(gettext('This VM ID is already in use'));
}
}
});
stateful: false,
columns: [
{
- header: 'Name',
+ header: gettext('Name'),
width: me.cwidth1 || 100,
dataIndex: 'key',
renderer: me.renderKey
},
{
flex: 1,
- header: 'Value',
+ header: gettext('Value'),
dataIndex: 'value',
renderer: me.renderValue
}
url: "/nodes/" + nodename + "/apt/" + cmd,
method: 'POST',
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, opts) {
var upid = response.result.data;
method: 'GET',
failure: function(response, opts) {
win.close();
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, opts) {
win.show();
method: 'POST',
waitMsgTarget: me,
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
}
});
};
xtype: 'pveNodeNetworkView'
},
{
- title: 'DNS',
+ title: gettext('DNS'),
itemId: 'dns',
xtype: 'pveNodeDNSView'
},
me.items.push([
{
- title: 'Task History',
+ title: gettext('Task History'),
itemId: 'tasks',
xtype: 'pveNodeTasks'
}
me.items.push([
{
- title: 'Subscription',
+ title: gettext('Subscription'),
itemId: 'support',
xtype: 'pveNodeSubscription',
nodename: nodename
me.items = [
{
xtype: 'textfield',
- fieldLabel: 'Search domain',
+ fieldLabel: gettext('Search domain'),
name: 'search',
allowBlank: false
},
];
Ext.applyIf(me, {
- subject: 'DNS',
+ subject: gettext('DNS'),
url: "/api2/extjs/nodes/" + nodename + "/dns",
fieldDefaults: {
labelWidth: 120
var column2 = [
{
xtype: 'pvecheckbox',
- fieldLabel: 'Autostart',
+ fieldLabel: gettext('Autostart'),
name: 'autostart',
uncheckedValue: 0,
checked: me.create ? true : undefined
if (me.iftype === 'bridge') {
column2.push({
xtype: 'textfield',
- fieldLabel: 'Bridge ports',
+ fieldLabel: gettext('Bridge ports'),
name: 'bridge_ports'
});
} else if (me.iftype === 'bond') {
column2.push({
xtype: 'textfield',
- fieldLabel: 'Slaves',
+ fieldLabel: gettext('Slaves'),
name: 'slaves'
});
column2.push({
xtype: 'bondModeSelector',
- fieldLabel: 'Mode',
+ fieldLabel: gettext('Mode'),
name: 'bond_mode',
value: me.create ? 'balance-rr' : undefined,
allowBlank: false
{
xtype: 'pvetextfield',
deleteEmpty: !me.create,
- fieldLabel: 'Gateway',
+ fieldLabel: gettext('Gateway'),
vtype: 'IPAddress',
name: 'gateway'
}
PVE.Utils.API2Request({
url: '/nodes/' + nodename + '/network',
failure: function(response, opts) {
- changeitem.update('Error: ' + response.htmlStatus);
+ changeitem.update(gettext('Error') + ': ' + response.htmlStatus);
store.loadData({});
},
success: function(response, opts) {
reload();
},
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
}
});
}
},
{
xtype: 'booleancolumn',
- header: 'Autostart',
+ header: gettext('Autostart'),
width: 80,
sortable: true,
dataIndex: 'autostart',
undefinedText: 'No'
},
{
- header: 'Ports/Slaves',
+ header: gettext('Ports/Slaves'),
dataIndex: 'type',
renderer: render_ports
},
dataIndex: 'netmask'
},
{
- header: 'Gateway',
+ header: gettext('Gateway'),
sortable: true,
dataIndex: 'gateway'
}
});
});
-
\ No newline at end of file
+
url: "/nodes/" + nodename + "/services/" + rec.data.service + "/" + cmd,
method: 'POST',
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
me.loading = true;
},
success: function(response, opts) {
var render_cpuinfo = function(value) {
return value.cpus + " x " + value.model + " (" +
value.sockets.toString() + " " +
- (value.sockets > 1 ? "Sockets" : "Socket") + ")";
+ (value.sockets > 1 ? gettext('Sockets') : gettext('Socket')) + ")";
};
var render_loadavg = function(value) {
var render_meminfo = function(value) {
var per = (value.used / value.total)*100;
- var text = "<div>Total: " + PVE.Utils.format_size(value.total) + "</div>" +
- "<div>Used: " + PVE.Utils.format_size(value.used) + "</div>";
+ var text = "<div>" + gettext('Total') + ": " + PVE.Utils.format_size(value.total) + "</div>" +
+ "<div>" + gettext('Used') + ": " + PVE.Utils.format_size(value.used) + "</div>";
return text;
};
var rows = {
- uptime: { header: 'Uptime', required: true, renderer: PVE.Utils.format_duration_long },
- loadavg: { header: 'Load average', required: true, renderer: render_loadavg },
- cpuinfo: { header: 'CPUs', required: true, renderer: render_cpuinfo },
- cpu: { header: 'CPU usage',required: true, renderer: render_cpu },
- wait: { header: 'IO delay', required: true, renderer: render_cpu },
- memory: { header: 'RAM usage', required: true, renderer: render_meminfo },
- swap: { header: 'SWAP usage', required: true, renderer: render_meminfo },
- ksm: { header: 'KSM sharing', required: true, renderer: render_ksm },
- rootfs: { header: 'HD space (root)', required: true, renderer: render_meminfo },
- pveversion: { header: 'PVE Manager version', required: true },
- kversion: { header: 'Kernel version', required: true }
+ uptime: { header: gettext('Uptime'), required: true, renderer: PVE.Utils.format_duration_long },
+ loadavg: { header: gettext('Load average'), required: true, renderer: render_loadavg },
+ cpuinfo: { header: gettext('CPUs'), required: true, renderer: render_cpuinfo },
+ cpu: { header: gettext('CPU usage'),required: true, renderer: render_cpu },
+ wait: { header: gettext('IO delay'), required: true, renderer: render_cpu },
+ memory: { header: gettext('RAM usage'), required: true, renderer: render_meminfo },
+ swap: { header: gettext('SWAP usage'), required: true, renderer: render_meminfo },
+ ksm: { header: gettext('KSM sharing'), required: true, renderer: render_ksm },
+ rootfs: { header: gettext('HD space (root)'), required: true, renderer: render_meminfo },
+ pveversion: { header: gettext('PVE Manager version'), required: true },
+ kversion: { header: gettext('Kernel version'), required: true }
};
Ext.applyIf(me, {
header: gettext('Server ID')
},
sockets: {
- header: 'Sockets'
+ header: gettext('Sockets')
},
checktime: {
- header: 'Last checked',
+ header: gettext('Last checked'),
renderer: PVE.Utils.render_timestamp
}
};
method: 'POST',
waitMsgTarget: me,
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
callback: reload
});
method: 'GET',
failure: function(response, opts) {
win.close();
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, opts) {
win.show();
var rstore = me.statusStore;
var statusview = Ext.create('PVE.node.StatusView', {
- title: 'Status',
+ title: gettext('Status'),
pveSelNode: me.pveSelNode,
- style: { 'padding-top': '0px' },
+ style: 'padding-top:0px',
rstore: rstore
});
bodyStyle: 'padding:10px',
defaults: {
width: 800,
- style: { 'padding-top': '10px' }
+ style: 'padding-top:10px'
},
tbar: [version_btn, '->', { xtype: 'pveRRDTypeSelector' } ],
items: [
statusview,
{
xtype: 'pveRRDView',
- title: "CPU usage %",
+ title: gettext('CPU usage'),
datasource: 'cpu,iowait',
rrdurl: rrdurl
},
{
xtype: 'pveRRDView',
- title: "Server load",
+ title: gettext('Server load'),
datasource: 'loadavg',
rrdurl: rrdurl
},
{
xtype: 'pveRRDView',
- title: "Memory usage",
+ title: gettext('Memory usage'),
datasource: 'memtotal,memused',
rrdurl: rrdurl
},
{
xtype: 'pveRRDView',
- title: "Network traffic",
+ title: gettext('Network traffic'),
datasource: 'netin,netout',
rrdurl: rrdurl
}
stateful: false,
columns: [
{
- header: 'Ressource',
+ header: gettext('Resource'),
width: 100,
dataIndex: 'id'
},
{
- header: 'held',
+ header: gettext('Held'),
width: 100,
renderer: me.renderUbc,
dataIndex: 'held'
},
{
- header: 'maxheld',
+ header: gettext('Maxheld'),
width: 100,
renderer: me.renderUbc,
dataIndex: 'maxheld'
},
{
- header: 'barrier',
+ header: gettext('Barrier'),
width: 100,
renderer: me.renderUbc,
dataIndex: 'bar'
},
{
- header: 'limit',
+ header: gettext('Limit'),
width: 100,
renderer: me.renderUbc,
dataIndex: 'lim'
},
{
- header: 'failcnt',
+ header: gettext('Failcnt'),
width: 100,
dataIndex: 'failcnt'
}
url: '/nodes/' + nodename + '/openvz/' + vmid + "/status/" + cmd,
method: 'POST',
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
}
});
};
xtype: 'pveOpenVZNetworkView'
},
{
- title: 'DNS',
+ title: gettext('DNS'),
itemId: 'dns',
xtype: 'pveOpenVZDNS'
},
xtype: 'pveOpenVZOptions'
},
{
- title: 'Task History',
+ title: gettext('Task History'),
itemId: 'tasks',
xtype: 'pveNodeTasks',
vmidFilter: vmid
var bridgesel = Ext.create('PVE.form.BridgeSelector', {
name: 'bridge',
- fieldLabel: 'Bridge',
+ fieldLabel: gettext('Bridge'),
labelAlign: 'right',
autoSelect: true,
disabled: true,
name: 'hostname',
vtype: 'DnsName',
value: '',
- fieldLabel: 'Hostname',
+ fieldLabel: gettext('Hostname'),
skipEmptyText: true,
allowBlank: true
}
xtype: 'radiofield',
name: 'networkmode',
inputValue: 'bridge',
- boxLabel: 'Bridged mode',
+ boxLabel: gettext('Bridged mode'),
checked: false,
listeners: {
change: function(f, value) {
xtype: 'pvetextfield',
name: 'searchdomain',
skipEmptyText: true,
- fieldLabel: 'DNS domain',
+ fieldLabel: gettext('DNS domain'),
emptyText: 'use host settings',
allowBlank: true,
listeners: {
hostname: {
required: true,
defaultValue: me.pveSelNode.data.name,
- header: 'Hostname',
+ header: gettext('Hostname'),
editor: caps.vms['VM.Config.Network'] ? {
xtype: 'pveWindowEdit',
- subject: 'Hostname',
+ subject: gettext('Hostname'),
items: {
xtype: 'textfield',
name: 'hostname',
vtype: 'DnsName',
value: '',
- fieldLabel: 'Hostname',
+ fieldLabel: gettext('Hostname'),
allowBlank: true,
emptyText: me.pveSelNode.data.name
}
} : undefined
},
searchdomain: {
- header: 'DNS domain',
+ header: gettext('DNS domain'),
defaultValue: '',
editor: caps.vms['VM.Config.Network'] ? {
xtype: 'pveWindowEdit',
- subject: 'DNS domain',
+ subject: gettext('DNS domain'),
items: {
xtype: 'pvetextfield',
name: 'searchdomain',
- fieldLabel: 'DNS domain',
+ fieldLabel: gettext('DNS domain'),
allowBlank: false
}
} : undefined
{
xtype: 'textfield',
name: 'mac',
- fieldLabel: 'MAC',
+ fieldLabel: gettext('MAC address'),
vtype: 'MacAddress',
value: cdata.mac,
allowBlank: me.create,
xtype: 'PVE.form.BridgeSelector',
name: 'bridge',
nodename: me.nodename,
- fieldLabel: 'Bridge',
+ fieldLabel: gettext('Bridge'),
value: cdata.bridge,
allowBlank: false
},
{
xtype: 'textfield',
name: 'host_ifname',
- fieldLabel: 'Host device name',
+ fieldLabel: gettext('Host device name'),
value: cdata.host_ifname,
allowBlank: true,
emptyText: 'auto'
{
xtype: 'textfield',
name: 'host_mac',
- fieldLabel: 'Host MAC address',
+ fieldLabel: gettext('Host MAC address'),
vtype: 'MacAddress',
value: cdata.host_mac,
allowBlank: true,
renderer: me.renderValue
},
{
- header: 'Bridge',
+ header: gettext('Bridge'),
width: 110,
dataIndex: 'bridge'
},
{
- header: 'MAC',
+ header: gettext('MAC address'),
width: 110,
dataIndex: 'mac'
},
{
- header: 'Host ifname',
+ header: gettext('Host ifname'),
width: 110,
dataIndex: 'host_ifname'
},
{
- header: 'Host MAC',
+ header: gettext('Host MAC address'),
width: 110,
dataIndex: 'host_mac'
}
defaultValue: 'no set'
},
cpuunits: {
- header: 'CPU units',
+ header: gettext('CPU units'),
defaultValue: '1000',
editor: caps.vms['VM.Config.CPU'] ? {
xtype: 'pveWindowEdit',
- subject: 'CPU units',
+ subject: gettext('CPU units'),
items: {
xtype: 'numberfield',
name: 'cpuunits',
- fieldLabel: 'CPU units',
+ fieldLabel: gettext('CPU units'),
minValue: 8,
maxValue: 500000,
allowBlank: false
} : undefined
},
quotaugidlimit: {
- header: 'Quota UGID limit',
+ header: gettext('Quota UGID limit'),
defaultValue: '0',
renderer: function(value) {
if (value == 0) {
},
editor: caps.vms['VM.Config.Disk'] ? {
xtype: 'pveWindowEdit',
- subject: 'Quota UGID limit (0 to disable user quotas)',
+ subject: gettext('Quota UGID limit (0 to disable user quotas)'),
items: {
xtype: 'numberfield',
name: 'quotaugidlimit',
- fieldLabel: 'UGID limit',
+ fieldLabel: gettext('UGID limit'),
minValue: 0,
allowBlank: false
}
} : undefined
},
quotatime: {
- header: 'Quota Grace period',
+ header: gettext('Quota Grace period'),
defaultValue: '0',
editor: caps.vms['VM.Config.Disk'] ? {
xtype: 'pveWindowEdit',
- subject: 'Quota Grace period (seconds)',
+ subject: gettext('Quota Grace period (seconds)'),
items: {
xtype: 'numberfield',
name: 'quotatime',
minValue: 1,
value: '1',
step: 1,
- fieldLabel: 'CPUs',
+ fieldLabel: gettext('CPUs'),
labelWidth: labelWidth,
allowBlank: false
}
me.load();
}
-});
\ No newline at end of file
+});
var render_mem = function(value, metaData, record, rowIndex, colIndex, store) {
var maxmem = me.getObjectValue('maxmem', 0);
var per = (value / maxmem)*100;
- var text = "<div>Total: " + PVE.Utils.format_size(maxmem) + "</div>" +
- "<div>Used: " + PVE.Utils.format_size(value) + "</div>";
+ var text = "<div>" + gettext('Total') + ": " + PVE.Utils.format_size(maxmem) + "</div>" +
+ "<div>" + gettext('Used') + ": " + PVE.Utils.format_size(value) + "</div>";
return text;
};
var render_swap = function(value, metaData, record, rowIndex, colIndex, store) {
var maxswap = me.getObjectValue('maxswap', 0);
var per = (value / maxswap)*100;
- var text = "<div>Total: " + PVE.Utils.format_size(maxswap) + "</div>" +
- "<div>Used: " + PVE.Utils.format_size(value) + "</div>";
+ var text = "<div>" + gettext('Total') + ": " + PVE.Utils.format_size(maxswap) + "</div>" +
+ "<div>" + gettext('Used') + ": " + PVE.Utils.format_size(value) + "</div>";
return text;
};
name: { header: gettext('Name'), defaultValue: 'no name specified' },
status: { header: gettext('Status'), defaultValue: 'unknown', renderer: render_status },
failcnt: { visible: false },
- cpu: { header: 'CPU usage', required: true, renderer: render_cpu },
+ cpu: { header: gettext('CPU usage'), required: true, renderer: render_cpu },
cpus: { visible: false },
- mem: { header: 'Memory usage', required: true, renderer: render_mem },
+ mem: { header: gettext('Memory usage'), required: true, renderer: render_mem },
maxmem: { visible: false },
- swap: { header: 'VSwap usage', required: true, renderer: render_swap },
+ swap: { header: gettext('VSwap usage'), required: true, renderer: render_swap },
maxswap: { visible: false },
uptime: { header: gettext('Uptime'), required: true, renderer: PVE.Utils.render_uptime },
- ha: { header: 'Managed by HA', required: true, renderer: PVE.Utils.format_boolean }
+ ha: { header: gettext('Managed by HA'), required: true, renderer: PVE.Utils.format_boolean }
};
Ext.applyIf(me, {
var rstore = me.statusStore;
var statusview = Ext.create('PVE.openvz.StatusView', {
- title: 'Status',
+ title: gettext('Status'),
pveSelNode: me.pveSelNode,
width: 400,
rstore: rstore
},
{
xtype: 'pveRRDView',
- title: "CPU usage %",
+ title: gettext('CPU usage %'),
pveSelNode: me.pveSelNode,
datasource: 'cpu',
rrdurl: rrdurl
},
{
xtype: 'pveRRDView',
- title: "Memory usage",
+ title: gettext('Memory usage'),
pveSelNode: me.pveSelNode,
datasource: 'mem,maxmem',
rrdurl: rrdurl
},
{
xtype: 'pveRRDView',
- title: "Network traffic",
+ title: gettext('Network traffic'),
pveSelNode: me.pveSelNode,
datasource: 'netin,netout',
rrdurl: rrdurl
},
{
xtype: 'pveRRDView',
- title: "Disk IO",
+ title: gettext('Disk IO'),
pveSelNode: me.pveSelNode,
datasource: 'diskread,diskwrite',
rrdurl: rrdurl
url: me.url,
waitMsgTarget: me,
failure: function(response, opts) {
- me.update("Error " + response.htmlStatus);
+ me.update(gettext('Error') + " " + response.htmlStatus);
},
success: function(response, opts) {
var data = response.result.data.description || '';
xtype: 'radiofield',
name: 'mediaType',
inputValue: 'iso',
- boxLabel: 'Use CD/DVD disc image file (iso)',
+ boxLabel: gettext('Use CD/DVD disc image file (iso)'),
checked: true,
listeners: {
change: function(f, value) {
name: 'cdimage',
nodename: me.nodename,
storageContent: 'iso',
- fieldLabel: 'ISO Image',
+ fieldLabel: gettext('ISO Image'),
labelAlign: 'right',
allowBlank: false
});
xtype: 'radiofield',
name: 'mediaType',
inputValue: 'cdrom',
- boxLabel: 'Use physical CD/DVD Drive'
+ boxLabel: gettext('Use physical CD/DVD Drive')
});
items.push({
me.targetSel = Ext.create('PVE.form.NodeSelector', {
name: 'target',
- fieldLabel: 'Target node',
+ fieldLabel: gettext('Target node'),
selectCurNode: true,
allowBlank: false,
onlineValidator: true
}
me.kv1 = Ext.create('PVE.form.KVComboBox', {
- fieldLabel: 'Clone Mode',
+ fieldLabel: gettext('Clone Mode'),
name: 'clonemode',
allowBlank: false,
value: me.isTemplate ? 'clone' : 'copy',
me.snapshotSel = Ext.create('PVE.form.SnapshotSelector', {
name: 'snapname',
- fieldLabel: 'Snapshot',
+ fieldLabel: gettext('Snapshot'),
nodename: me.nodename,
vmid: me.vmid,
hidden: me.isTemplate ? true : false,
me.hdstoragesel = Ext.create('PVE.form.StorageSelector', {
name: 'storage',
nodename: me.nodename,
- fieldLabel: 'Target Storage',
+ fieldLabel: gettext('Target Storage'),
storageContent: 'images',
autoSelect: me.insideWizard,
allowBlank: true,
xtype: 'PVE.qemu.Options'
},
{
- title: 'Task History',
+ title: gettext('Task History'),
itemId: 'tasks',
xtype: 'pveNodeTasks',
vmidFilter: vmid
});
var cdpanel = Ext.create('PVE.qemu.CDInputPanel', {
- title: 'CD/DVD',
+ title: gettext('CD/DVD'),
confid: 'ide2',
fieldDefaults: {
labelWidth: 160
}
},
{
- title: 'OS',
+ title: gettext('OS'),
xtype: 'PVE.qemu.OSTypeInputPanel'
},
cdpanel,
hdpanel,
{
xtype: 'PVE.qemu.ProcessorInputPanel',
- title: 'CPU'
+ title: gettext('CPU')
},
{
xtype: 'PVE.qemu.MemoryInputPanel',
xtype: 'CacheTypeSelector',
name: 'cache',
value: '',
- fieldLabel: 'Cache'
+ fieldLabel: gettext('Cache')
});
if (!me.insideWizard) {
var value = response.result.data[me.confid];
var drive = PVE.Parser.parseQemuDrive(me.confid, value);
if (!drive) {
- Ext.Msg.alert('Error', 'Unable to parse drive options');
+ Ext.Msg.alert(gettext('Error'), gettext('Unable to parse drive options'));
me.close();
return;
}
xtype: 'displayfield',
name: 'disk',
value: me.disk,
- fieldLabel: 'Disk',
+ fieldLabel: gettext('Disk'),
vtype: 'StorageId',
allowBlank: false
}
me.hdstoragesel = Ext.create('PVE.form.StorageSelector', {
name: 'hdstorage',
nodename: me.nodename,
- fieldLabel: 'Target Storage',
+ fieldLabel: gettext('Target Storage'),
storageContent: 'images',
autoSelect: me.insideWizard,
allowBlank: true,
waitMsgTarget: me,
method: 'PUT',
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, options) {
me.close();
xtype: 'displayfield',
name: 'disk',
value: me.disk,
- fieldLabel: 'Disk',
+ fieldLabel: gettext('Disk'),
vtype: 'StorageId',
allowBlank: false
}
me.bridgesel = Ext.create('PVE.form.BridgeSelector', {
name: 'bridge',
- fieldLabel: 'Bridge',
+ fieldLabel: gettext('Bridge'),
nodename: me.nodename,
labelAlign: 'right',
autoSelect: true,
name: 'networkmode',
height: 22, // hack: set same height as text fields
inputValue: 'bridge',
- boxLabel: 'Bridged mode',
+ boxLabel: gettext('Bridged mode'),
checked: true,
listeners: {
change: function(f, value) {
maxValue: 4094,
value: '',
emptyText: 'no VLAN',
- fieldLabel: 'VLAN Tag',
+ fieldLabel: gettext('VLAN Tag'),
labelAlign: 'right',
allowBlank: true
},
name: 'networkmode',
height: 22, // hack: set same height as text fields
inputValue: 'nat',
- boxLabel: 'NAT mode'
+ boxLabel: gettext('NAT mode')
}
];
name: 'networkmode',
height: 22, // hack: set same height as text fields
inputValue: 'none',
- boxLabel: 'No network device'
+ boxLabel: gettext('No network device')
});
}
{
xtype: 'PVE.form.NetworkCardSelector',
name: 'model',
- fieldLabel: 'Model',
+ fieldLabel: gettext('Model'),
value: 'e1000',
allowBlank: false
},
{
xtype: 'textfield',
name: 'macaddr',
- fieldLabel: 'MAC address',
+ fieldLabel: gettext('MAC address'),
vtype: 'MacAddress',
allowBlank: true,
emptyText: 'auto'
{
xtype: 'numberfield',
name: 'rate',
- fieldLabel: 'Rate limit (MB/s)',
+ fieldLabel: gettext('Rate limit (MB/s)'),
minValue: 0,
maxValue: 10*1024,
value: '',
var value = me.vmconfig[me.confid];
var network = PVE.Parser.parseQemuNetwork(me.confid, value);
if (!network) {
- Ext.Msg.alert('Error', 'Unable to parse network options');
+ Ext.Msg.alert(gettext('Error'), gettext('Unable to parse network options'));
me.close();
return;
}
me.column2 = [
{
xtype: 'component',
- html: 'Linux/Other',
+ html: 'Linux/' + gettext('Other'),
cls:'x-form-check-group-label'
},
{
'PVE.qemu.StartupEdit' : undefined
},
ostype: {
- header: 'OS Type',
+ header: gettext('OS Type'),
editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.OSTypeEdit' : undefined,
renderer: PVE.Utils.render_kvm_ostype,
defaultValue: 'other'
}
},
tablet: {
- header: 'Use tablet for pointer',
+ header: gettext('Use tablet for pointer'),
defaultValue: true,
renderer: PVE.Utils.format_boolean,
editor: caps.vms['VM.Config.HWType'] ? {
xtype: 'pveWindowEdit',
- subject: 'Use tablet for pointer',
+ subject: gettext('Use tablet for pointer'),
items: {
xtype: 'pvecheckbox',
name: 'tablet',
} : undefined
},
acpi: {
- header: 'ACPI support',
+ header: gettext('ACPI support'),
defaultValue: true,
renderer: PVE.Utils.format_boolean,
editor: caps.vms['VM.Config.HWType'] ? {
xtype: 'pveWindowEdit',
- subject: 'ACPI support',
+ subject: gettext('ACPI support'),
items: {
xtype: 'pvecheckbox',
name: 'acpi',
} : undefined
},
scsihw: {
- header: 'SCSI Controller Type',
+ header: gettext('SCSI Controller Type'),
editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.ScsiHwEdit' : undefined,
renderer: PVE.Utils.render_scsihw,
defaultValue: ''
},
kvm: {
- header: 'KVM hardware virtualization',
+ header: gettext('KVM hardware virtualization'),
defaultValue: true,
renderer: PVE.Utils.format_boolean,
editor: caps.vms['VM.Config.HWType'] ? {
xtype: 'pveWindowEdit',
- subject: 'KVM hardware virtualization',
+ subject: gettext('KVM hardware virtualization'),
items: {
xtype: 'pvecheckbox',
name: 'kvm',
} : undefined
},
cpuunits: {
- header: 'CPU units',
+ header: gettext('CPU units'),
defaultValue: '1000',
editor: caps.vms['VM.Config.CPU'] ? {
xtype: 'pveWindowEdit',
- subject: 'CPU units',
+ subject: gettext('CPU units'),
items: {
xtype: 'numberfield',
name: 'cpuunits',
- fieldLabel: 'CPU units',
+ fieldLabel: gettext('CPU units'),
minValue: 8,
maxValue: 500000,
defaultValue: 1000,
} : undefined
},
freeze: {
- header: 'Freeze CPU at startup',
+ header: gettext('Freeze CPU at startup'),
defaultValue: false,
renderer: PVE.Utils.format_boolean,
editor: caps.vms['VM.PowerMgmt'] ? {
xtype: 'pveWindowEdit',
- subject: 'Freeze CPU at startup',
+ subject: gettext('Freeze CPU at startup'),
items: {
xtype: 'pvecheckbox',
name: 'freeze',
defaultValue: 0,
deleteDefaultValue: true,
labelWidth: 140,
- fieldLabel: 'Freeze CPU at startup'
+ fieldLabel: gettext('Freeze CPU at startup')
}
} : undefined
},
localtime: {
- header: 'Use local time for RTC',
+ header: gettext('Use local time for RTC'),
defaultValue: false,
renderer: PVE.Utils.format_boolean,
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'pveWindowEdit',
- subject: 'Use local time for RTC',
+ subject: gettext('Use local time for RTC'),
items: {
xtype: 'pvecheckbox',
name: 'localtime',
defaultValue: 0,
deleteDefaultValue: true,
labelWidth: 140,
- fieldLabel: 'Use local time for RTC'
+ fieldLabel: gettext('Use local time for RTC')
}
} : undefined
},
startdate: {
- header: 'RTC start date',
+ header: gettext('RTC start date'),
defaultValue: 'now',
editor: caps.vms['VM.Config.Options'] ? {
xtype: 'pveWindowEdit',
- subject: 'RTC start date',
+ subject: gettext('RTC start date'),
items: {
xtype: 'pvetextfield',
name: 'startdate',
deleteEmpty: true,
value: 'now',
- fieldLabel: 'RTC start date',
+ fieldLabel: gettext('RTC start date'),
vtype: 'QemuStartDate',
allowBlank: true
}
minValue: 1,
maxValue: 4,
value: '1',
- fieldLabel: 'Sockets',
+ fieldLabel: gettext('Sockets'),
allowBlank: false,
listeners: {
change: function(f, value) {
minValue: 1,
maxValue: 32,
value: '1',
- fieldLabel: 'Cores',
+ fieldLabel: gettext('Cores'),
allowBlank: false,
listeners: {
change: function(f, value) {
xtype: 'CPUModelSelector',
name: 'cpu',
value: '',
- fieldLabel: 'CPU type'
+ fieldLabel: gettext('CPU type')
},
{
xtype: 'displayfield',
- fieldLabel: 'Total cores',
+ fieldLabel: gettext('Total cores'),
name: 'totalcores',
value: '1'
}
me.load();
}
-});
\ No newline at end of file
+});
waitMsgTarget: me,
method: 'POST',
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, options) {
var upid = response.result.data;
waitMsgTarget: me,
method: 'PUT',
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, options) {
me.close();
waitMsgTarget: me,
method: 'GET',
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
me.close();
},
success: function(response, options) {
}
},
{
- text: 'RAM',
+ text: gettext('RAM'),
align: 'center',
resizable: false,
dataIndex: 'vmstate',
var render_mem = function(value, metaData, record, rowIndex, colIndex, store) {
var maxmem = me.getObjectValue('maxmem', 0);
var per = (value / maxmem)*100;
- var text = "<div>Total: " + PVE.Utils.format_size(maxmem) + "</div>" +
- "<div>Used: " + PVE.Utils.format_size(value) + "</div>";
+ var text = "<div>" + gettext('Total') + ": " + PVE.Utils.format_size(maxmem) + "</div>" +
+ "<div>" + gettext('Used') + ": " + PVE.Utils.format_size(value) + "</div>";
return text;
};
var rows = {
name: { header: gettext('Name'), defaultValue: 'no name specified' },
qmpstatus: { header: gettext('Status'), defaultValue: 'unknown' },
- cpu: { header: 'CPU usage', required: true, renderer: render_cpu },
+ cpu: { header: gettext('CPU usage'), required: true, renderer: render_cpu },
cpus: { visible: false },
- mem: { header: 'Memory usage', required: true, renderer: render_mem },
+ mem: { header: gettext('Memory usage'), required: true, renderer: render_mem },
maxmem: { visible: false },
uptime: { header: gettext('Uptime'), required: true, renderer: PVE.Utils.render_uptime },
- ha: { header: 'Managed by HA', required: true, renderer: PVE.Utils.format_boolean }
+ ha: { header: gettext('Managed by HA'), required: true, renderer: PVE.Utils.format_boolean }
};
Ext.applyIf(me, {
var rstore = me.statusStore;
var statusview = Ext.create('PVE.qemu.StatusView', {
- title: 'Status',
+ title: gettext('Status'),
pveSelNode: me.pveSelNode,
width: 400,
rstore: rstore
},
{
xtype: 'pveRRDView',
- title: "CPU usage %",
+ title: gettext('CPU usage %'),
pveSelNode: me.pveSelNode,
datasource: 'cpu',
rrdurl: rrdurl
},
{
xtype: 'pveRRDView',
- title: "Memory usage",
+ title: gettext('Memory usage'),
pveSelNode: me.pveSelNode,
datasource: 'mem,maxmem',
rrdurl: rrdurl
},
{
xtype: 'pveRRDView',
- title: "Network traffic",
+ title: gettext('Network traffic'),
pveSelNode: me.pveSelNode,
datasource: 'netin,netout',
rrdurl: rrdurl
},
{
xtype: 'pveRRDView',
- title: "Disk IO",
+ title: gettext('Disk IO'),
pveSelNode: me.pveSelNode,
datasource: 'diskread,diskwrite',
rrdurl: rrdurl
url: '/nodes/' + nodename + '/qemu/' + vmid + "/status/" + cmd,
method: 'POST',
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
}
});
};
},
method: 'POST',
failure: function (response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, options) {
var upid = response.result.data;
{
xtype: 'pveKVComboBox',
data: [
- ['iso', 'ISO image'],
- ['backup', 'VZDump backup file'],
- ['vztmpl', 'OpenVZ template']
+ ['iso', gettext('ISO image')],
+ ['backup', gettext('VZDump backup file')],
+ ['vztmpl', gettext('OpenVZ template')]
],
fieldLabel: gettext('Content'),
name: 'content',
if (xhr.status == 200) {
me.close();
} else {
- var msg = "Error " + xhr.status.toString() + ": " + Ext.htmlEncode(xhr.statusText);
+ 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);
idProperty: 'volid'
});
-});
\ No newline at end of file
+});
displayField: 'target',
matchFieldWidth: false,
listConfig: {
- loadingText: 'Scanning...',
+ loadingText: gettext('Scanning...'),
listeners: {
// hack: call setHeight to show scroll bars correctly
refresh: function(list) {
height: 22, // hack: set same height as text fields
name: 'portal',
value: '',
- fieldLabel: 'Portal',
+ fieldLabel: gettext('Portal'),
allowBlank: false,
listeners: {
change: function(f, value) {
xtype: me.create ? 'pveIScsiScan' : 'displayfield',
name: 'target',
value: '',
- fieldLabel: 'Target',
+ fieldLabel: gettext('Target'),
allowBlank: false
}
];
});
Ext.apply(me, {
- subject: 'iSCSI target',
+ subject: gettext('iSCSI target'),
isAdd: true,
items: [ ipanel ]
});
queryMode: 'local',
editable: false,
listConfig: {
- loadingText: 'Scanning...',
+ loadingText: gettext('Scanning...'),
listeners: {
// hack: call setHeight to show scroll bars correctly
refresh: function(list) {
});
Ext.apply(me, {
- subject: 'LVM group',
+ subject: gettext('LVM group'),
isAdd: true,
items: [ ipanel ]
});
displayField: 'path',
matchFieldWidth: false,
listConfig: {
- loadingText: 'Scanning...',
+ loadingText: gettext('Scanning...'),
listeners: {
// hack: call setHeight to show scroll bars correctly
refresh: function(list) {
height: 22, // hack: set same height as text fields
name: 'export',
value: '',
- fieldLabel: 'Export',
+ fieldLabel: gettext('Export'),
allowBlank: false
},
{
});
Ext.apply(me, {
- subject: 'NFS share',
+ subject: gettext('NFS share'),
isAdd: true,
items: [ ipanel ]
});
});
Ext.apply(me, {
- subject: 'Nexenta Storage',
+ subject: gettext('Nexenta Storage'),
isAdd: true,
items: [ ipanel ]
});
});
Ext.apply(me, {
- subject: 'RBD Storage',
+ subject: gettext('RBD Storage'),
isAdd: true,
items: [ ipanel ]
});
});
Ext.apply(me, {
- subject: 'Sheepdog Storage',
+ subject: gettext('Sheepdog Storage'),
isAdd: true,
items: [ ipanel ]
});
statusview,
{
xtype: 'pveRRDView',
- title: "Usage",
+ title: gettext('Usage'),
pveSelNode: me.pveSelNode,
datasource: 'total,used',
rrdurl: rrdurl
waitMsgTarget: me,
method: 'POST',
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, options) {
var upid = response.result.data;
{
xtype: 'PVE.form.NodeSelector',
name: 'target',
- fieldLabel: 'Target node',
+ fieldLabel: gettext('Target node'),
allowBlank: false,
onlineValidator: true
},
uncheckedValue: 0,
defaultValue: 0,
checked: running,
- fieldLabel: 'Online'
+ fieldLabel: gettext('Online')
}
]
});
var form = me.formPanel.getForm();
var submitBtn = Ext.create('Ext.Button', {
- text: 'Migrate',
+ text: gettext('Migrate'),
handler: function() {
var values = form.getValues();
me.migrate(values.target, values.online);
});
Ext.apply(me, {
- title: "Migrate VM " + me.vmid,
+ title: gettext('Migrate VM') + " " + me.vmid,
width: 350,
modal: true,
layout: 'auto',
method: 'POST',
waitMsgTarget: me,
failure: function (response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, options) {
var upid = response.result.data;
if (me.vmid) {
var msg = gettext('Are you sure you want to restore this VM?') + ' ' +
gettext('This will permanently erase current VM data.');
- Ext.Msg.confirm('Confirmation', msg, function(btn) {
+ Ext.Msg.confirm(gettext('Confirmation'), msg, function(btn) {
if (btn !== 'yes') {
return;
}
submitBtn.setDisabled(!valid);
});
- var title = (me.vmtype === 'openvz') ? "Restore CT" : "Restore VM";
+ var title = (me.vmtype === 'openvz') ? gettext('Restore CT') : gettext('Restore VM');
Ext.apply(me, {
title: title,
visible: false
},
type: {
- header: 'Task type',
+ header: gettext('Task type'),
required: true
},
user: {
required: true
},
pid: {
- header: 'Process ID',
+ header: gettext('Process ID'),
required: true
},
starttime: {
renderer: PVE.Utils.render_timestamp
},
upid: {
- header: 'Unique task ID'
+ header: gettext('Unique task ID')
}
};
waitMsgTarget: me,
method: 'DELETE',
failure: function(response, opts) {
- Ext.Msg.alert('Error', response.htmlStatus);
+ Ext.Msg.alert(gettext('Error'), response.htmlStatus);
}
});
};
projects / pve-manager.git / commitdiff