| # 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 |