| // 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}, |
| 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++; |
| } |
| $.ajax({ |
| url: createURL('listHosts'), |
| data: {clusterid: cluster.id, type: 'routing'}, |
| 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 (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'}, |
| 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 |
| }, |
| 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: 'cpunotificationthreshold', |
| disable: 'cpudisablethreshold' |
| } |
| } |
| } |
| }, |
| 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: 'memnotificationthreshold', |
| disable: 'memdisablethreshold' |
| } |
| } |
| } |
| }, |
| 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.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) { |
| 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 = '--'; |
| } |
| |
| // Threshold color coding |
| items[idx].cpunotificationthreshold = 0.75 * parseFloat(items[idx].cputotal); |
| items[idx].cpudisablethreshold = 0.95 * parseFloat(items[idx].cputotal); |
| items[idx].memnotificationthreshold = 0.75 * parseFloat(items[idx].memtotal); |
| items[idx].memdisablethreshold = 0.95 * 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); |
| break; |
| case 'cluster.cpu.allocated.capacity.notificationthreshold': |
| items[idx].cpunotificationthreshold = parseFloat(config.value) * parseFloat(items[idx].cputotal); |
| break; |
| case 'cluster.memory.allocated.capacity.disablethreshold': |
| items[idx].memdisablethreshold = parseFloat(config.value) * parseFloat(items[idx].memtotal); |
| break; |
| case 'cluster.memory.allocated.capacity.notificationthreshold': |
| items[idx].memnotificationthreshold = parseFloat(config.value) * parseFloat(items[idx].memtotal); |
| break; |
| } |
| }); |
| } |
| }, |
| async: false |
| }); |
| |
| 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 = cluster.cpuovercommitratio; |
| memOverCommit = cluster.memoryovercommitratio; |
| } |
| }, |
| async: false |
| }); |
| |
| items[idx].cputotal = items[idx].cputotal + ' Ghz (x' + cpuOverCommit + ')'; |
| items[idx].memtotal = items[idx].memtotal + ' (x' + memOverCommit + ')'; |
| }); |
| } |
| 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 |
| }, |
| 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' |
| }, |
| memused: { |
| label: 'label.metrics.memory.used.avg' |
| } |
| } |
| }, |
| 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 (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)).toFixed(0) + ' Mhz'; |
| items[idx].cpuusedavg = vm.cpuused; |
| items[idx].cpuallocated = vm.cpuallocated; |
| items[idx].memallocated = (parseFloat(vm.memory)/1024.0).toFixed(2) + ' GB'; |
| items[idx].memused = (parseFloat(vm.memoryused)/(1024.0*1024.0*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); |
| |
| var keys = [{'cpuused': 'cpuusedavg'}, |
| {'memoryused': 'memused'}, |
| {'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' |
| }, |
| diskoffering: { |
| label: 'label.metrics.disk.offering' |
| }, |
| 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 (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].diskoffering = volume.diskofferingname; |
| if (volume.type == 'ROOT') { |
| items[idx].diskoffering = volume.serviceofferingname; |
| } |
| 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 |
| }); |
| } |
| }); |
| }, |
| browseBy: { |
| filterKey: 'storageid', |
| filterBy: 'id', |
| resource: 'storagepool' |
| }, |
| 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 (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].storageallocateddisablethreshold = 0.95 * parseFloat(items[idx].disksizetotal); |
| |
| |
| 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) * 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) * 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); |
