def setUpClass(cls):
cls.testClient = super(TestHostsForMigration, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
clusterWithSufficientHosts = None
clusters = Cluster.list(cls.api_client, zoneid=cls.zone.id)
for cluster in clusters:
cls.hosts = Host.list(cls.api_client, clusterid=cluster.id, type="Routing")
if len(cls.hosts) >= 2:
clusterWithSufficientHosts = cluster
break
if clusterWithSufficientHosts is None:
raise unittest.SkipTest("No Cluster with 2 hosts found")
Host.update(cls.api_client, id=cls.hosts[1].id, hosttags="PREMIUM")
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering_with_tag = ServiceOffering.create(
cls.api_client, cls.services["service_offering_with_tag"]
)
cls._cleanup = [cls.service_offering_with_tag]
return
def test_03_reconnect_host(self):
""" Test reconnect Host which has VPC elements
"""
# Steps:
# 1.Reconnect one of the host on which VPC Virtual Router is present.
# Validate the following
# 1. Host should successfully reconnect.
# 2. Network connectivity to all the VMs on the host should not be
# effected due to reconnection.
self.debug("Reconnecting the host where VPC VR is running")
try:
Host.reconnect(self.apiclient, id=self.vpcvr.hostid)
except Exception as e:
self.fail("Failed to reconnect to host: %s" % e)
self.debug("Check the status of router after migration")
routers = Router.list(
self.apiclient,
id=self.vpcvr.id,
listall=True
)
self.assertEqual(
isinstance(routers, list),
True,
"List routers shall return the valid response"
)
self.assertEqual(
routers[0].state,
"Running",
"Router state should be running"
)
# TODO: Check for the network connectivity
return
def tearDown(self):
try:
for host in self.hosts:
Host.update(self.apiclient, id=host.id, hosttags="")
cleanup_resources(self.apiclient, self.cleanup)
except Exception as e:
self.debug("Warning! Exception in tearDown: %s" % e)
def tearDown(self):
try:
for host in self.hosts:
Host.update(self.apiclient, id=host.id, hosttags="")
cleanup_resources(self.apiclient, self.cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
def tearDownClass(cls):
try:
# Remove the host from HA
Host.update(cls.api_client, id=cls.hosts[2].id, hosttags="")
#Cleanup resources used
cleanup_resources(cls.api_client, cls._cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def test_validateState_succeeds_at_retry_limit(self):
retries = 3
timeout = 3
api_client = MockApiClient(retries, 'initial state', 'final state')
host = Host({'id': 'host_id'})
state = host.validateState(api_client, ['final state', 'final state'], timeout=timeout, interval=1)
self.assertEqual(state, [PASS, None])
self.assertEqual(retries, api_client.retry_counter)
def test_03_reconnect_host(self):
""" Test reconnect Host which has VPC elements
"""
# Steps:
# 1.Reconnect one of the host on which VPC Virtual Router is present.
# Validate the following
# 1. Host should successfully reconnect.
# 2. Network connectivity to all the VMs on the host should not be
# effected due to reconnection.
try:
timeout = self.services["timeout"]
while True:
list_host_response = Host.list(
self.apiclient,
id=self.vpcvr.hostid,
resourcestate="Enabled")
if list_host_response is not None:
break
elif timeout == 0:
raise Exception("Failed to list the Host in Up State")
time.sleep(self.services["sleep"])
timeout = timeout - 1
self.debug("Verified that the Host is in Up State")
except:
self.fail("Failed to find the Host in Up State")
self.debug("Reconnecting the host where VPC VR is running")
try:
Host.reconnect(self.apiclient, id=self.vpcvr.hostid)
except Exception as e:
self.fail("Failed to reconnect to host: %s" % e)
self.debug("Check the status of router after migration")
routers = Router.list(
self.apiclient,
id=self.vpcvr.id,
listall=True
)
self.assertEqual(
isinstance(routers, list),
True,
"List routers shall return the valid response"
)
self.assertEqual(
routers[0].state,
"Running",
"Router state should be running"
)
# TODO: Check for the network connectivity
return
def test_validateState_fails_after_retry_limit(self):
retries = 3
timeout = 2
api_client = MockApiClient(retries, 'initial state', 'final state')
host = Host({'id': 'host_id'})
state = host.validateState(api_client, ['final state', 'final state'], timeout=timeout, interval=1)
self.assertEqual(state,
[FAIL, "Host state not transited to %s, operation timed out" % ['final state', 'final state']])
self.assertEqual(retries, api_client.retry_counter)
def tearDownClass(cls):
try:
# Delete the host tags
Host.update(cls.api_client, id=cls.hosts[0].id, hosttags="")
Host.update(cls.api_client, id=cls.hosts[1].id, hosttags="")
cls.account.delete(cls.api_client)
wait_for_cleanup(cls.api_client, ["account.cleanup.interval"])
# Cleanup resources used
cleanup_resources(cls.api_client, cls._cleanup)
cls.vpc_off.delete(cls.api_client)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def test_02_cancel_maintenance(self):
""" Test cancel Maintenance Mode on the above Hosts + Migrate VMs Back
"""
# Steps
# 1. Cancel Maintenance Mode on the host.
# 2. Migrate the VMs back onto the host on which Maintenance mode is
# cancelled.
# Validate the following
# 1. Successfully cancel the Maintenance mode on the host.
# 2. Migrate the VMs back successfully onto the host.
# 3. Check that the network connectivity exists with the migrated VMs.
self.debug("Cancel host maintenence on which the VPCVR is running")
try:
Host.cancelMaintenance(self.apiclient, id=self.vpcvr.hostid)
except Exception as e:
self.fail("Failed to enable maintenance mode on host: %s" % e)
self.debug(
"Migrating the instances back to the host: %s" %
self.vpcvr.hostid)
try:
cmd = migrateSystemVm.migrateSystemVmCmd()
cmd.hostid = self.vpcvr.hostid
cmd.virtualmachineid = self.vpcvr.id
self.apiclient.migrateSystemVm(cmd)
except Exception as e:
self.fail("Failed to migrate VPCVR back: %s" % e)
self.debug("Check the status of router after migration")
routers = Router.list(
self.apiclient,
id=self.vpcvr.id,
listall=True
)
self.assertEqual(
isinstance(routers, list),
True,
"List routers shall return the valid response"
)
self.assertEqual(
routers[0].state,
"Running",
"Router state should be running"
)
# TODO: Check for the network connectivity
return
def test_06_secondary_storage(self):
"""Check the status of secondary storage"""
# Validate the following
# 1. List secondary storage
# 2. Check state is "Up" or not
if self.hypervisor.lower() == 'simulator':
self.skipTest("Hypervisor is simulator skipping")
sec_storages = Host.list(
self.apiclient,
zoneid=self.zone.id,
type='SecondaryStorageVM',
listall=True
)
if sec_storages is None:
self.skipTest("SSVM is not provisioned yet, skipping")
self.assertEqual(
isinstance(sec_storages, list),
True,
"Check if listHosts returns a valid response"
)
for sec_storage in sec_storages:
self.assertEqual(
sec_storage.state,
'Up',
"Secondary storage should be in Up state"
)
return
def setUpClass(cls):
testClient = super(TestDeployVmWithVariedPlanners, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.template = get_template(
cls.apiclient,
cls.zone.id,
cls.services["ostype"]
)
if cls.template == FAILED:
assert False, "get_template() failed to return template with description %s" % cls.services["ostype"]
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["template"] = cls.template.id
cls.services["zoneid"] = cls.zone.id
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
domainid=cls.domain.id
)
cls.hosts = Host.list(cls.apiclient, type='Routing')
cls.clusters = Cluster.list(cls.apiclient)
cls.cleanup = [
cls.account
]
def test_02_migrate_vm(self):
"""Test migrate VM in project
# Validate the following
# 1. Create VM with custom disk offering in a project and check
# initial primary storage count
# 2. List the hosts suitable for migrating the VM
# 3. Migrate the VM and verify that primary storage count of project remains same"""
try:
hosts = Host.list(self.apiclient,virtualmachineid=self.vm.id,
listall=True)
self.assertEqual(validateList(hosts)[0], PASS, "hosts list validation failed")
host = hosts[0]
self.vm.migrate(self.apiclient, host.id)
except Exception as e:
self.fail("Exception occured" % e)
expectedCount = self.initialResourceCount
response = matchResourceCount(
self.apiclient, expectedCount,
RESOURCE_PRIMARY_STORAGE,
projectid=self.project.id)
self.assertEqual(response[0], PASS, response[1])
return
def test_06_secondary_storage(self):
"""Check the status of secondary storage"""
# Validate the following
# 1. List secondary storage
# 2. Check state is "Up" or not
sec_storages = Host.list(
self.apiclient,
zoneid=self.zone.id,
type='SecondaryStorageVM',
listall=True
)
self.assertEqual(
isinstance(sec_storages, list),
True,
"Check if listHosts returns a valid response"
)
for sec_storage in sec_storages:
self.assertEqual(
sec_storage.state,
'Up',
"Secondary storage should be in Up state"
)
return
def test_04_hosts(self):
"""Check the status of hosts"""
# Validate the following
# 1. List hosts with type=Routing
# 2. Check state is "Up" or not
hosts = Host.list(
self.apiclient,
zoneid=self.zone.id,
type='Routing',
listall=True
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check if listHosts returns a valid response"
)
for host in hosts:
self.assertEqual(
host.state,
'Up',
"Host should be in Up state and running"
)
return
def test_01_cluster_settings(self):
"""change cpu/mem.overprovisioning.factor at cluster level and
verify the change """
listHost = Host.list(self.apiclient,
id=self.deployVmResponse.hostid
)
self.assertEqual(
validateList(listHost)[0],
PASS,
"check list host response for host id %s" %
self.deployVmResponse.hostid)
Configurations.update(self.apiclient,
clusterid=listHost[0].clusterid,
name="mem.overprovisioning.factor",
value=2)
Configurations.update(self.apiclient,
clusterid=listHost[0].clusterid,
name="cpu.overprovisioning.factor",
value=3)
list_cluster = Cluster.list(self.apiclient,
id=listHost[0].clusterid)
self.assertEqual(
validateList(list_cluster)[0],
PASS,
"check list cluster response for cluster id %s" %
listHost[0].clusterid)
self.assertEqual(int(list_cluster[0].cpuovercommitratio),
3,
"check the cpu overcommit value at cluster level ")
self.assertEqual(int(list_cluster[0].memoryovercommitratio),
2,
"check memory overcommit value at cluster level")
Configurations.update(self.apiclient,
clusterid=listHost[0].clusterid,
name="mem.overprovisioning.factor",
value=1)
Configurations.update(self.apiclient,
clusterid=listHost[0].clusterid,
name="cpu.overprovisioning.factor",
value=1)
list_cluster1 = Cluster.list(self.apiclient,
id=listHost[0].clusterid)
self.assertEqual(
validateList(list_cluster1)[0],
PASS,
"check the list cluster response for id %s" %
listHost[0].clusterid)
self.assertEqual(int(list_cluster1[0].cpuovercommitratio),
1,
"check the cpu overcommit value at cluster level ")
self.assertEqual(int(list_cluster1[0].memoryovercommitratio),
1,
"check memory overcommit value at cluster level")
def get_target_host(self, secured, virtualmachineid):
target_hosts = Host.listForMigration(self.apiclient,
virtualmachineid=virtualmachineid)
for host in target_hosts:
h = list_hosts(self.apiclient,type='Routing', id=host.id)[0]
if h.details.secured == secured:
return h
cloudstackTestCase.skipTest(self, "No target hosts available, skipping test.")
def migrate_router(self, router):
""" Migrate the router """
self.debug("Checking if the host is available for migration?")
hosts = Host.list(self.api_client, zoneid=self.zone.id, type='Routing')
self.assertEqual(
isinstance(hosts, list),
True,
"List hosts should return a valid list"
)
if len(hosts) < 2:
self.skipTest(
"No host available for migration. Test requires atleast 2 hosts")
# Remove the host of current VM from the hosts list
hosts[:] = [host for host in hosts if host.id != router.hostid]
host = hosts[0]
self.debug("Validating if the network rules work properly or not?")
self.debug("Migrating VM-ID: %s from %s to Host: %s" % (
router.id,
router.hostid,
host.id
))
try:
# Migrate the router
cmd = migrateSystemVm.migrateSystemVmCmd()
cmd.isAsync = "false"
cmd.hostid = host.id
cmd.virtualmachineid = router.id
self.api_client.migrateSystemVm(cmd)
except Exception as e:
self.fail("Failed to migrate instance, %s" % e)
self.debug("Waiting for Router mgiration ....")
time.sleep(240)
# List routers to check state of router
router_response = list_routers(
self.api_client,
id=router.id
)
self.assertEqual(
isinstance(router_response, list),
True,
"Check list response returns a valid list"
)
router.hostid = router_response[0].hostid
self.assertEqual(
router.hostid, host.id, "Migration to host %s failed. The router host is"
"still %s" %
(host.id, router.hostid))
return
def update_host(self, state, host_id):
"""
Function to Enable/Disable Host
"""
host_status = Host.update(
self.apiclient,
id=host_id,
allocationstate=state
)
return host_status.resourcestate
def test_10_list_volumes(self):
# Validate the following
#
# 1. List Root Volume and waits until it has the newly introduced attributes
#
# 2. Verifies return attributes has values different from none, when instance is running
#
list_vm = VirtualMachine.list(self.apiclient, id=self.virtual_machine.id)[0]
host = Host.list(
self.apiclient,
type='Routing',
id=list_vm.hostid
)[0]
list_pods = get_pod(self.apiclient, self.zone.id, host.podid)
root_volume = self.wait_for_attributes_and_return_root_vol()
self.assertTrue(hasattr(root_volume, "utilization"))
self.assertTrue(root_volume.utilization is not None)
self.assertTrue(hasattr(root_volume, "virtualsize"))
self.assertTrue(root_volume.virtualsize is not None)
self.assertTrue(hasattr(root_volume, "physicalsize"))
self.assertTrue(root_volume.physicalsize is not None)
self.assertTrue(hasattr(root_volume, "vmname"))
self.assertEqual(root_volume.vmname, list_vm.name)
self.assertTrue(hasattr(root_volume, "clustername"))
self.assertTrue(root_volume.clustername is not None)
self.assertTrue(hasattr(root_volume, "clusterid"))
self.assertTrue(root_volume.clusterid is not None)
self.assertTrue(hasattr(root_volume, "storageid"))
self.assertTrue(root_volume.storageid is not None)
self.assertTrue(hasattr(root_volume, "storage"))
self.assertTrue(root_volume.storage is not None)
self.assertTrue(hasattr(root_volume, "zoneid"))
self.assertEqual(root_volume.zoneid, self.zone.id)
self.assertTrue(hasattr(root_volume, "zonename"))
self.assertEqual(root_volume.zonename, self.zone.name)
self.assertTrue(hasattr(root_volume, "podid"))
self.assertEqual(root_volume.podid, list_pods.id)
self.assertTrue(hasattr(root_volume, "podname"))
self.assertEqual(root_volume.podname, list_pods.name)
def tearDownClass(cls):
try:
# Cleanup resources used
cleanup_resources(cls.api_client, cls._cleanup)
for host in cls.hosts:
Host.cancelMaintenance(
cls.api_client,
id=host.id
)
hosts_states = Host.list(
cls.api_client,
id=host.id,
listall=True
)
if hosts_states[0].resourcestate != 'Enabled':
raise Exception(
"Failed to cancel maintenance mode on %s" %
(host.name))
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def setUpClass(cls):
cls.testClient = super(TestAttachVolumeISO, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.pod = get_pod(cls.api_client, cls.zone.id)
cls.services["mode"] = cls.zone.networktype
cls._cleanup = []
cls.unsupportedStorageType = False
cls.hypervisor = cls.testClient.getHypervisorInfo()
if cls.hypervisor.lower() == "lxc":
if not find_storage_pool_type(cls.api_client, storagetype="rbd"):
cls.unsupportedStorageType = True
return
cls.disk_offering = DiskOffering.create(cls.api_client, cls.services["disk_offering"])
cls._cleanup.append(cls.disk_offering)
template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
cls.services["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["iso"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = template.id
# get max data volumes limit based on the hypervisor type and version
listHost = Host.list(cls.api_client, type="Routing", zoneid=cls.zone.id, podid=cls.pod.id)
ver = listHost[0].hypervisorversion
hv = listHost[0].hypervisor
cmd = listHypervisorCapabilities.listHypervisorCapabilitiesCmd()
cmd.hypervisor = hv
res = cls.api_client.listHypervisorCapabilities(cmd)
cls.debug("Hypervisor Capabilities: {}".format(res))
for i in range(len(res)):
if res[i].hypervisorversion == ver:
break
cls.max_data_volumes = int(res[i].maxdatavolumeslimit)
cls.debug("max data volumes:{}".format(cls.max_data_volumes))
cls.services["volume"]["max"] = cls.max_data_volumes
# Create VMs, NAT Rules etc
cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"])
cls._cleanup.append(cls.service_offering)
cls.virtual_machine = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
)
def migrate_vm(self, vm):
self.debug("Checking if a host is available for migration?")
hosts = Host.listForMigration(self.api_client)
self.assertEqual(isinstance(hosts, list), True,
"List hosts should return a valid list"
)
# Remove the host of current VM from the hosts list
hosts[:] = [host for host in hosts if host.id != vm.hostid]
if len(hosts) <= 0:
self.skipTest("No host available for migration. Test requires at-least 2 hosts")
host = hosts[0]
self.debug("Migrating VM-ID: %s to Host: %s" % (vm.id, host.id))
try:
vm.migrate(self.api_client, hostid=host.id)
except Exception as e:
self.fail("Failed to migrate instance, %s" % e)
def test_08_resize_volume(self):
"""Test resize a volume"""
# Verify the size is the new size is what we wanted it to be.
self.debug(
"Attaching volume (ID: %s) to VM (ID: %s)" % (
self.volume.id,
self.virtual_machine.id
))
self.virtual_machine.attach_volume(self.apiClient, self.volume)
self.attached = True
hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid)
self.assertTrue(isinstance(hosts, list))
self.assertTrue(len(hosts) > 0)
self.debug("Found %s host" % hosts[0].hypervisor)
if hosts[0].hypervisor == "XenServer":
self.virtual_machine.stop(self.apiClient)
elif hosts[0].hypervisor.lower() == "vmware":
self.skipTest("Resize Volume is unsupported on VmWare")
# resize the data disk
self.debug("Resize Volume ID: %s" % self.volume.id)
cmd = resizeVolume.resizeVolumeCmd()
cmd.id = self.volume.id
cmd.diskofferingid = self.services['resizeddiskofferingid']
self.apiClient.resizeVolume(cmd)
count = 0
success = False
while count < 3:
list_volume_response = Volume.list(
self.apiClient,
id=self.volume.id,
type='DATADISK'
)
for vol in list_volume_response:
if vol.id == self.volume.id and vol.size == 3221225472L and vol.state == 'Ready':
success = True
if success:
break
else:
time.sleep(10)
count += 1
def findSuitableHostForMigration(apiclient, vmid):
"""Returns a suitable host for VM migration"""
suitableHost = None
try:
hosts = Host.listForMigration(apiclient, virtualmachineid=vmid)
except Exception as e:
raise Exception("Exception while getting hosts list suitable for migration: %s" % e)
suitablehosts = []
if isinstance(hosts, list) and len(hosts) > 0:
suitablehosts = [
host for host in hosts if (str(host.resourcestate).lower() == "enabled" and str(host.state).lower() == "up")
]
if len(suitablehosts) > 0:
suitableHost = suitablehosts[0]
return suitableHost
def setUpClass(cls):
testClient = super(TestDisableEnableHost, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.testdata = testClient.getParsedTestDataConfig()
cls.hypervisor = cls.testClient.getHypervisorInfo()
cls.snapshotSupported = True
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.pod = get_pod(cls.apiclient, zone_id=cls.zone.id)
hostList = Host.list(cls.apiclient, zoneid=cls.zone.id, type="routing")
clusterList = Cluster.list(cls.apiclient, id=hostList[0].clusterid)
cls.host = Host(hostList[0].__dict__)
cls.cluster = Cluster(clusterList[0].__dict__)
cls.template = get_template(cls.apiclient, cls.zone.id, cls.testdata["ostype"])
cls._cleanup = []
cls.disabledHosts = []
try:
cls.service_offering = ServiceOffering.create(cls.apiclient, cls.testdata["service_offering"])
cls._cleanup.append(cls.service_offering)
cls.disk_offering = DiskOffering.create(cls.apiclient, cls.testdata["disk_offering"])
cls._cleanup.append(cls.disk_offering)
# Create an account
cls.account = Account.create(cls.apiclient, cls.testdata["account"], domainid=cls.domain.id)
cls._cleanup.append(cls.account)
# Create root admin account
cls.admin_account = Account.create(cls.apiclient, cls.testdata["account2"], admin=True)
cls._cleanup.append(cls.admin_account)
# Create user api client of the account
cls.userapiclient = testClient.getUserApiClient(UserName=cls.account.name, DomainName=cls.account.domain)
except Exception as e:
cls.tearDownClass()
raise e
return
def tearDownClass(cls):
try:
for hostid in cls.disabledHosts:
hosts = Host.list(cls.apiclient, id=hostid)
assert (
validateList(hosts)[0] == PASS
), "hosts\
list validation failed"
if hosts[0].resourcestate.lower() == DISABLED.lower():
cmd = updateHost.updateHostCmd()
cmd.id = hostid
cmd.resourcestate = ENABLED
cmd.allocationstate = ENABLE
cls.apiclient.updateHost(cmd)
cleanup_resources(cls.apiclient, cls._cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
def test_deployVmOnGivenHost(self):
"""Test deploy VM on specific host
"""
# Steps for validation
# 1. as admin list available hosts that are Up
# 2. deployVM with hostid=above host
# 3. listVirtualMachines
# 4. destroy VM
# Validate the following
# 1. listHosts returns at least one host in Up state
# 2. VM should be in Running
# 3. VM should be on the host that it was deployed on
hosts = Host.list(self.apiclient, zoneid=self.zone.id, type="Routing", state="Up", listall=True)
self.assertEqual(isinstance(hosts, list), True, "CS should have atleast one host Up and Running")
host = hosts[0]
self.debug("Deploting VM on host: %s" % host.name)
try:
vm = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
hostid=host.id,
)
self.debug("Deploy VM succeeded")
except Exception as e:
self.fail("Deploy VM failed with exception: %s" % e)
self.debug("Cheking the state of deployed VM")
vms = VirtualMachine.list(
self.apiclient, id=vm.id, listall=True, account=self.account.name, domainid=self.account.domainid
)
self.assertEqual(isinstance(vms, list), True, "List Vm should return a valid response")
vm_response = vms[0]
self.assertEqual(vm_response.state, "Running", "VM should be in running state after deployment")
self.assertEqual(vm_response.hostid, host.id, "Host id where VM is deployed should match")
return
def check_connection(self, secured, host, retries=20, interval=6):
while retries > -1:
time.sleep(interval)
host = Host.list(
self.apiclient,
zoneid=self.zone.id,
hostid=host.id,
type='Routing'
)[0]
if host.details.secured != secured:
if retries >= 0:
retries = retries - 1
continue
else:
return
raise Exception("Host detail 'secured' was expected: " + secured +
", actual is: " + host.details.secured)
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
if self.hypervisor.lower() not in ["kvm"]:
self.skipTest("Secured migration is not supported on other than KVM")
self.hosts = Host.list(
self.apiclient,
zoneid=self.zone.id,
type='Routing',
hypervisor='KVM')
if len(self.hosts) < 2:
self.skipTest("Requires at least two hosts for performing migration related tests")
self.secure_all_hosts()
self.updateConfiguration("ca.plugin.root.auth.strictness", "false")
def setUp(self):
self.testdata = self.testClient.getParsedTestDataConfig()
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient)
self.zone = get_zone(self.apiclient, self.testClient.getZoneForTests())
self.testdata["mode"] = self.zone.networktype
self.template = get_template(self.apiclient, self.zone.id, self.testdata["ostype"])
self.hosts = []
suitablecluster = None
clusters = Cluster.list(self.apiclient)
self.assertTrue(isinstance(clusters, list) and len(clusters) > 0, msg = "No clusters found")
for cluster in clusters:
self.hosts = Host.list(self.apiclient, clusterid=cluster.id, type='Routing')
if isinstance(self.hosts, list) and len(self.hosts) >= 2:
suitablecluster = cluster
break
self.assertEqual(validateList(self.hosts)[0], PASS, "hosts list validation failed")
if len(self.hosts) < 2:
self.skipTest("Atleast 2 hosts required in cluster for VM HA test")
#update host tags
for host in self.hosts:
Host.update(self.apiclient, id=host.id, hosttags=self.testdata["service_offerings"]["hasmall"]["hosttags"])
#create a user account
self.account = Account.create(
self.apiclient,
self.testdata["account"],
domainid=self.domain.id
)
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient,
self.testdata["service_offerings"]["hasmall"]
)
#deploy ha vm
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
templateid=self.template.id
)
list_vms = VirtualMachine.list(self.apiclient, id=self.virtual_machine.id)
self.debug(
"Verify listVirtualMachines response for virtual machine: %s"\
% self.virtual_machine.id
)
self.assertTrue(isinstance(list_vms, list) and len(list_vms) == 1, msg = "List VM response was empty")
self.virtual_machine = list_vms[0]
self.mock_checkhealth = SimulatorMock.create(
apiclient=self.apiclient,
command="CheckHealthCommand",
zoneid=suitablecluster.zoneid,
podid=suitablecluster.podid,
clusterid=suitablecluster.id,
hostid=self.virtual_machine.hostid,
value="result:fail")
self.mock_ping = SimulatorMock.create(
apiclient=self.apiclient,
command="PingCommand",
zoneid=suitablecluster.zoneid,
podid=suitablecluster.podid,
clusterid=suitablecluster.id,
hostid=self.virtual_machine.hostid,
value="result:fail")
self.mock_checkvirtualmachine = SimulatorMock.create(
apiclient=self.apiclient,
command="CheckVirtualMachineCommand",
zoneid=suitablecluster.zoneid,
podid=suitablecluster.podid,
clusterid=suitablecluster.id,
hostid=self.virtual_machine.hostid,
value="result:fail")
self.mock_pingtest = SimulatorMock.create(
apiclient=self.apiclient,
command="PingTestCommand",
zoneid=suitablecluster.zoneid,
podid=suitablecluster.podid,
value="result:fail")
self.mock_checkonhost_list = []
for host in self.hosts:
if host.id != self.virtual_machine.hostid:
self.mock_checkonhost_list.append(SimulatorMock.create(
apiclient=self.apiclient,
command="CheckOnHostCommand",
zoneid=suitablecluster.zoneid,
podid=suitablecluster.podid,
clusterid=suitablecluster.id,
hostid=host.id,
value="result:fail"))
#build cleanup list
self.cleanup = [
self.service_offering,
self.account,
self.mock_checkhealth,
self.mock_ping,
self.mock_checkvirtualmachine,
self.mock_pingtest
]
self.cleanup = self.cleanup + self.mock_checkonhost_list
def test_check_hypervisor_max_limit_effect(self):
""" Test hypervisor max limits effect
# 1. Read exsiting count of VM's on the host including SSVM and VR
and modify maxguestcount accordingly
# 2. Deploy a VM
# 2. Try to deploy another vm
# 3. Verify that second VM
deployment fails (2 SSVMs 1 VR VM and 1 deployed VM)
"""
hostList = Host.list(self.apiclient,
zoneid=self.zone.id,
type="Routing")
event_validation_result = validateList(hostList)
self.assertEqual(
event_validation_result[0], PASS,
"host list validation failed due to %s" %
event_validation_result[2])
self.host = Host(hostList[0])
Host.update(self.apiclient, id=self.host.id, hosttags="host1")
# Step 1
# List VM's , SSVM's and VR on selected host
listVm = list_virtual_machines(self.apiclient, hostid=self.host.id)
listssvm = list_ssvms(self.apiclient, hostid=self.host.id)
listvr = list_routers(self.apiclient, hostid=self.host.id)
newValue = 1
if listVm is not None:
newValue = len(listVm) + newValue
if listssvm is not None:
newValue = len(listssvm) + newValue
if listvr is not None:
newValue = len(listvr) + newValue
qresultset = self.dbclient.execute(
"select hypervisor_version from host where uuid='%s'" %
self.host.id)
event_validation_result = validateList(qresultset)
self.assertEqual(
event_validation_result[0], PASS,
"event list validation failed due to %s" %
event_validation_result[2])
cmdList = listHypervisorCapabilities.listHypervisorCapabilitiesCmd()
cmdList.hypervisor = self.hypervisor
config = self.apiclient.listHypervisorCapabilities(cmdList)
for host in config:
if host.hypervisorversion == qresultset[0][0]:
self.hostCapId = host.id
self.originalLimit = host.maxguestslimit
break
else:
self.skipTest("No hypervisor capabilities found for %s \
with version %s" % (self.hypervisor, qresultset[0][0]))
cmdUpdate = updateHypervisorCapabilities.\
updateHypervisorCapabilitiesCmd()
cmdUpdate.id = self.hostCapId
cmdUpdate.maxguestslimit = newValue
self.apiclient.updateHypervisorCapabilities(cmdUpdate)
# Step 2
vm = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
self.cleanup.append(vm)
# Step 3
with self.assertRaises(Exception):
VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
def test_03_restore_vm_with_new_template(self):
""" Test restoring a vm with different template than the one it was created with
"""
hosts = Host.list(self.apiclient, type="Routing", listall=True)
host_list_validation_result = validateList(hosts)
self.assertEqual(
host_list_validation_result[0], PASS,
"host list validation failed due to %s" %
host_list_validation_result[2])
hypervisor = host_list_validation_result[1].hypervisor
for k, v in self.services["templates"].items():
if k.lower() == hypervisor.lower():
# Register new template
template = Template.register(self.apiclient,
v,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
hypervisor=self.hypervisor)
self.debug("Registered a template of format: %s with ID: %s" %
(v["format"], template.id))
self.debug("Downloading template with ID: %s" % (template.id))
template.download(self.apiclient)
self.cleanup.append(template)
# Wait for template status to be changed across
time.sleep(self.services["sleep"])
self.verify_template_listing(template)
# Restore a vm with the new template.
self.vm_with_reset.restore(self.apiclient,
templateid=template.id)
self.vm_without_reset.restore(self.apiclient,
templateid=template.id)
# Make sure the VMs now have the new template ID
# Make sure the Ip address of the VMs haven't changed
self.debug("Checking template id of VM with isVolatile=True")
vms = VirtualMachine.list(self.apiclient,
id=self.vm_with_reset.id,
listall=True)
vm_list_validation_result = validateList(vms)
self.assertEqual(
vm_list_validation_result[0], PASS,
"VM list validation failed due to %s" %
vm_list_validation_result[2])
vm_with_reset = vm_list_validation_result[1]
self.assertNotEqual(
self.vm_with_reset.templateid, vm_with_reset.templateid,
"VM created with IsVolatile=True has same templateid : %s after restore"
% vm_with_reset.templateid)
self.assertNotEqual(
self.vm_with_reset.templateid, template.id,
"VM created with IsVolatile=True has wrong templateid after restore Got:%s Expected: %s"
% (self.vm_with_reset.templateid, template.id))
# Make sure it has the same IP after reboot
self.assertEqual(
self.vm_with_reset.nic[0].ipaddress,
vm_with_reset.nic[0].ipaddress,
"VM created with IsVolatile=True doesn't have same ip after restore. Got : %s Expected : %s"
% (vm_with_reset.nic[0].ipaddress,
self.vm_with_reset.nic[0].ipaddress))
# Check if the the root disk was not destroyed for isVolatile=False
self.debug("Checking template id of VM with isVolatile=False")
vms = VirtualMachine.list(self.apiclient,
id=self.vm_without_reset.id,
listall=True)
vm_list_validation_result = validateList(vms)
self.assertEqual(
vm_list_validation_result[0], PASS,
"VM list validation failed due to %s" %
vm_list_validation_result[2])
vm_without_reset = vm_list_validation_result[1]
self.assertNotEqual(
self.vm_without_reset.templateid,
vm_without_reset.templateid,
"VM created with IsVolatile=False has same templateid : %s after restore"
% vm_with_reset.templateid)
self.assertNotEqual(
self.vm_without_reset.templateid, template.id,
"VM created with IsVolatile=False has wrong templateid after restore Got:%s Expected: %s"
% (self.vm_without_reset.templateid, template.id))
# Make sure it has the same IP after reboot
self.assertEqual(
self.vm_without_reset.nic[0].ipaddress,
vm_without_reset.nic[0].ipaddress,
"VM created with IsVolatile=False doesn't have same ip after restore. Got : %s Expected : %s"
% (vm_without_reset.nic[0].ipaddress,
self.vm_without_reset.nic[0].ipaddress))
return
def test_07_resize_fail(self):
"""Test resize (negative) non-existent volume"""
# Verify the size is the new size is what we wanted it to be.
self.debug("Fail Resize Volume ID: %s" % self.volume.id)
# first, an invalid id
cmd = resizeVolume.resizeVolumeCmd()
cmd.id = "invalid id"
cmd.diskofferingid = self.services['customresizeddiskofferingid']
success = False
try:
self.apiClient.resizeVolume(cmd)
except Exception as ex:
#print str(ex)
if "invalid" in str(ex):
success = True
self.assertEqual(
success,
True,
"ResizeVolume - verify invalid id is handled appropriately")
# Next, we'll try an invalid disk offering id
cmd.id = self.volume.id
cmd.diskofferingid = "invalid id"
success = False
try:
self.apiClient.resizeVolume(cmd)
except Exception as ex:
if "invalid" in str(ex):
success = True
self.assertEqual(
success,
True,
"ResizeVolume - verify disk offering is handled appropriately")
# try to resize a root disk with a disk offering, root can only be resized by size=
# get root vol from created vm
list_volume_response = Volume.list(
self.apiClient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall=True
)
rootvolume = list_volume_response[0]
cmd.id = rootvolume.id
cmd.diskofferingid = self.services['diskofferingid']
with self.assertRaises(Exception):
self.apiClient.resizeVolume(cmd)
# Ok, now let's try and resize a volume that is not custom.
cmd.id = self.volume.id
cmd.diskofferingid = self.services['diskofferingid']
cmd.size = 4
currentSize = self.volume.size
self.debug(
"Attaching volume (ID: %s) to VM (ID: %s)" % (
self.volume.id,
self.virtual_machine.id)
)
#attach the volume
self.virtual_machine.attach_volume(self.apiClient, self.volume)
self.attached = True
#stop the vm if it is on xenserver
hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid)
self.assertTrue(isinstance(hosts, list))
self.assertTrue(len(hosts) > 0)
self.debug("Found %s host" % hosts[0].hypervisor)
if hosts[0].hypervisor == "XenServer":
self.virtual_machine.stop(self.apiClient)
elif hosts[0].hypervisor.lower() in ("vmware", "hyperv"):
self.skipTest("Resize Volume is unsupported on VmWare and Hyper-V")
# Attempting to resize it should throw an exception, as we're using a non
# customisable disk offering, therefore our size parameter should be ignored
with self.assertRaises(Exception):
self.apiClient.resizeVolume(cmd)
if hosts[0].hypervisor == "XenServer":
self.virtual_machine.start(self.apiClient)
time.sleep(30)
return
def test_08_resize_volume(self):
"""Test resize a volume"""
# Verify the size is the new size is what we wanted it to be.
self.debug(
"Attaching volume (ID: %s) to VM (ID: %s)" % (
self.volume.id,
self.virtual_machine.id
))
self.virtual_machine.attach_volume(self.apiClient, self.volume)
self.attached = True
hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid)
self.assertTrue(isinstance(hosts, list))
self.assertTrue(len(hosts) > 0)
self.debug("Found %s host" % hosts[0].hypervisor)
if hosts[0].hypervisor == "XenServer":
self.virtual_machine.stop(self.apiClient)
elif hosts[0].hypervisor.lower() in ("vmware", "hyperv"):
self.skipTest("Resize Volume is unsupported on VmWare and Hyper-V")
# resize the data disk
self.debug("Resize Volume ID: %s" % self.volume.id)
self.services["disk_offering"]["disksize"] = 20
disk_offering_20_GB = DiskOffering.create(
self.apiclient,
self.services["disk_offering"]
)
self.cleanup.append(disk_offering_20_GB)
cmd = resizeVolume.resizeVolumeCmd()
cmd.id = self.volume.id
cmd.diskofferingid = disk_offering_20_GB.id
self.apiClient.resizeVolume(cmd)
count = 0
success = False
while count < 3:
list_volume_response = Volume.list(
self.apiClient,
id=self.volume.id,
type='DATADISK'
)
for vol in list_volume_response:
if vol.id == self.volume.id and int(vol.size) == (int(disk_offering_20_GB.disksize) * (1024** 3)) and vol.state == 'Ready':
success = True
if success:
break
else:
time.sleep(10)
count += 1
self.assertEqual(
success,
True,
"Check if the data volume resized appropriately"
)
can_shrink = False
list_volume_response = Volume.list(
self.apiClient,
id=self.volume.id,
type='DATADISK'
)
storage_pool_id = [x.storageid for x in list_volume_response if x.id == self.volume.id][0]
storage = StoragePool.list(self.apiclient, id=storage_pool_id)[0]
# At present only CLVM supports shrinking volumes
if storage.type.lower() == "clvm":
can_shrink = True
if can_shrink:
self.services["disk_offering"]["disksize"] = 10
disk_offering_10_GB = DiskOffering.create(
self.apiclient,
self.services["disk_offering"]
)
self.cleanup.append(disk_offering_10_GB)
cmd = resizeVolume.resizeVolumeCmd()
cmd.id = self.volume.id
cmd.diskofferingid = disk_offering_10_GB.id
cmd.shrinkok = "true"
self.apiClient.resizeVolume(cmd)
count = 0
success = False
while count < 3:
list_volume_response = Volume.list(
self.apiClient,
id=self.volume.id
)
for vol in list_volume_response:
if vol.id == self.volume.id and int(vol.size) == (int(disk_offering_10_GB.disksize) * (1024 ** 3)) and vol.state == 'Ready':
success = True
if success:
break
else:
time.sleep(10)
count += 1
self.assertEqual(
success,
True,
"Check if the root volume resized appropriately"
)
#start the vm if it is on xenserver
if hosts[0].hypervisor == "XenServer":
self.virtual_machine.start(self.apiClient)
time.sleep(30)
return
def test_07_resize_fail(self):
"""Test resize (negative) non-existent volume"""
# Verify the size is the new size is what we wanted it to be.
self.debug("Fail Resize Volume ID: %s" % self.volume.id)
# first, an invalid id
cmd = resizeVolume.resizeVolumeCmd()
cmd.id = "invalid id"
cmd.diskofferingid = self.services['resizeddiskofferingid']
success = False
try:
self.apiClient.resizeVolume(cmd)
except Exception as ex:
#print str(ex)
if "invalid" in str(ex):
success = True
self.assertEqual(
success,
True,
"ResizeVolume - verify invalid id is handled appropriately")
# Next, we'll try an invalid disk offering id
cmd.id = self.volume.id
cmd.diskofferingid = "invalid id"
success = False
try:
self.apiClient.resizeVolume(cmd)
except Exception as ex:
if "invalid" in str(ex):
success = True
self.assertEqual(
success,
True,
"ResizeVolume - verify disk offering is handled appropriately")
# try to resize a root disk with a disk offering, root can only be resized by size=
# get root vol from created vm
list_volume_response = Volume.list(
self.apiClient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall=True
)
rootvolume = list_volume_response[0]
cmd.id = rootvolume.id
cmd.diskofferingid = self.services['diskofferingid']
success = False
try:
self.apiClient.resizeVolume(cmd)
except Exception as ex:
if "Can only resize Data volumes" in str(ex):
success = True
self.assertEqual(
success,
True,
"ResizeVolume - verify root disks cannot be resized by disk offering id")
# Ok, now let's try and resize a volume that is not custom.
cmd.id = self.volume.id
cmd.diskofferingid = self.services['diskofferingid']
cmd.size = 4
currentSize = self.volume.size
self.debug(
"Attaching volume (ID: %s) to VM (ID: %s)" % (
self.volume.id,
self.virtual_machine.id)
)
#attach the volume
self.virtual_machine.attach_volume(self.apiClient, self.volume)
self.attached = True
#stop the vm if it is on xenserver
hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid)
self.assertTrue(isinstance(hosts, list))
self.assertTrue(len(hosts) > 0)
self.debug("Found %s host" % hosts[0].hypervisor)
if hosts[0].hypervisor == "XenServer":
self.virtual_machine.stop(self.apiClient)
elif hosts[0].hypervisor.lower() == "vmware":
self.skipTest("Resize Volume is unsupported on VmWare")
self.apiClient.resizeVolume(cmd)
count = 0
success = True
while count < 10:
list_volume_response = Volume.list(
self.apiClient,
id=self.volume.id,
type='DATADISK'
)
for vol in list_volume_response:
if vol.id == self.volume.id and vol.size != currentSize and vol.state != "Resizing":
success = False
if success:
break
else:
time.sleep(1)
count += 1
self.assertEqual(
success,
True,
"Verify the volume did not resize"
)
if hosts[0].hypervisor == "XenServer":
self.virtual_machine.start(self.apiClient)
time.sleep(30)
return
def _perform_add_remove_host(self, primary_storage_id, sf_iscsi_name):
xen_sr = self.xen_session.xenapi.SR.get_by_name_label(sf_iscsi_name)[0]
pbds = self.xen_session.xenapi.SR.get_PBDs(xen_sr)
self._verify_all_pbds_attached(pbds)
num_pbds = len(pbds)
sf_vag_id = self._get_sf_vag_id(self.cluster.id, primary_storage_id)
host_iscsi_iqns = self._get_host_iscsi_iqns()
sf_vag = self._get_sf_vag(sf_vag_id)
sf_vag_initiators = self._get_sf_vag_initiators(sf_vag)
self._verifyVag(host_iscsi_iqns, sf_vag_initiators)
sf_vag_initiators_len_orig = len(sf_vag_initiators)
xen_session = XenAPI.Session(self.testdata[TestData.urlOfNewHost])
xenserver = self.testdata[TestData.xenServer]
xen_session.xenapi.login_with_password(xenserver[TestData.username], xenserver[TestData.password])
xen_session.xenapi.pool.join(self.xs_pool_master_ip, xenserver[TestData.username], xenserver[TestData.password])
time.sleep(60)
pbds = self.xen_session.xenapi.SR.get_PBDs(xen_sr)
self.assertEqual(
len(pbds),
num_pbds + 1,
"'len(pbds)' is not equal to 'num_pbds + 1'."
)
num_pbds = num_pbds + 1
num_pbds_not_attached = 0
for pbd in pbds:
pbd_record = self.xen_session.xenapi.PBD.get_record(pbd)
if pbd_record["currently_attached"] == False:
num_pbds_not_attached = num_pbds_not_attached + 1
self.assertEqual(
num_pbds_not_attached,
1,
"'num_pbds_not_attached' is not equal to 1."
)
host = Host.create(
self.apiClient,
self.cluster,
self.testdata[TestData.newHost],
hypervisor="XenServer"
)
self.assertTrue(
isinstance(host, Host),
"'host' is not a 'Host'."
)
pbds = self.xen_session.xenapi.SR.get_PBDs(xen_sr)
self.assertEqual(
len(pbds),
num_pbds,
"'len(pbds)' is not equal to 'num_pbds'."
)
self._verify_all_pbds_attached(pbds)
host_iscsi_iqns = self._get_host_iscsi_iqns()
sf_vag = self._get_sf_vag(sf_vag_id)
sf_vag_initiators = self._get_sf_vag_initiators(sf_vag)
self._verifyVag(host_iscsi_iqns, sf_vag_initiators)
sf_vag_initiators_len_new = len(sf_vag_initiators)
self.assertEqual(
sf_vag_initiators_len_new,
sf_vag_initiators_len_orig + 1,
"sf_vag_initiators_len_new' != sf_vag_initiators_len_orig + 1"
)
host.delete(self.apiClient)
pbds = self.xen_session.xenapi.SR.get_PBDs(xen_sr)
self.assertEqual(
len(pbds),
num_pbds,
"'len(pbds)' is not equal to 'num_pbds'."
)
self._verify_all_pbds_attached(pbds)
host_iscsi_iqns = self._get_host_iscsi_iqns()
sf_vag = self._get_sf_vag(sf_vag_id)
sf_vag_initiators = self._get_sf_vag_initiators(sf_vag)
self.assertEqual(
len(host_iscsi_iqns) - 1,
len(sf_vag_initiators),
"'len(host_iscsi_iqns) - 1' is not equal to 'len(sf_vag_initiators)'."
)
host_ref = self.xen_session.xenapi.host.get_by_name_label(self.testdata[TestData.newHostDisplayName])[0]
self.xen_session.xenapi.pool.eject(host_ref)
time.sleep(120)
pbds = self.xen_session.xenapi.SR.get_PBDs(xen_sr)
self.assertEqual(
len(pbds),
num_pbds - 1,
"'len(pbds)' is not equal to 'num_pbds - 1'."
)
self._verify_all_pbds_attached(pbds)
host_iscsi_iqns = self._get_host_iscsi_iqns()
sf_vag = self._get_sf_vag(sf_vag_id)
sf_vag_initiators = self._get_sf_vag_initiators(sf_vag)
self._verifyVag(host_iscsi_iqns, sf_vag_initiators)
sf_vag_initiators_len_new = len(sf_vag_initiators)
self.assertEqual(
sf_vag_initiators_len_new,
sf_vag_initiators_len_orig,
"sf_vag_initiators_len_new' != sf_vag_initiators_len_orig"
)
def test_08_migrate_vm(self):
"""Test migrate VM
"""
# Validate the following
# 1. Environment has enough hosts for migration
# 2. DeployVM on suitable host (with another host in the cluster)
# 3. Migrate the VM and assert migration successful
suitable_hosts = None
hosts = Host.list(self.apiclient, zoneid=self.zone.id, type='Routing')
self.assertEqual(
validateList(hosts)[0], PASS, "hosts list validation failed")
if len(hosts) < 2:
self.skipTest(
"At least two hosts should be present in the zone for migration"
)
if self.hypervisor.lower() in ["lxc"]:
self.skipTest("Migration is not supported on LXC")
# For KVM, two hosts used for migration should be present in same cluster
# For XenServer and VMware, migration is possible between hosts belonging to different clusters
# with the help of XenMotion and Vmotion respectively.
if self.hypervisor.lower() in ["kvm", "simulator"]:
# identify suitable host
clusters = [h.clusterid for h in hosts]
# find hosts withe same clusterid
clusters = [
cluster for index, cluster in enumerate(clusters)
if clusters.count(cluster) > 1
]
if len(clusters) <= 1:
self.skipTest(
"In " + self.hypervisor.lower() +
" Live Migration needs two hosts within same cluster")
suitable_hosts = [
host for host in hosts if host.clusterid == clusters[0]
]
else:
suitable_hosts = hosts
target_host = suitable_hosts[0]
migrate_host = suitable_hosts[1]
# deploy VM on target host
vm_to_migrate = VirtualMachine.create(
self.apiclient,
self.services["small"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.small_offering.id,
mode=self.services["mode"],
hostid=target_host.id)
self.debug("Migrating VM-ID: %s to Host: %s" %
(vm_to_migrate.id, migrate_host.id))
vm_to_migrate.migrate(self.apiclient, migrate_host.id)
retries_cnt = 3
while retries_cnt >= 0:
list_vm_response = VirtualMachine.list(self.apiclient,
id=vm_to_migrate.id)
self.assertNotEqual(list_vm_response, None,
"Check virtual machine is listed")
vm_response = list_vm_response[0]
self.assertEqual(vm_response.id, vm_to_migrate.id,
"Check virtual machine ID of migrated VM")
self.assertEqual(vm_response.hostid, migrate_host.id,
"Check destination hostID of migrated VM")
retries_cnt = retries_cnt - 1
return
