mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
1208 lines
62 KiB
JavaScript
1208 lines
62 KiB
JavaScript
// Licensed to the Apache Software Foundation (ASF) under one
|
|
// or more contributor license agreements. See the NOTICE file
|
|
// distributed with this work for additional information
|
|
// regarding copyright ownership. The ASF licenses this file
|
|
// to you under the Apache License, Version 2.0 (the
|
|
// "License"); you may not use this file except in compliance
|
|
// with the License. You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing,
|
|
// software distributed under the License is distributed on an
|
|
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the License for the
|
|
// specific language governing permissions and limitations
|
|
// under the License.
|
|
(function(cloudStack) {
|
|
cloudStack.sections.metrics = {
|
|
title: 'label.metrics',
|
|
listView: {
|
|
id: 'metrics',
|
|
fields: {
|
|
name: {
|
|
label: 'metrics'
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
// Zones Metrics
|
|
cloudStack.sections.metrics.zones = {
|
|
title: 'label.metrics',
|
|
listView: {
|
|
id: 'physicalResources',
|
|
fields: {
|
|
name: {
|
|
label: 'label.metrics.name'
|
|
},
|
|
state: {
|
|
label: 'label.metrics.state',
|
|
converter: function (str) {
|
|
// For localization
|
|
return str;
|
|
},
|
|
indicator: {
|
|
'Enabled': 'on',
|
|
'Disabled': 'off'
|
|
},
|
|
compact: true
|
|
},
|
|
clusters : {
|
|
label: 'label.metrics.clusters'
|
|
},
|
|
cpuused: {
|
|
label: 'label.metrics.cpu.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
cpuusedavg: {
|
|
label: 'label.metrics.cpu.used.avg',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'cpunotificationthreshold',
|
|
disable: 'cpudisablethreshold'
|
|
}
|
|
},
|
|
cpumaxdev: {
|
|
label: 'label.metrics.cpu.max.dev'
|
|
}
|
|
}
|
|
},
|
|
cpuallocated: {
|
|
label: 'label.metrics.cpu.allocated',
|
|
collapsible: true,
|
|
columns: {
|
|
cpuallocated: {
|
|
label: 'label.metrics.allocated',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'cpunotificationthreshold',
|
|
disable: 'cpudisablethreshold'
|
|
}
|
|
},
|
|
cputotal: {
|
|
label: 'label.metrics.cpu.total'
|
|
}
|
|
}
|
|
},
|
|
memused: {
|
|
label: 'label.metrics.memory.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
memusedavg: {
|
|
label: 'label.metrics.memory.used.avg',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'memnotificationthreshold',
|
|
disable: 'memdisablethreshold'
|
|
}
|
|
},
|
|
memmaxdev: {
|
|
label: 'label.metrics.memory.max.dev'
|
|
}
|
|
}
|
|
},
|
|
memallocated: {
|
|
label: 'label.metrics.memory.allocated',
|
|
collapsible: true,
|
|
columns: {
|
|
memallocated: {
|
|
label: 'label.metrics.allocated',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'memnotificationthreshold',
|
|
disable: 'memdisablethreshold'
|
|
}
|
|
},
|
|
memtotal: {
|
|
label: 'label.metrics.memory.total'
|
|
}
|
|
}
|
|
}
|
|
},
|
|
dataProvider: function(args) {
|
|
var data = {};
|
|
listViewDataProvider(args, data);
|
|
$.ajax({
|
|
url: createURL('listZones'),
|
|
data: data,
|
|
success: function(json) {
|
|
var items = json.listzonesresponse.zone;
|
|
if (items) {
|
|
$.each(items, function(idx, zone) {
|
|
items[idx].clusters = 0;
|
|
items[idx].clustersUp = 0;
|
|
items[idx].hosts = 0;
|
|
items[idx].cpuusedavg = 0.0;
|
|
items[idx].cpumaxdev = 0.0;
|
|
items[idx].cpuallocated = 0.0;
|
|
items[idx].cputotal = 0.0;
|
|
items[idx].maxCpuUsed = 0.0;
|
|
items[idx].memusedavg = 0.0;
|
|
items[idx].memmaxdev = 0.0;
|
|
items[idx].memallocated = 0.0;
|
|
items[idx].memtotal = 0.0;
|
|
items[idx].maxMemUsed = 0.0;
|
|
|
|
// Threshold color coding
|
|
items[idx].cpunotificationthreshold = 75.0;
|
|
items[idx].cpudisablethreshold = 95.0;
|
|
items[idx].memnotificationthreshold = 75.0;
|
|
items[idx].memdisablethreshold = 95.0;
|
|
|
|
$.ajax({
|
|
url: createURL('listClusters'),
|
|
data: {zoneid: zone.id, pagesize: -1},
|
|
success: function(json) {
|
|
if (json && json.listclustersresponse && json.listclustersresponse.cluster && json.listclustersresponse.count) {
|
|
items[idx].clusters += parseInt(json.listclustersresponse.count);
|
|
$.each(json.listclustersresponse.cluster, function(i, cluster) {
|
|
if (cluster.allocationstate == 'Enabled' && cluster.managedstate == 'Managed') {
|
|
items[idx].clustersUp += 1;
|
|
}
|
|
$.ajax({
|
|
url: createURL('listHosts'),
|
|
data: {clusterid: cluster.id, type: 'routing', pagesize: -1},
|
|
success: function(json) {
|
|
if (json && json.listhostsresponse && json.listhostsresponse.host && json.listhostsresponse.count) {
|
|
items[idx].hosts += parseInt(json.listhostsresponse.count);
|
|
$.each(json.listhostsresponse.host, function(i, host) {
|
|
if (host.hasOwnProperty('cpuused')) {
|
|
var hostCpuUsage = parseFloat(host.cpuused);
|
|
items[idx].cpuusedavg += hostCpuUsage;
|
|
if (hostCpuUsage > items[idx].maxCpuUsed) {
|
|
items[idx].maxCpuUsed = hostCpuUsage;
|
|
}
|
|
}
|
|
|
|
if (host.hasOwnProperty('cpuallocated')) {
|
|
items[idx].cpuallocated += parseFloat(host.cpuallocated.replace('%', ''));
|
|
}
|
|
|
|
if (host.hasOwnProperty('memoryused')) {
|
|
var hostMemoryUsage = 100.0 * parseFloat(host.memoryused) / parseFloat(host.memorytotal);
|
|
items[idx].memusedavg += hostMemoryUsage;
|
|
if (hostMemoryUsage > items[idx].maxMemUsed) {
|
|
items[idx].maxMemUsed = hostMemoryUsage;
|
|
}
|
|
}
|
|
|
|
if (host.hasOwnProperty('memoryallocated')) {
|
|
items[idx].memallocated += parseFloat(100.0 * parseFloat(host.memoryallocated)/parseFloat(host.memorytotal));
|
|
}
|
|
});
|
|
}
|
|
},
|
|
async: false
|
|
});
|
|
});
|
|
}
|
|
},
|
|
async: false
|
|
});
|
|
|
|
$.ajax({
|
|
url: createURL('listCapacity'),
|
|
data: {zoneid: zone.id},
|
|
success: function(json) {
|
|
if (json && json.listcapacityresponse && json.listcapacityresponse.capacity) {
|
|
$.each(json.listcapacityresponse.capacity, function(i, capacity) {
|
|
// CPU
|
|
if (capacity.type == 1) {
|
|
items[idx].cputotal = parseInt(capacity.capacitytotal)/1000.0;
|
|
}
|
|
// Memory
|
|
if (capacity.type == 0) {
|
|
items[idx].memtotal = parseInt(capacity.capacitytotal)/(1024.0*1024.0*1024.0);
|
|
}
|
|
});
|
|
}
|
|
},
|
|
async: false
|
|
});
|
|
|
|
if (items[idx].hosts != 0) {
|
|
items[idx].cpuusedavg = (items[idx].cpuusedavg / items[idx].hosts);
|
|
items[idx].cpumaxdev = (items[idx].maxCpuUsed - items[idx].cpuusedavg);
|
|
items[idx].cpuallocated = (items[idx].cpuallocated / items[idx].hosts);
|
|
|
|
items[idx].memusedavg = (items[idx].memusedavg / items[idx].hosts);
|
|
items[idx].memmaxdev = (items[idx].maxMemUsed - items[idx].memusedavg);
|
|
items[idx].memallocated = (items[idx].memallocated / items[idx].hosts);
|
|
}
|
|
// Format data
|
|
items[idx].cpuusedavg = (items[idx].cpuusedavg).toFixed(2) + "%";
|
|
items[idx].cpumaxdev = (items[idx].cpumaxdev).toFixed(2) + "%";
|
|
items[idx].cpuallocated = (items[idx].cpuallocated).toFixed(2) + "%";
|
|
items[idx].cputotal = (items[idx].cputotal).toFixed(2) + " Ghz";
|
|
|
|
items[idx].memusedavg = (items[idx].memusedavg).toFixed(2) + "%";
|
|
items[idx].memmaxdev = (items[idx].memmaxdev).toFixed(2) + "%";
|
|
items[idx].memallocated = (items[idx].memallocated).toFixed(2) + "%";
|
|
items[idx].memtotal = (items[idx].memtotal).toFixed(2) + " GB";
|
|
|
|
items[idx].clusters = items[idx].clustersUp + ' / ' + items[idx].clusters;
|
|
items[idx].state = items[idx].allocationstate;
|
|
});
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
},
|
|
browseBy: {
|
|
filterBy: 'zoneid',
|
|
resource: 'clusters'
|
|
},
|
|
detailView: cloudStack.sections.system.physicalResourceSection.sections.physicalResources.listView.zones.detailView
|
|
}
|
|
};
|
|
|
|
|
|
// Clusters Metrics
|
|
cloudStack.sections.metrics.clusters = {
|
|
title: 'label.metrics',
|
|
listView: {
|
|
id: 'clusters',
|
|
fields: {
|
|
name: {
|
|
label: 'label.metrics.name'
|
|
},
|
|
state: {
|
|
label: 'label.metrics.state',
|
|
converter: function (str) {
|
|
// For localization
|
|
return str;
|
|
},
|
|
indicator: {
|
|
'Enabled': 'on',
|
|
'Unmanaged': 'warning',
|
|
'Disabled': 'off'
|
|
},
|
|
compact: true
|
|
},
|
|
hosts: {
|
|
label: 'label.metrics.hosts'
|
|
},
|
|
cpuused: {
|
|
label: 'label.metrics.cpu.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
cpuusedavg: {
|
|
label: 'label.metrics.cpu.used.avg',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'cpunotificationthreshold',
|
|
disable: 'cpudisablethreshold'
|
|
}
|
|
},
|
|
cpumaxdev: {
|
|
label: 'label.metrics.cpu.max.dev'
|
|
}
|
|
}
|
|
},
|
|
cpuallocated: {
|
|
label: 'label.metrics.cpu.allocated',
|
|
collapsible: true,
|
|
columns: {
|
|
cpuallocated: {
|
|
label: 'label.metrics.allocated',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'cpunotificationthreshold',
|
|
disable: 'cpudisablethreshold'
|
|
}
|
|
},
|
|
cputotal: {
|
|
label: 'label.metrics.cpu.total'
|
|
}
|
|
}
|
|
},
|
|
memused: {
|
|
label: 'label.metrics.memory.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
memusedavg: {
|
|
label: 'label.metrics.memory.used.avg',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'memnotificationthreshold',
|
|
disable: 'memdisablethreshold'
|
|
}
|
|
},
|
|
memmaxdev: {
|
|
label: 'label.metrics.memory.max.dev'
|
|
}
|
|
}
|
|
},
|
|
memallocated: {
|
|
label: 'label.metrics.memory.allocated',
|
|
collapsible: true,
|
|
columns: {
|
|
memallocated: {
|
|
label: 'label.metrics.allocated',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'memnotificationthreshold',
|
|
disable: 'memdisablethreshold'
|
|
}
|
|
},
|
|
memtotal: {
|
|
label: 'label.metrics.memory.total'
|
|
}
|
|
}
|
|
}
|
|
},
|
|
dataProvider: function(args) {
|
|
var data = {};
|
|
listViewDataProvider(args, data);
|
|
|
|
if ("zones" in args.context && args.context.zones[0]) {
|
|
data['zoneid'] = args.context.zones[0].id;
|
|
}
|
|
|
|
if ("pods" in args.context && args.context.pods[0]) {
|
|
data['podid'] = args.context.pods[0].id;
|
|
}
|
|
|
|
if (args.context.metricsFilterData && args.context.metricsFilterData.key && args.context.metricsFilterData.value) {
|
|
data[args.context.metricsFilterData.key] = args.context.metricsFilterData.value;
|
|
}
|
|
|
|
$.ajax({
|
|
url: createURL('listClusters'),
|
|
data: data,
|
|
success: function(json) {
|
|
var items = json.listclustersresponse.cluster;
|
|
if (items) {
|
|
$.each(items, function(idx, cluster) {
|
|
items[idx].hosts = 0;
|
|
items[idx].hostsUp = 0;
|
|
items[idx].cpuusedavg = 0.0;
|
|
items[idx].cpumaxdev = 0.0;
|
|
items[idx].cpuallocated = 0.0;
|
|
items[idx].cputotal = 0.0;
|
|
items[idx].maxCpuUsed = 0;
|
|
items[idx].memusedavg = 0.0;
|
|
items[idx].memmaxdev = 0.0;
|
|
items[idx].memallocated = 0.0;
|
|
items[idx].memtotal = 0.0;
|
|
items[idx].maxMemUsed = 0.0;
|
|
|
|
// Threshold color coding
|
|
items[idx].cpunotificationthreshold = 75.0;
|
|
items[idx].cpudisablethreshold = 95.0;
|
|
items[idx].memnotificationthreshold = 75.0;
|
|
items[idx].memdisablethreshold = 95.0;
|
|
|
|
$.ajax({
|
|
url: createURL('listConfigurations'),
|
|
data: {clusterid: cluster.id, listAll: true},
|
|
success: function(json) {
|
|
if (json.listconfigurationsresponse && json.listconfigurationsresponse.configuration) {
|
|
$.each(json.listconfigurationsresponse.configuration, function(i, config) {
|
|
switch (config.name) {
|
|
case 'cluster.cpu.allocated.capacity.disablethreshold':
|
|
items[idx].cpudisablethreshold = 100 * parseFloat(config.value);
|
|
break;
|
|
case 'cluster.cpu.allocated.capacity.notificationthreshold':
|
|
items[idx].cpunotificationthreshold = 100 * parseFloat(config.value);
|
|
break;
|
|
case 'cluster.memory.allocated.capacity.disablethreshold':
|
|
items[idx].memdisablethreshold = 100 * parseFloat(config.value);
|
|
break;
|
|
case 'cluster.memory.allocated.capacity.notificationthreshold':
|
|
items[idx].memnotificationthreshold = 100 * parseFloat(config.value);
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
},
|
|
async: false
|
|
});
|
|
|
|
$.ajax({
|
|
url: createURL('listHosts'),
|
|
data: {clusterid: cluster.id, type: 'routing', pagesize: -1},
|
|
success: function(json) {
|
|
if (json && json.listhostsresponse && json.listhostsresponse.host && json.listhostsresponse.count) {
|
|
items[idx].hosts += parseInt(json.listhostsresponse.count);
|
|
$.each(json.listhostsresponse.host, function(i, host) {
|
|
if (host.state == 'Up') {
|
|
items[idx].hostsUp += 1;
|
|
}
|
|
if (host.hasOwnProperty('cpuused')) {
|
|
var hostCpuUsage = parseFloat(host.cpuused);
|
|
items[idx].cpuusedavg += hostCpuUsage;
|
|
if (hostCpuUsage > items[idx].maxCpuUsed) {
|
|
items[idx].maxCpuUsed = hostCpuUsage;
|
|
}
|
|
}
|
|
|
|
if (host.hasOwnProperty('cpuallocated')) {
|
|
items[idx].cpuallocated += parseFloat(host.cpuallocated.replace('%', ''));
|
|
}
|
|
|
|
if (host.hasOwnProperty('memoryused')) {
|
|
var hostMemoryUsage = 100.0 * parseFloat(host.memoryused) / parseFloat(host.memorytotal);
|
|
items[idx].memusedavg += hostMemoryUsage;
|
|
if (hostMemoryUsage > items[idx].maxMemUsed) {
|
|
items[idx].maxMemUsed = hostMemoryUsage;
|
|
}
|
|
}
|
|
|
|
if (host.hasOwnProperty('memoryallocated')) {
|
|
items[idx].memallocated += parseFloat(100.0 * parseFloat(host.memoryallocated)/parseFloat(host.memorytotal));
|
|
}
|
|
});
|
|
}
|
|
},
|
|
async: false
|
|
});
|
|
|
|
$.ajax({
|
|
url: createURL('listCapacity'),
|
|
data: {clusterid: cluster.id},
|
|
success: function(json) {
|
|
if (json && json.listcapacityresponse && json.listcapacityresponse.capacity) {
|
|
$.each(json.listcapacityresponse.capacity, function(i, capacity) {
|
|
// CPU
|
|
if (capacity.type == 1) {
|
|
items[idx].cputotal = parseInt(capacity.capacitytotal)/1000.0;
|
|
}
|
|
// Memory
|
|
if (capacity.type == 0) {
|
|
items[idx].memtotal = parseInt(capacity.capacitytotal)/(1024.0*1024.0*1024.0);
|
|
}
|
|
});
|
|
}
|
|
},
|
|
async: false
|
|
});
|
|
|
|
if (items[idx].hosts != 0) {
|
|
items[idx].cpuusedavg = (items[idx].cpuusedavg / items[idx].hosts);
|
|
items[idx].cpumaxdev = (items[idx].maxCpuUsed - items[idx].cpuusedavg);
|
|
items[idx].cpuallocated = (items[idx].cpuallocated / items[idx].hosts);
|
|
|
|
items[idx].memusedavg = (items[idx].memusedavg / items[idx].hosts);
|
|
items[idx].memmaxdev = (items[idx].maxMemUsed - items[idx].memusedavg);
|
|
items[idx].memallocated = (items[idx].memallocated / items[idx].hosts);
|
|
}
|
|
|
|
// Format data
|
|
items[idx].cpuusedavg = (items[idx].cpuusedavg).toFixed(2) + "%";
|
|
items[idx].cpumaxdev = (items[idx].cpumaxdev).toFixed(2) + "%";
|
|
items[idx].cpuallocated = (items[idx].cpuallocated).toFixed(2) + "%";
|
|
items[idx].cputotal = (items[idx].cputotal).toFixed(2) + " Ghz";
|
|
|
|
items[idx].memusedavg = (items[idx].memusedavg).toFixed(2) + "%";
|
|
items[idx].memmaxdev = (items[idx].memmaxdev).toFixed(2) + "%";
|
|
items[idx].memallocated = (items[idx].memallocated).toFixed(2) + "%";
|
|
items[idx].memtotal = (items[idx].memtotal).toFixed(2) + " GB";
|
|
items[idx].hosts = items[idx].hostsUp + ' / ' + items[idx].hosts;
|
|
|
|
items[idx].state = items[idx].allocationstate;
|
|
if (items[idx].managedstate == 'Unmanaged') {
|
|
items[idx].state = 'Unmanaged';
|
|
}
|
|
|
|
if (items[idx].managedstate == 'Managed' && items[idx].allocationstate == 'Enabled') {
|
|
items[idx].state = 'Enabled';
|
|
}
|
|
|
|
if (items[idx].managedstate == 'Managed' && items[idx].allocationstate == 'Disabled') {
|
|
items[idx].state = 'Disabled';
|
|
}
|
|
});
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
},
|
|
browseBy: {
|
|
filterBy: 'clusterid',
|
|
resource: 'hosts'
|
|
},
|
|
detailView: cloudStack.sections.system.subsections.clusters.listView.detailView
|
|
}
|
|
};
|
|
|
|
|
|
// Hosts Metrics
|
|
cloudStack.sections.metrics.hosts = {
|
|
title: 'label.metrics',
|
|
listView: {
|
|
id: 'hosts',
|
|
fields: {
|
|
name: {
|
|
label: 'label.metrics.name'
|
|
},
|
|
state: {
|
|
label: 'label.metrics.state',
|
|
converter: function (str) {
|
|
// For localization
|
|
return str;
|
|
},
|
|
indicator: {
|
|
'Up': 'on',
|
|
'Down': 'off',
|
|
'Disconnected': 'off',
|
|
'Removed': 'off',
|
|
'Error': 'off',
|
|
'Connecting': 'transition',
|
|
'Rebalancing': 'transition',
|
|
'Alert': 'warning'
|
|
},
|
|
compact: true
|
|
},
|
|
outofbandmanagementpowerstate: {
|
|
label: 'label.metrics.outofbandmanagementpowerstate',
|
|
converter: function (str) {
|
|
// For localization
|
|
return str;
|
|
},
|
|
indicator: {
|
|
'On': 'on',
|
|
'Off': 'off',
|
|
'Unknown': 'warning'
|
|
},
|
|
compact: true
|
|
},
|
|
instances: {
|
|
label: 'label.instances'
|
|
},
|
|
cpuused: {
|
|
label: 'label.metrics.cpu.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
cores: {
|
|
label: 'label.metrics.num.cpu.cores'
|
|
},
|
|
cputotal: {
|
|
label: 'label.metrics.cpu.total'
|
|
},
|
|
cpuusedavg: {
|
|
label: 'label.metrics.cpu.used.avg',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'cpunotificationthreshold',
|
|
disable: 'cpudisablethreshold'
|
|
}
|
|
},
|
|
cpuallocated: {
|
|
label: 'label.metrics.allocated',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'cpuallocatednotificationthreshold',
|
|
disable: 'cpuallocateddisablethreshold'
|
|
}
|
|
}
|
|
}
|
|
},
|
|
memused: {
|
|
label: 'label.metrics.memory.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
memtotal: {
|
|
label: 'label.metrics.memory.total'
|
|
},
|
|
memusedavg: {
|
|
label: 'label.metrics.memory.used.avg',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'memnotificationthreshold',
|
|
disable: 'memdisablethreshold'
|
|
}
|
|
},
|
|
memallocated: {
|
|
label: 'label.metrics.allocated',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'memallocatednotificationthreshold',
|
|
disable: 'memallocateddisablethreshold'
|
|
}
|
|
}
|
|
}
|
|
},
|
|
network: {
|
|
label: 'label.metrics.network.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
networkread: {
|
|
label: 'label.metrics.network.read'
|
|
},
|
|
networkwrite: {
|
|
label: 'label.metrics.network.write'
|
|
}
|
|
}
|
|
}
|
|
},
|
|
dataProvider: function(args) {
|
|
var data = {};
|
|
data.type = 'routing';
|
|
listViewDataProvider(args, data);
|
|
|
|
if (!args.context.instances) {
|
|
if ("zones" in args.context && args.context.zones[0]) {
|
|
data['zoneid'] = args.context.zones[0].id;
|
|
}
|
|
|
|
if ("pods" in args.context && args.context.pods[0]) {
|
|
data['podid'] = args.context.pods[0].id;
|
|
}
|
|
|
|
if ("clusters" in args.context && args.context.clusters[0]) {
|
|
data['clusterid'] = args.context.clusters[0].id;
|
|
}
|
|
} else {
|
|
if (args.context.instances[0]) {
|
|
data['id'] = args.context.instances[0].hostid;
|
|
}
|
|
}
|
|
|
|
if (args.context.metricsFilterData && args.context.metricsFilterData.key && args.context.metricsFilterData.value) {
|
|
data[args.context.metricsFilterData.key] = args.context.metricsFilterData.value;
|
|
}
|
|
|
|
$.ajax({
|
|
url: createURL('listHosts'),
|
|
data: data,
|
|
success: function(json) {
|
|
var items = json.listhostsresponse.host;
|
|
if (items) {
|
|
$.each(items, function(idx, host) {
|
|
if (host && host.outofbandmanagement) {
|
|
items[idx].outofbandmanagementpowerstate = host.outofbandmanagement.powerstate;
|
|
}
|
|
items[idx].cores = host.cpunumber;
|
|
items[idx].cputotal = (parseFloat(host.cpunumber) * parseFloat(host.cpuspeed) / 1000.0).toFixed(2);
|
|
if (host.cpuused) {
|
|
items[idx].cpuusedavg = (parseFloat(host.cpuused) * items[idx].cputotal / 100.0).toFixed(2) + ' Ghz';
|
|
} else {
|
|
items[idx].cpuusedavg = '';
|
|
}
|
|
items[idx].cpuallocated = (parseFloat(host.cpuallocated) * items[idx].cputotal / 100.0).toFixed(2) + ' Ghz';
|
|
items[idx].memtotal = (parseFloat(host.memorytotal)/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
|
|
items[idx].memallocated = (parseFloat(host.memoryallocated)/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
|
|
if (host.memoryused) {
|
|
items[idx].memusedavg = (parseFloat(host.memoryused)/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
|
|
} else {
|
|
items[idx].memusedavg = '';
|
|
}
|
|
if (host.networkkbsread && host.networkkbswrite) {
|
|
items[idx].networkread = (parseFloat(host.networkkbsread)/(1024.0*1024.0)).toFixed(2) + ' GB';
|
|
items[idx].networkwrite = (parseFloat(host.networkkbswrite)/(1024.0*1024.0)).toFixed(2) + ' GB';
|
|
} else {
|
|
items[idx].networkread = '';
|
|
items[idx].networkwrite = '';
|
|
}
|
|
|
|
var cpuOverCommit = 1.0;
|
|
var memOverCommit = 1.0;
|
|
$.ajax({
|
|
url: createURL('listClusters'),
|
|
data: {clusterid: host.clusterid, listAll: true},
|
|
success: function(json) {
|
|
if (json.listclustersresponse && json.listclustersresponse.cluster) {
|
|
var cluster = json.listclustersresponse.cluster[0];
|
|
cpuOverCommit = parseFloat(cluster.cpuovercommitratio);
|
|
memOverCommit = parseFloat(cluster.memoryovercommitratio);
|
|
}
|
|
},
|
|
async: false
|
|
});
|
|
|
|
// Threshold color coding
|
|
items[idx].cpunotificationthreshold = 0.75 * parseFloat(items[idx].cputotal);
|
|
items[idx].cpudisablethreshold = 0.95 * parseFloat(items[idx].cputotal);
|
|
items[idx].cpuallocatednotificationthreshold = 0.75 * cpuOverCommit * parseFloat(items[idx].cputotal);
|
|
items[idx].cpuallocateddisablethreshold = 0.95 * cpuOverCommit * parseFloat(items[idx].cputotal);
|
|
|
|
items[idx].memnotificationthreshold = 0.75 * parseFloat(items[idx].memtotal);
|
|
items[idx].memdisablethreshold = 0.95 * parseFloat(items[idx].memtotal);
|
|
items[idx].memallocatednotificationthreshold = 0.75 * memOverCommit * parseFloat(items[idx].memtotal);
|
|
items[idx].memallocateddisablethreshold = 0.95 * memOverCommit * parseFloat(items[idx].memtotal);
|
|
|
|
$.ajax({
|
|
url: createURL('listConfigurations'),
|
|
data: {clusterid: host.clusterid, listAll: true},
|
|
success: function(json) {
|
|
if (json.listconfigurationsresponse && json.listconfigurationsresponse.configuration) {
|
|
$.each(json.listconfigurationsresponse.configuration, function(i, config) {
|
|
switch (config.name) {
|
|
case 'cluster.cpu.allocated.capacity.disablethreshold':
|
|
items[idx].cpudisablethreshold = parseFloat(config.value) * parseFloat(items[idx].cputotal);
|
|
items[idx].cpuallocateddisablethreshold = parseFloat(config.value) * cpuOverCommit * parseFloat(items[idx].cputotal);
|
|
break;
|
|
case 'cluster.cpu.allocated.capacity.notificationthreshold':
|
|
items[idx].cpunotificationthreshold = parseFloat(config.value) * parseFloat(items[idx].cputotal);
|
|
items[idx].cpuallocatednotificationthreshold = parseFloat(config.value) * cpuOverCommit * parseFloat(items[idx].cputotal);
|
|
break;
|
|
case 'cluster.memory.allocated.capacity.disablethreshold':
|
|
items[idx].memdisablethreshold = parseFloat(config.value) * parseFloat(items[idx].memtotal);
|
|
items[idx].memallocateddisablethreshold = parseFloat(config.value) * memOverCommit * parseFloat(items[idx].memtotal);
|
|
break;
|
|
case 'cluster.memory.allocated.capacity.notificationthreshold':
|
|
items[idx].memnotificationthreshold = parseFloat(config.value) * parseFloat(items[idx].memtotal);
|
|
items[idx].memallocatednotificationthreshold = parseFloat(config.value) * memOverCommit * parseFloat(items[idx].memtotal);
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
},
|
|
async: false
|
|
});
|
|
|
|
|
|
items[idx].cputotal = items[idx].cputotal + ' Ghz (x' + cpuOverCommit + ')';
|
|
items[idx].memtotal = items[idx].memtotal + ' (x' + memOverCommit + ')';
|
|
|
|
items[idx].instances = 0;
|
|
items[idx].instancesUp = 0;
|
|
$.ajax({
|
|
url: createURL('listVirtualMachines'),
|
|
data: {hostid: host.id, listAll: true},
|
|
success: function(json) {
|
|
if (json && json.listvirtualmachinesresponse && json.listvirtualmachinesresponse.virtualmachine) {
|
|
var vms = json.listvirtualmachinesresponse.virtualmachine;
|
|
if (vms) {
|
|
$.each(vms, function(_, vm) {
|
|
items[idx].instances += 1;
|
|
if (vm.state == 'Running') {
|
|
items[idx].instancesUp += 1;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
},
|
|
async: false
|
|
});
|
|
items[idx].instances = items[idx].instancesUp + ' / ' + items[idx].instances;
|
|
});
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
},
|
|
browseBy: {
|
|
filterBy: 'hostid',
|
|
resource: 'vms'
|
|
},
|
|
detailView: cloudStack.sections.system.subsections.hosts.listView.detailView
|
|
}
|
|
};
|
|
|
|
|
|
// VMs Metrics
|
|
cloudStack.sections.metrics.instances = {
|
|
title: 'label.metrics',
|
|
listView: {
|
|
id: 'instances',
|
|
fields: {
|
|
name: {
|
|
label: 'label.metrics.name'
|
|
},
|
|
state: {
|
|
label: 'label.metrics.state',
|
|
converter: function (str) {
|
|
// For localization
|
|
return str;
|
|
},
|
|
indicator: {
|
|
'Running': 'on',
|
|
'Stopped': 'off',
|
|
'Error': 'off',
|
|
'Destroyed': 'off',
|
|
'Expunging': 'off',
|
|
'Stopping': 'transition',
|
|
'Starting': 'transition',
|
|
'Migrating': 'transition',
|
|
'Shutdowned': 'warning'
|
|
},
|
|
compact: true
|
|
},
|
|
ipaddress: {
|
|
label: 'label.ip.address'
|
|
},
|
|
zonename: {
|
|
label: 'label.zone'
|
|
},
|
|
cpuused: {
|
|
label: 'label.metrics.cpu.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
cores: {
|
|
label: 'label.metrics.num.cpu.cores'
|
|
},
|
|
cputotal: {
|
|
label: 'label.metrics.cpu.total'
|
|
},
|
|
cpuused: {
|
|
label: 'label.metrics.cpu.used.avg'
|
|
}
|
|
}
|
|
},
|
|
memused: {
|
|
label: 'label.metrics.memory.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
memallocated: {
|
|
label: 'label.metrics.allocated'
|
|
}
|
|
}
|
|
},
|
|
network: {
|
|
label: 'label.metrics.network.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
networkread: {
|
|
label: 'label.metrics.network.read'
|
|
},
|
|
networkwrite: {
|
|
label: 'label.metrics.network.write'
|
|
}
|
|
}
|
|
},
|
|
disk: {
|
|
label: 'label.metrics.disk.usage',
|
|
collapsible: true,
|
|
columns: {
|
|
diskread: {
|
|
label: 'label.metrics.disk.read'
|
|
},
|
|
diskwrite: {
|
|
label: 'label.metrics.disk.write'
|
|
},
|
|
diskiopstotal: {
|
|
label: 'label.metrics.disk.iops.total'
|
|
}
|
|
}
|
|
}
|
|
},
|
|
dataProvider: function(args) {
|
|
var data = {};
|
|
listViewDataProvider(args, data);
|
|
|
|
if ("hosts" in args.context && args.context.hosts[0]) {
|
|
data['hostid'] = args.context.hosts[0].id;
|
|
}
|
|
|
|
if (args.context.metricsFilterData && args.context.metricsFilterData.key && args.context.metricsFilterData.value) {
|
|
data[args.context.metricsFilterData.key] = args.context.metricsFilterData.value;
|
|
}
|
|
|
|
$.ajax({
|
|
url: createURL('listVirtualMachines'),
|
|
data: data,
|
|
success: function(json) {
|
|
var items = [];
|
|
if (json && json.listvirtualmachinesresponse && json.listvirtualmachinesresponse.virtualmachine) {
|
|
items = json.listvirtualmachinesresponse.virtualmachine;
|
|
$.each(items, function(idx, vm) {
|
|
items[idx].cores = vm.cpunumber;
|
|
items[idx].cputotal = (parseFloat(vm.cpunumber) * parseFloat(vm.cpuspeed) / 1000.0).toFixed(1) + ' Ghz';
|
|
items[idx].cpuusedavg = vm.cpuused;
|
|
items[idx].cpuallocated = vm.cpuallocated;
|
|
items[idx].memallocated = (parseFloat(vm.memory)/1024.0).toFixed(2) + ' GB';
|
|
items[idx].networkread = (parseFloat(vm.networkkbsread)/(1024.0)).toFixed(2) + ' MB';
|
|
items[idx].networkwrite = (parseFloat(vm.networkkbswrite)/(1024.0)).toFixed(2) + ' MB';
|
|
items[idx].diskread = (parseFloat(vm.diskkbsread)/(1024.0)).toFixed(2) + ' MB';
|
|
items[idx].diskwrite = (parseFloat(vm.diskkbswrite)/(1024.0)).toFixed(2) + ' MB';
|
|
items[idx].diskiopstotal = parseFloat(vm.diskioread) + parseFloat(vm.diskiowrite);
|
|
if (vm.nic && vm.nic.length > 0 && vm.nic[0].ipaddress) {
|
|
items[idx].ipaddress = vm.nic[0].ipaddress;
|
|
}
|
|
|
|
var keys = [{'cpuused': 'cpuusedavg'},
|
|
{'networkkbsread': 'networkread'},
|
|
{'networkkbswrite': 'networkwrite'},
|
|
{'diskkbsread': 'diskread'},
|
|
{'diskkbswrite': 'diskwrite'},
|
|
{'diskioread': 'diskiopstotal'}];
|
|
for (keyIdx in keys) {
|
|
var map = keys[keyIdx];
|
|
var key = Object.keys(map)[0];
|
|
var uiKey = map[key];
|
|
if (!vm.hasOwnProperty(key)) {
|
|
items[idx][uiKey] = '';
|
|
}
|
|
}
|
|
});
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
},
|
|
browseBy: {
|
|
filterBy: 'virtualmachineid',
|
|
resource: 'volumes'
|
|
},
|
|
detailView: cloudStack.sections.instances.listView.detailView
|
|
}
|
|
};
|
|
|
|
|
|
// Volumes Metrics
|
|
cloudStack.sections.metrics.volumes = {
|
|
title: 'label.metrics',
|
|
listView: {
|
|
id: 'volumes',
|
|
fields: {
|
|
name: {
|
|
label: 'label.metrics.name'
|
|
},
|
|
state: {
|
|
label: 'label.metrics.state',
|
|
converter: function (str) {
|
|
// For localization
|
|
return str;
|
|
},
|
|
indicator: {
|
|
'Allocated': 'transition',
|
|
'Creating': 'transition',
|
|
'Ready': 'on',
|
|
'Destroy': 'off',
|
|
'Expunging': 'off',
|
|
'Migrating': 'warning',
|
|
'UploadOp': 'transition',
|
|
'Snapshotting': 'warning'
|
|
},
|
|
compact: true
|
|
},
|
|
vmname: {
|
|
label: 'label.metrics.vm.name'
|
|
},
|
|
disksize: {
|
|
label: 'label.metrics.disk.size'
|
|
},
|
|
storagetype: {
|
|
label: 'label.metrics.disk.storagetype'
|
|
},
|
|
storagepool: {
|
|
label: 'label.metrics.storagepool'
|
|
}
|
|
},
|
|
dataProvider: function(args) {
|
|
var data = {listAll: true};
|
|
listViewDataProvider(args, data);
|
|
|
|
if ("instances" in args.context && args.context.instances[0]) {
|
|
data['virtualmachineid'] = args.context.instances[0].id;
|
|
}
|
|
|
|
if ("primarystorages" in args.context && args.context.primarystorages[0]) {
|
|
data['storageid'] = args.context.primarystorages[0].id;
|
|
}
|
|
|
|
if (args.context.metricsFilterData && args.context.metricsFilterData.key && args.context.metricsFilterData.value) {
|
|
data[args.context.metricsFilterData.key] = args.context.metricsFilterData.value;
|
|
}
|
|
|
|
$.ajax({
|
|
url: createURL('listVolumes'),
|
|
data: data,
|
|
success: function(json) {
|
|
var items = [];
|
|
if (json && json.listvolumesresponse && json.listvolumesresponse.volume) {
|
|
items = json.listvolumesresponse.volume;
|
|
$.each(items, function(idx, volume) {
|
|
items[idx].name = volume.name;
|
|
items[idx].state = volume.state;
|
|
items[idx].vmname = volume.vmname;
|
|
items[idx].disksize = parseFloat(volume.size)/(1024.0*1024.0*1024.0) + ' GB';
|
|
items[idx].storagetype = volume.storagetype.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();}) + ' (' + volume.type + ')';
|
|
if (volume.storage) {
|
|
items[idx].storagepool = volume.storage;
|
|
}
|
|
});
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
},
|
|
detailView: cloudStack.sections.storage.sections.volumes.listView.detailView
|
|
}
|
|
};
|
|
|
|
|
|
// Storage Pool Metrics
|
|
cloudStack.sections.metrics.storagepool = {
|
|
title: 'label.metrics',
|
|
listView: {
|
|
id: 'primarystorages',
|
|
fields: {
|
|
name: {
|
|
label: 'label.metrics.name'
|
|
},
|
|
property: {
|
|
label: 'label.metrics.property',
|
|
collapsible: true,
|
|
columns: {
|
|
state: {
|
|
label: 'label.metrics.state',
|
|
converter: function (str) {
|
|
// For localization
|
|
return str;
|
|
},
|
|
indicator: {
|
|
'Up': 'on',
|
|
'Down': 'off',
|
|
'Removed': 'off',
|
|
'ErrorInMaintenance': 'off',
|
|
'PrepareForMaintenance': 'transition',
|
|
'CancelMaintenance': 'warning',
|
|
'Maintenance': 'warning'
|
|
},
|
|
compact: true
|
|
},
|
|
scope: {
|
|
label: 'label.metrics.scope'
|
|
},
|
|
type: {
|
|
label: 'label.metrics.disk.storagetype'
|
|
}
|
|
}
|
|
},
|
|
disk: {
|
|
label: 'label.metrics.disk',
|
|
collapsible: true,
|
|
columns: {
|
|
disksizeused: {
|
|
label: 'label.metrics.disk.used',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'storagenotificationthreshold',
|
|
disable: 'storagedisablethreshold'
|
|
}
|
|
},
|
|
disksizetotal: {
|
|
label: 'label.metrics.disk.total'
|
|
},
|
|
disksizeallocated: {
|
|
label: 'label.metrics.disk.allocated',
|
|
thresholdcolor: true,
|
|
thresholds: {
|
|
notification: 'storageallocatednotificationthreshold',
|
|
disable: 'storageallocateddisablethreshold'
|
|
}
|
|
},
|
|
disksizeunallocated: {
|
|
label: 'label.metrics.disk.unallocated'
|
|
}
|
|
}
|
|
}
|
|
},
|
|
dataProvider: function(args) {
|
|
var data = {};
|
|
listViewDataProvider(args, data);
|
|
|
|
if ("zones" in args.context && args.context.zones[0]) {
|
|
data['zoneid'] = args.context.zones[0].id;
|
|
}
|
|
|
|
if ("pods" in args.context && args.context.pods[0]) {
|
|
data['podid'] = args.context.pods[0].id;
|
|
}
|
|
|
|
if ("clusters" in args.context && args.context.clusters[0]) {
|
|
data['clusterid'] = args.context.clusters[0].id;
|
|
}
|
|
|
|
if (args.context.metricsFilterData && args.context.metricsFilterData.key && args.context.metricsFilterData.value) {
|
|
data[args.context.metricsFilterData.key] = args.context.metricsFilterData.value;
|
|
}
|
|
|
|
$.ajax({
|
|
url: createURL('listStoragePools'),
|
|
data: data,
|
|
success: function(json) {
|
|
var items = [];
|
|
if (json && json.liststoragepoolsresponse && json.liststoragepoolsresponse.storagepool) {
|
|
items = json.liststoragepoolsresponse.storagepool;
|
|
$.each(items, function(idx, pool) {
|
|
items[idx].name = pool.name;
|
|
items[idx].state = pool.state;
|
|
items[idx].scope = pool.scope;
|
|
items[idx].type = pool.type;
|
|
items[idx].overprovisionfactor = parseFloat(pool.overprovisionfactor);
|
|
if (pool.disksizeused) {
|
|
items[idx].disksizeused = (parseFloat(pool.disksizeused)/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
|
|
} else {
|
|
items[idx].disksizeused = '';
|
|
}
|
|
items[idx].disksizetotal = parseFloat(pool.disksizetotal);
|
|
items[idx].disksizeallocated = parseFloat(pool.disksizeallocated);
|
|
items[idx].disksizeunallocated = (items[idx].overprovisionfactor * items[idx].disksizetotal) - items[idx].disksizeallocated;
|
|
|
|
// Format presentation
|
|
items[idx].disksizetotal = (items[idx].disksizetotal/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB (x' + items[idx].overprovisionfactor + ')';
|
|
items[idx].disksizeallocated = (items[idx].disksizeallocated/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
|
|
items[idx].disksizeunallocated = (items[idx].disksizeunallocated/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
|
|
|
|
// Threshold color coding
|
|
items[idx].storagenotificationthreshold = 0.75 * parseFloat(items[idx].disksizetotal);
|
|
items[idx].storagedisablethreshold = 0.95 * parseFloat(items[idx].disksizetotal);
|
|
items[idx].storageallocatednotificationthreshold = 0.75 * parseFloat(items[idx].disksizetotal) * items[idx].overprovisionfactor;
|
|
items[idx].storageallocateddisablethreshold = 0.95 * parseFloat(items[idx].disksizetotal) * items[idx].overprovisionfactor;
|
|
|
|
|
|
var getThresholds = function(data, items, idx) {
|
|
data.listAll = true;
|
|
$.ajax({
|
|
url: createURL('listConfigurations'),
|
|
data: data,
|
|
success: function(json) {
|
|
if (json.listconfigurationsresponse && json.listconfigurationsresponse.configuration) {
|
|
$.each(json.listconfigurationsresponse.configuration, function(i, config) {
|
|
switch (config.name) {
|
|
case 'cluster.storage.allocated.capacity.notificationthreshold':
|
|
items[idx].storageallocatednotificationthreshold = parseFloat(config.value) * items[idx].overprovisionfactor * parseFloat(items[idx].disksizetotal);
|
|
break;
|
|
case 'cluster.storage.capacity.notificationthreshold':
|
|
items[idx].storagenotificationthreshold = parseFloat(config.value) * parseFloat(items[idx].disksizetotal);
|
|
break;
|
|
case 'pool.storage.allocated.capacity.disablethreshold':
|
|
items[idx].storageallocateddisablethreshold = parseFloat(config.value) * items[idx].overprovisionfactor * parseFloat(items[idx].disksizetotal);
|
|
break;
|
|
case 'pool.storage.capacity.disablethreshold':
|
|
items[idx].storagedisablethreshold = parseFloat(config.value) * parseFloat(items[idx].disksizetotal);
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
},
|
|
async: false
|
|
});
|
|
};
|
|
// Update global and cluster level thresholds
|
|
getThresholds({}, items, idx);
|
|
getThresholds({clusterid: pool.clusterid}, items, idx);
|
|
});
|
|
}
|
|
args.response.success({
|
|
data: items
|
|
});
|
|
}
|
|
});
|
|
},
|
|
browseBy: {
|
|
filterBy: 'storageid',
|
|
resource: 'volumes'
|
|
},
|
|
detailView: cloudStack.sections.system.subsections['primary-storage'].listView.detailView
|
|
}
|
|
};
|
|
|
|
})(cloudStack);
|