mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 01:32:18 +02:00
8e538028b2
Best practice is to have one blank line at the end of Python files. Remove unneeded blank lines from the end of files
379 lines
17 KiB
Python
379 lines
17 KiB
Python
# 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.
|
|
|
|
import marvin
|
|
from marvin.cloudstackTestCase import *
|
|
from marvin.cloudstackAPI import *
|
|
from marvin.lib.utils import *
|
|
from marvin.lib.base import *
|
|
from marvin.lib.common import *
|
|
from marvin.lib.utils import (random_gen)
|
|
from nose.plugins.attrib import attr
|
|
|
|
import time
|
|
|
|
_multiprocess_shared_ = True
|
|
|
|
class TestMetrics(cloudstackTestCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.apiclient = cls.testClient.getApiClient()
|
|
cls.hypervisor = cls.testClient.getHypervisorInfo()
|
|
cls.dbclient = cls.testClient.getDbConnection()
|
|
cls.services = cls.testClient.getParsedTestDataConfig()
|
|
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
|
|
cls.pod = get_pod(cls.apiclient, cls.zone.id)
|
|
cls.host = list_hosts(cls.apiclient,
|
|
zoneid=cls.zone.id,
|
|
type='Routing')[0]
|
|
cls.cluster = cls.apiclient.listClusters(listClusters.listClustersCmd())[0]
|
|
cls._cleanup = []
|
|
cls.disk_offering = DiskOffering.create(
|
|
cls.apiclient,
|
|
cls.services["disk_offering"]
|
|
)
|
|
cls._cleanup.append(cls.disk_offering)
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.apiclient,
|
|
cls.services["service_offering"]
|
|
)
|
|
cls.template = get_test_template(
|
|
cls.apiclient,
|
|
cls.zone.id,
|
|
cls.hypervisor
|
|
)
|
|
cls._cleanup.append(cls.service_offering)
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
super(TestMetrics, cls).tearDownClass()
|
|
|
|
def setUp(self):
|
|
self.cleanup = []
|
|
|
|
def tearDown(self):
|
|
super(TestMetrics, self).tearDown();
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_hosts_metrics(self):
|
|
|
|
cmd = listHostsMetrics.listHostsMetricsCmd()
|
|
cmd.id = self.host.id
|
|
cmd.type = 'Routing'
|
|
|
|
host_metric = self.apiclient.listHostsMetrics(cmd)[0]
|
|
|
|
self.assertEqual(host_metric.cpuallocated, self.host.cpuallocated)
|
|
self.assertEqual(host_metric.memoryallocated, self.host.memoryallocated)
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_clusters_metrics(self):
|
|
|
|
cmd = listClustersMetrics.listClustersMetricsCmd()
|
|
cmd.id = self.cluster.id
|
|
|
|
cluster_metric = self.apiclient.listClustersMetrics(cmd)[0]
|
|
|
|
self.assertEqual(cluster_metric.id, self.cluster.id)
|
|
self.assertTrue(hasattr(cluster_metric, 'cpuallocated'))
|
|
self.assertTrue(hasattr(cluster_metric, 'cpumaxdeviation'))
|
|
self.assertTrue(hasattr(cluster_metric, 'memoryallocated'))
|
|
self.assertTrue(hasattr(cluster_metric, 'memoryused'))
|
|
self.assertTrue(hasattr(cluster_metric, 'memorymaxdeviation'))
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_zones_metrics(self):
|
|
cmd = listZonesMetrics.listZonesMetricsCmd()
|
|
cmd.id = self.zone.id
|
|
|
|
zone_metrics = self.apiclient.listZonesMetrics(cmd)[0]
|
|
|
|
self.assertTrue(hasattr(zone_metrics, 'cpuallocated'))
|
|
self.assertTrue(hasattr(zone_metrics, 'cpumaxdeviation'))
|
|
self.assertTrue(hasattr(zone_metrics, 'cputotal'))
|
|
self.assertTrue(hasattr(zone_metrics, 'cpuused'))
|
|
self.assertTrue(hasattr(zone_metrics, 'memoryallocated'))
|
|
self.assertTrue(hasattr(zone_metrics, 'memorymaxdeviation'))
|
|
self.assertTrue(hasattr(zone_metrics, 'memoryused'))
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_vms_metrics(self):
|
|
#deploy VM
|
|
self.small_virtual_machine = VirtualMachine.create(
|
|
self.apiclient,
|
|
self.services["virtual_machine"],
|
|
serviceofferingid=self.service_offering.id,
|
|
templateid=self.template.id,
|
|
zoneid=self.zone.id
|
|
)
|
|
self.cleanup.append(self.small_virtual_machine)
|
|
|
|
|
|
cmd = listVirtualMachinesMetrics.listVirtualMachinesMetricsCmd()
|
|
cmd.id = self.small_virtual_machine.id
|
|
|
|
lvmm = self.apiclient.listVirtualMachinesMetrics(cmd)[0]
|
|
|
|
self.assertEqual(lvmm.id, self.small_virtual_machine.id)
|
|
|
|
self.assertTrue(hasattr(lvmm, 'cputotal'))
|
|
self.assertTrue(hasattr(lvmm, 'cpuused'))
|
|
self.assertTrue(hasattr(lvmm, 'diskiowrite'))
|
|
self.assertTrue(hasattr(lvmm, 'diskkbswrite'))
|
|
self.assertTrue(hasattr(lvmm, 'networkread'))
|
|
self.assertTrue(hasattr(lvmm, 'networkwrite'))
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_pstorage_metrics(self):
|
|
#list StoragePools
|
|
sp = self.apiclient.listStoragePools(listStoragePools.listStoragePoolsCmd())[0]
|
|
|
|
#list StoragePoolsMetrics
|
|
cmd = listStoragePoolsMetrics.listStoragePoolsMetricsCmd()
|
|
cmd.id = sp.id
|
|
|
|
sp_metrics = self.apiclient.listStoragePoolsMetrics(cmd)[0]
|
|
|
|
self.assertEqual(sp_metrics.disksizeallocated, sp.disksizeallocated)
|
|
self.assertEqual(sp_metrics.state, sp.state)
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_volumes_metrics(self):
|
|
volume = Volume.create(
|
|
self.apiclient,
|
|
self.services['volume'],
|
|
zoneid=self.zone.id,
|
|
diskofferingid=self.disk_offering.id
|
|
)
|
|
self.cleanup.append(volume)
|
|
|
|
cmd = listVolumes.listVolumesCmd()
|
|
cmd.id = volume.id
|
|
|
|
lv = self.apiclient.listVolumes(cmd)[0]
|
|
|
|
cmd = listVolumesMetrics.listVolumesMetricsCmd()
|
|
cmd.id = lv.id
|
|
lvm = self.apiclient.listVolumesMetrics(cmd)[0]
|
|
|
|
self.assertEqual(lv.size, lvm.size)
|
|
self.assertTrue(hasattr(lvm, 'diskBytesReadRate'))
|
|
self.assertTrue(hasattr(lvm, 'diskBytesWriteRate'))
|
|
self.assertTrue(hasattr(lvm, 'diskIopsReadRate'))
|
|
self.assertTrue(hasattr(lvm, 'diskIopsWriteRate'))
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_infrastructure_metrics(self):
|
|
cmd = listInfrastructure.listInfrastructureCmd()
|
|
li = self.apiclient.listInfrastructure(cmd)
|
|
|
|
self.assertTrue(hasattr(li, 'clusters'))
|
|
self.assertEqual(li.clusters, len(self.apiclient.listClusters(listClusters.listClustersCmd())))
|
|
self.assertTrue(hasattr(li, 'hosts'))
|
|
|
|
self.assertEqual(li.hosts, len(list_hosts(self.apiclient,
|
|
zoneid=self.zone.id,
|
|
type='Routing')))
|
|
|
|
self.assertTrue(hasattr(li, 'imagestores'))
|
|
self.assertEqual(li.imagestores, len(self.apiclient.listImageStores(listImageStores.listImageStoresCmd())))
|
|
|
|
self.assertTrue(hasattr(li, 'pods'))
|
|
self.assertEqual(li.pods, len(self.apiclient.listPods(listPods.listPodsCmd())))
|
|
|
|
self.assertTrue(hasattr(li, 'routers'))
|
|
|
|
self.assertTrue(hasattr(li, 'storagepools'))
|
|
self.assertEqual(li.storagepools, len(self.apiclient.listStoragePools(listStoragePools.listStoragePoolsCmd())))
|
|
|
|
self.assertTrue(hasattr(li, 'zones'))
|
|
self.assertEqual(li.zones, len(self.apiclient.listZones(listZones.listZonesCmd())))
|
|
|
|
self.assertTrue(hasattr(li, 'systemvms'))
|
|
self.assertTrue(hasattr(li, 'cpusockets'))
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic", "bla"], required_hardware="false")
|
|
def test_list_management_server_metrics(self):
|
|
cmd = listManagementServersMetrics.listManagementServersMetricsCmd()
|
|
listMSMs = self.apiclient.listManagementServersMetrics(cmd)
|
|
cmd = listManagementServers.listManagementServersCmd()
|
|
listMSs= self.apiclient.listManagementServers(cmd)
|
|
|
|
self.assertEqual(len(listMSMs), len(listMSs))
|
|
|
|
metrics = listMSMs[0]
|
|
self.assertTrue(hasattr(metrics, 'availableprocessors'))
|
|
self.assertTrue(isinstance(metrics.availableprocessors, int))
|
|
self.assertTrue(hasattr(metrics, 'agentcount'))
|
|
self.assertTrue(isinstance(metrics.agentcount, int))
|
|
self.assertTrue(hasattr(metrics, 'sessions'))
|
|
self.assertTrue(isinstance(metrics.sessions, int))
|
|
|
|
self.assertTrue(hasattr(metrics, 'heapmemoryused'))
|
|
self.assertTrue(isinstance(metrics.heapmemoryused, int))
|
|
self.assertTrue(hasattr(metrics, 'heapmemorytotal'))
|
|
self.assertTrue(isinstance(metrics.heapmemorytotal, int))
|
|
self.assertTrue(metrics.heapmemoryused <= metrics.heapmemorytotal)
|
|
|
|
self.assertTrue(hasattr(metrics, 'threadsblockedcount'))
|
|
self.assertTrue(isinstance(metrics.threadsblockedcount, int))
|
|
self.assertTrue(hasattr(metrics, 'threadsdaemoncount'))
|
|
self.assertTrue(isinstance(metrics.threadsdaemoncount, int))
|
|
self.assertTrue(hasattr(metrics, 'threadsrunnablecount'))
|
|
self.assertTrue(isinstance(metrics.threadsrunnablecount, int))
|
|
self.assertTrue(hasattr(metrics, 'threadsteminatedcount'))
|
|
self.assertTrue(isinstance(metrics.threadsteminatedcount, int))
|
|
self.assertTrue(hasattr(metrics, 'threadstotalcount'))
|
|
self.assertTrue(isinstance(metrics.threadstotalcount, int))
|
|
self.assertTrue(hasattr(metrics, 'threadswaitingcount'))
|
|
self.assertTrue(isinstance(metrics.threadswaitingcount, int))
|
|
self.assertTrue(metrics.threadsblockedcount <= metrics.threadstotalcount)
|
|
self.assertTrue(metrics.threadsdaemoncount <= metrics.threadstotalcount)
|
|
self.assertTrue(metrics.threadsrunnablecount <= metrics.threadstotalcount)
|
|
self.assertTrue(metrics.threadsteminatedcount <= metrics.threadstotalcount)
|
|
self.assertTrue(metrics.threadswaitingcount <= metrics.threadstotalcount)
|
|
|
|
self.assertTrue(hasattr(metrics, 'systemmemorytotal'))
|
|
self.assertTrue(isinstance(metrics.systemmemorytotal, str))
|
|
self.assertTrue(hasattr(metrics, 'systemmemoryfree'))
|
|
self.assertTrue(isinstance(metrics.systemmemoryfree, str))
|
|
self.assertTrue(hasattr(metrics, 'systemmemoryvirtualsize'))
|
|
self.assertTrue(isinstance(metrics.systemmemoryvirtualsize, str))
|
|
|
|
self.assertTrue(hasattr(metrics, 'loginfo'))
|
|
self.assertTrue(isinstance(metrics.loginfo, str))
|
|
self.assertTrue(hasattr(metrics, 'systemtotalcpucycles'))
|
|
self.assertTrue(isinstance(metrics.systemtotalcpucycles, float))
|
|
self.assertTrue(hasattr(metrics, 'systemloadaverages'))
|
|
self.assertTrue(isinstance(metrics.systemloadaverages, list))
|
|
self.assertEqual(len(metrics.systemloadaverages), 3)
|
|
self.assertTrue(hasattr(metrics, 'systemcycleusage'))
|
|
self.assertTrue(isinstance(metrics.systemcycleusage, list))
|
|
self.assertEqual(len(metrics.systemcycleusage), 3)
|
|
self.assertTrue(hasattr(metrics, 'dbislocal'))
|
|
self.assertTrue(isinstance(metrics.dbislocal, bool))
|
|
self.assertTrue(hasattr(metrics, 'usageislocal'))
|
|
self.assertTrue(isinstance(metrics.usageislocal, bool))
|
|
self.assertTrue(hasattr(metrics, 'collectiontime'))
|
|
self.assertTrue(isinstance(metrics.collectiontime, str))
|
|
self.assertTrue(self.valid_date(metrics.collectiontime))
|
|
self.assertTrue(hasattr(metrics, 'id'))
|
|
self.assertTrue(isinstance(metrics.id, str))
|
|
self.assertTrue(hasattr(metrics, 'name'))
|
|
self.assertTrue(isinstance(metrics.name, str))
|
|
self.assertTrue(hasattr(metrics, 'state'))
|
|
self.assertEqual(metrics.state, 'Up')
|
|
self.assertTrue(hasattr(metrics, 'version'))
|
|
self.assertTrue(isinstance(metrics.version, str))
|
|
self.assertTrue(hasattr(metrics, 'javadistribution'))
|
|
self.assertTrue(isinstance(metrics.javadistribution, str))
|
|
self.assertTrue(hasattr(metrics, 'javaversion'))
|
|
self.assertTrue(isinstance(metrics.javaversion, str))
|
|
self.assertTrue(hasattr(metrics, 'osdistribution'))
|
|
self.assertTrue(isinstance(metrics.osdistribution, str))
|
|
self.assertTrue(hasattr(metrics, 'lastserverstart'))
|
|
self.assertTrue(isinstance(metrics.lastserverstart, str))
|
|
self.assertTrue(self.valid_date(metrics.lastserverstart))
|
|
if hasattr(metrics, 'lastserverstop') and metrics.lastserverstop:
|
|
self.debug(f"=== lastserverstop {metrics.lastserverstop} ===")
|
|
self.assertTrue(isinstance(metrics.lastserverstop, str))
|
|
self.assertTrue(self.valid_date(metrics.lastserverstop))
|
|
self.assertTrue(hasattr(metrics, 'lastboottime'))
|
|
self.assertTrue(isinstance(metrics.lastboottime, str))
|
|
self.assertTrue(self.valid_date(metrics.lastboottime))
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_usage_server_metrics(self):
|
|
cmd = listUsageServerMetrics.listUsageServerMetricsCmd()
|
|
metrics = self.apiclient.listUsageServerMetrics(cmd)
|
|
|
|
self.assertTrue(hasattr(metrics,'collectiontime'))
|
|
self.assertTrue(isinstance(metrics.collectiontime, str))
|
|
self.assertTrue(self.valid_date(metrics.collectiontime))
|
|
self.assertTrue(hasattr(metrics, 'hostname'))
|
|
self.assertTrue(isinstance(metrics.hostname, str))
|
|
if hasattr(metrics, 'lastheartbeat') and metrics.lastheartbeat :
|
|
self.debug(f"=== lastheartbeat {metrics.lastheartbeat} ===")
|
|
self.assertTrue(isinstance(metrics.lastheartbeat, str))
|
|
self.assertTrue(self.valid_date(metrics.lastheartbeat))
|
|
if hasattr(metrics, 'lastsuccessfuljob') and metrics.lastsuccessfuljob:
|
|
self.debug(f"=== lastsuccessfuljob {metrics.lastsuccessfuljob} ===")
|
|
self.assertTrue(isinstance(metrics.lastsuccessfuljob, str))
|
|
self.assertTrue(self.valid_date(metrics.lastsuccessfuljob))
|
|
self.assertTrue(hasattr(metrics, 'state'))
|
|
self.assertTrue(metrics.state == 'Up' or metrics.state == 'Down')
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_db_metrics(self):
|
|
cmd = listDbMetrics.listDbMetricsCmd()
|
|
metrics = self.apiclient.listDbMetrics(cmd)
|
|
|
|
self.assertTrue(hasattr(metrics,'collectiontime'))
|
|
self.assertTrue(isinstance(metrics.collectiontime, str))
|
|
self.assertTrue(self.valid_date(metrics.collectiontime))
|
|
self.assertTrue(hasattr(metrics, 'connections'))
|
|
self.assertTrue(isinstance(metrics.connections, int))
|
|
|
|
cmd = listConfigurations.listConfigurationsCmd()
|
|
cmd.name = 'database.server.stats.retention'
|
|
configuration = self.apiclient.listConfigurations(cmd)
|
|
retention = int(configuration[0].value)
|
|
self.assertTrue(hasattr(metrics, 'dbloadaverages'))
|
|
self.assertTrue(isinstance(metrics.dbloadaverages, list))
|
|
self.assertTrue(len(metrics.dbloadaverages) <= retention)
|
|
|
|
self.assertTrue(hasattr(metrics, 'hostname'))
|
|
self.assertTrue(isinstance(metrics.hostname, str))
|
|
self.assertTrue(hasattr(metrics, 'queries'))
|
|
self.assertTrue(isinstance(metrics.queries, int))
|
|
self.assertTrue(hasattr(metrics, 'replicas'))
|
|
self.assertTrue(isinstance(metrics.replicas, list))
|
|
self.assertTrue(hasattr(metrics, 'uptime'))
|
|
self.assertTrue(isinstance(metrics.uptime, int))
|
|
self.assertTrue(hasattr(metrics, 'version'))
|
|
self.assertTrue(isinstance(metrics.version, str))
|
|
self.assertTrue(hasattr(metrics, 'versioncomment'))
|
|
self.assertTrue(isinstance(metrics.versioncomment, str))
|
|
|
|
return
|
|
|
|
def valid_date(cls, date_text):
|
|
try:
|
|
datetime.datetime.strptime(date_text, '%Y-%m-%dT%H:%M:%S%z')
|
|
return True
|
|
except ValueError:
|
|
return False
|