mirror of
https://github.com/apache/cloudstack.git
synced 2025-11-04 00:02:37 +01:00
573 lines
26 KiB
Python
573 lines
26 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
|
|
from marvin.lib.decoratorGenerators import skipTestIf
|
|
|
|
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.mgtSvrDetails = cls.config.__dict__["mgtSvr"][0].__dict__
|
|
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._cleanup.append(cls.service_offering)
|
|
cls.template = get_test_template(
|
|
cls.apiclient,
|
|
cls.zone.id,
|
|
cls.hypervisor
|
|
)
|
|
cls.domain = get_domain(cls.apiclient)
|
|
cls.account = Account.create(
|
|
cls.apiclient,
|
|
cls.services["account"],
|
|
admin=False,
|
|
domainid=cls.domain.id
|
|
)
|
|
cls._cleanup.append(cls.account)
|
|
cls.hypervisorNotSupported = True
|
|
if cls.hypervisor.lower() != 'simulator':
|
|
cls.hypervisorNotSupported = False
|
|
cls.vm_stats_interval_cfg = Configurations.list(cls.apiclient, name='vm.stats.interval')[0].value
|
|
cls.vm_stats_max_retention_time_cfg = Configurations.list(cls.apiclient, name='vm.stats.max.retention.time')[0].value
|
|
cls.vm_stats_user_vm_only_cfg = Configurations.list(cls.apiclient, name='vm.stats.user.vm.only')[0].value
|
|
cls.vm_disk_stats_interval_cfg = Configurations.list(cls.apiclient, name='vm.disk.stats.interval')[0].value
|
|
cls.vm_disk_stats_interval_min_cfg = Configurations.list(cls.apiclient, name='vm.disk.stats.interval.min')[0].value
|
|
cls.vm_disk_stats_max_retention_time_cfg = Configurations.list(cls.apiclient, name='vm.disk.stats.max.retention.time')[0].value
|
|
cls.vm_disk_stats_retention_enabled_cfg = Configurations.list(cls.apiclient, name='vm.disk.stats.retention.enabled')[0].value
|
|
Configurations.update(cls.apiclient, 'vm.stats.interval', value='60000')
|
|
Configurations.update(cls.apiclient, 'vm.stats.max.retention.time', value='7200')
|
|
Configurations.update(cls.apiclient, 'vm.stats.user.vm.only', value='false')
|
|
Configurations.update(cls.apiclient, 'vm.disk.stats.interval', value='60')
|
|
Configurations.update(cls.apiclient, 'vm.disk.stats.interval.min', value='60')
|
|
Configurations.update(cls.apiclient, 'vm.disk.stats.max.retention.time', value='7200')
|
|
Configurations.update(cls.apiclient, 'vm.disk.stats.retention.enabled', value='true')
|
|
cls.restartServer()
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
if cls.hypervisor.lower() != 'simulator':
|
|
cls.updateConfiguration('vm.stats.interval', cls.vm_stats_interval_cfg)
|
|
cls.updateConfiguration('vm.stats.max.retention.time', cls.vm_stats_max_retention_time_cfg)
|
|
cls.updateConfiguration('vm.stats.user.vm.only', cls.vm_stats_user_vm_only_cfg)
|
|
cls.updateConfiguration('vm.disk.stats.interval', cls.vm_disk_stats_interval_cfg)
|
|
cls.updateConfiguration('vm.disk.stats.interval.min', cls.vm_disk_stats_interval_min_cfg)
|
|
cls.updateConfiguration('vm.disk.stats.max.retention.time', cls.vm_disk_stats_max_retention_time_cfg)
|
|
cls.updateConfiguration('vm.disk.stats.retention.enabled', cls.vm_disk_stats_retention_enabled_cfg)
|
|
cls.restartServer()
|
|
super(TestMetrics, cls).tearDownClass()
|
|
|
|
@classmethod
|
|
def restartServer(cls):
|
|
"""Restart management server"""
|
|
|
|
cls.debug("Restarting management server")
|
|
sshClient = SshClient(
|
|
cls.mgtSvrDetails["mgtSvrIp"],
|
|
22,
|
|
cls.mgtSvrDetails["user"],
|
|
cls.mgtSvrDetails["passwd"]
|
|
)
|
|
command = "service cloudstack-management stop"
|
|
sshClient.execute(command)
|
|
|
|
command = "service cloudstack-management start"
|
|
sshClient.execute(command)
|
|
|
|
#Waits for management to come up in 5 mins, when it's up it will continue
|
|
timeout = time.time() + 300
|
|
while time.time() < timeout:
|
|
if cls.isManagementUp() is True:
|
|
# allow hosts to be ready for deployment
|
|
time.sleep(30)
|
|
return
|
|
time.sleep(5)
|
|
cls.setup_failed = True
|
|
cls.debug("Management server did not come up, failing")
|
|
return
|
|
|
|
@classmethod
|
|
def isManagementUp(cls):
|
|
try:
|
|
cls.apiclient.listInfrastructure(listInfrastructure.listInfrastructureCmd())
|
|
return True
|
|
except Exception:
|
|
return False
|
|
|
|
@classmethod
|
|
def updateConfiguration(cls, config, value):
|
|
if value is not None:
|
|
Configurations.update(cls.apiclient, config, value=value)
|
|
|
|
def setUp(self):
|
|
self.userapiclient = self.testClient.getUserApiClient(
|
|
UserName=self.account.name,
|
|
DomainName=self.account.domain
|
|
)
|
|
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
|
|
|
|
def run_list_vm_metrics_test(self, is_user):
|
|
apiclient = self.apiclient
|
|
if is_user:
|
|
apiclient = self.userapiclient
|
|
self.small_virtual_machine = VirtualMachine.create(
|
|
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 = 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'))
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_vms_metrics_admin(self):
|
|
self.run_list_vm_metrics_test(False)
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
def test_list_vms_metrics_user(self):
|
|
self.run_list_vm_metrics_test(True)
|
|
|
|
@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,
|
|
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
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
|
|
@skipTestIf("hypervisorNotSupported")
|
|
def test_list_vms_metrics_history(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)
|
|
|
|
# Wait for 2 minutes
|
|
time.sleep(120)
|
|
|
|
cmd = listVirtualMachinesUsageHistory.listVirtualMachinesUsageHistoryCmd()
|
|
cmd.id = self.small_virtual_machine.id
|
|
|
|
result = self.apiclient.listVirtualMachinesUsageHistory(cmd)[0]
|
|
|
|
self.assertEqual(result.id, self.small_virtual_machine.id)
|
|
self.assertTrue(hasattr(result, 'stats'))
|
|
self.assertTrue(type(result.stats) == list and len(result.stats) > 0)
|
|
self.validate_vm_stats(result.stats[0])
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
|
|
@skipTestIf("hypervisorNotSupported")
|
|
def test_list_system_vms_metrics_history(self):
|
|
cmd = listSystemVmsUsageHistory.listSystemVmsUsageHistoryCmd()
|
|
now = datetime.datetime.now() - datetime.timedelta(minutes=15)
|
|
start_time = now.strftime("%Y-%m-%d %H:%M:%S")
|
|
cmd.startdate = start_time
|
|
|
|
result = self.apiclient.listSystemVmsUsageHistory(cmd)[0]
|
|
|
|
self.assertTrue(hasattr(result, 'stats'))
|
|
self.assertTrue(type(result.stats) == list and len(result.stats) > 0)
|
|
self.validate_vm_stats(result.stats[0])
|
|
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
|
|
@skipTestIf("hypervisorNotSupported")
|
|
def test_list_volumes_metrics_history(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)
|
|
|
|
currentHost = Host.list(self.apiclient, id=self.small_virtual_machine.hostid)[0]
|
|
if currentHost.hypervisor.lower() == "xenserver":
|
|
# Skip tests as volume metrics doesn't see to work
|
|
self.skipTest("Skipping test because volume metrics doesn't work on hypervisor\
|
|
%s, %s" % (currentHost.hypervisor, currentHost.hypervisorversion))
|
|
|
|
# Wait for 2 minutes
|
|
time.sleep(120)
|
|
|
|
volume = Volume.list(
|
|
self.apiclient,
|
|
virtualmachineid=self.small_virtual_machine.id)[0]
|
|
|
|
cmd = listVolumesUsageHistory.listVolumesUsageHistoryCmd()
|
|
cmd.id = volume.id
|
|
|
|
result = self.apiclient.listVolumesUsageHistory(cmd)[0]
|
|
self.assertEqual(result.id, volume.id)
|
|
self.assertTrue(hasattr(result, 'stats'))
|
|
self.assertTrue(type(result.stats) == list and len(result.stats) > 0)
|
|
stats = result.stats[0]
|
|
self.assertTrue(hasattr(stats, 'diskioread'))
|
|
self.assertTrue(hasattr(stats, 'diskiowrite'))
|
|
self.assertTrue(hasattr(stats, 'diskiopstotal'))
|
|
self.assertTrue(hasattr(stats, 'diskkbsread'))
|
|
self.assertTrue(hasattr(stats, 'diskkbswrite'))
|
|
self.assertTrue(hasattr(stats, 'timestamp'))
|
|
self.assertTrue(self.valid_date(stats.timestamp))
|
|
|
|
return
|
|
|
|
def validate_vm_stats(self, stats):
|
|
self.assertTrue(hasattr(stats, 'cpuused'))
|
|
self.assertTrue(hasattr(stats, 'diskiopstotal'))
|
|
self.assertTrue(hasattr(stats, 'diskioread'))
|
|
self.assertTrue(hasattr(stats, 'diskiowrite'))
|
|
self.assertTrue(hasattr(stats, 'diskkbsread'))
|
|
self.assertTrue(hasattr(stats, 'diskkbswrite'))
|
|
self.assertTrue(hasattr(stats, 'memoryintfreekbs'))
|
|
self.assertTrue(hasattr(stats, 'memorykbs'))
|
|
self.assertTrue(hasattr(stats, 'memorytargetkbs'))
|
|
self.assertTrue(hasattr(stats, 'networkkbsread'))
|
|
self.assertTrue(hasattr(stats, 'networkkbswrite'))
|
|
self.assertTrue(hasattr(stats, 'networkread'))
|
|
self.assertTrue(hasattr(stats, 'networkwrite'))
|
|
self.assertTrue(hasattr(stats, 'timestamp'))
|
|
self.assertTrue(self.valid_date(stats.timestamp))
|
|
|
|
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
|