def test_06_stop_cpvm(self):
"""Test stop CPVM
"""
# Validate the following
# 1. The CPVM should go to stop state
# 2. After a brief delay of say one minute, the SSVM should be
# restarted once again and return to Running state with previous
# two test cases still passing
# 3. If either of the two above steps fail the test is a failure
list_cpvm_response = list_ssvms(self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_cpvm_response, list), True,
"Check list response returns a valid list")
cpvm = list_cpvm_response[0]
hosts = list_hosts(self.apiclient, id=cpvm.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list response returns a valid list")
self.debug("Stopping CPVM: %s" % cpvm.id)
cmd = stopSystemVm.stopSystemVmCmd()
cmd.id = cpvm.id
self.apiclient.stopSystemVm(cmd)
timeout = self.services["timeout"]
while True:
list_cpvm_response = list_ssvms(self.apiclient, id=cpvm.id)
if isinstance(list_cpvm_response, list):
if list_cpvm_response[0].state == 'Running':
break
if timeout == 0:
raise Exception("List CPVM call failed!")
time.sleep(self.services["sleep"])
timeout = timeout - 1
cpvm_response = list_cpvm_response[0]
self.debug("CPVM state after debug: %s" % cpvm_response.state)
self.assertEqual(cpvm_response.state, 'Running',
"Check whether CPVM is running or not")
# Wait for the agent to be up
self.waitForSystemVMAgent(cpvm_response.name)
# Call above tests to ensure CPVM is properly running
self.test_02_list_cpvm_vm()
# Wait for some time before running diagnostic scripts on SSVM
# as it may take some time to start all service properly
time.sleep(int(self.services["configurableData"]["systemVmDelay"]))
self.test_04_cpvm_internals()
return
def checkRunningState():
if not ssvm_type:
response = list_ssvms(self.apiclient, id=ssvm.id)
else:
response = list_ssvms(self.apiclient,
zoneid=self.zone.id,
systemvmtype=ssvm_type)
if isinstance(response, list):
ssvm_response = response[0]
return ssvm_response.state == 'Running', ssvm_response
return False, None
def test_06_ping_in_cpvm_failure(self):
'''
Test Ping command execution in CPVM
'''
# Validate the following:
# 1. Ping command is executed remotely on CPVM
# 2. Validate Ping command execution with a non-existent/pingable IP address
if self.hypervisor.lower() == 'simulator':
raise self.skipTest(
"Skipping negative test case for Simulator hypervisor")
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
)
self.assertEqual(isinstance(list_ssvm_response, list), True,
'Check list response returns a valid list')
cpvm = list_ssvm_response[0]
self.debug('Setting up CPVM with ID %s' % cpvm.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = cpvm.id
cmd.ipaddress = '192.0.2.2'
cmd.type = 'ping'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertNotEqual(
'0', cmd_response.exitcode,
'Check diagnostics command returns a non-zero exit code')
def test_10_reboot_cpvm_forced(self):
"""Test force reboot CPVM
"""
list_cpvm_response = list_ssvms(self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_cpvm_response, list), True,
"Check list response returns a valid list")
cpvm_response = list_cpvm_response[0]
hosts = list_hosts(self.apiclient, id=cpvm_response.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list response returns a valid list")
self.debug("Force rebooting CPVM: %s" % cpvm_response.id)
cmd = rebootSystemVm.rebootSystemVmCmd()
cmd.id = cpvm_response.id
cmd.forced = True
self.apiclient.rebootSystemVm(cmd)
cpvm_response = self.checkForRunningSystemVM(cpvm_response)
self.debug("CPVM state: %s" % cpvm_response.state)
self.assertEqual('Running', str(cpvm_response.state),
"Check whether CPVM is running or not")
# Wait for the agent to be up
self.waitForSystemVMAgent(cpvm_response.name)
# Call to verify cloud process is running
self.test_04_cpvm_internals()
def test_12_traceroute_in_cpvm(self):
'''
Test Traceroute command execution in CPVMM
'''
# Validate the following:
# 1. Traceroute command is executed remotely on CPVM
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
'Check list response returns a valid list'
)
cpvm = list_cpvm_response[0]
self.debug('Setting up CPVMM with ID %s' % cpvm.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = cpvm.id
cmd.ipaddress = '8.8.4.4'
cmd.type = 'traceroute'
cmd.params = '-m 10'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertEqual(
'0',
cmd_response.exitcode,
'Failed to run remote Traceroute in CPVM'
)
def test_09_arping_in_cpvm(self):
'''
Test Arping command execution in CPVM
'''
# Validate the following:
# 1. Arping command is executed remotely on CPVM
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
'Check list response returns a valid list'
)
cpvm = list_cpvm_response[0]
self.debug('Setting up CPVM with ID %s' % cpvm.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = cpvm.id
cmd.ipaddress = cpvm.gateway
cmd.type = 'arping'
cmd.params = '-I eth2'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertEqual(
'0',
cmd_response.exitcode,
'Failed to run remote Arping in CPVM'
)
def test_03_ping_in_ssvm_success(self):
'''
Test Ping command execution in SSVM
'''
# Validate the following:
# 1. Ping command is executed remotely on SSVM
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
'Check list response returns a valid list'
)
ssvm = list_ssvm_response[0]
self.debug('Setting up SSVM with ID %s' % ssvm.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = ssvm.id
cmd.ipaddress = '8.8.8.8'
cmd.type = 'ping'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertEqual(
'0',
cmd_response.exitcode,
'Failed to run remote Ping in SSVM'
)
def test_09_arping_in_cpvm(self):
'''
Test Arping command execution in CPVM
'''
# Validate the following:
# 1. Arping command is executed remotely on CPVM
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
'Check list response returns a valid list'
)
cpvm = list_cpvm_response[0]
self.debug('Setting up CPVM with ID %s' % cpvm.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = cpvm.id
cmd.ipaddress = cpvm.gateway
cmd.type = 'arping'
cmd.params = '-I eth2'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertEqual(
'0',
cmd_response.exitcode,
'Failed to run remote Arping in CPVM'
)
def test_03_ping_in_ssvm_success(self):
'''
Test Ping command execution in SSVM
'''
# Validate the following:
# 1. Ping command is executed remotely on SSVM
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
'Check list response returns a valid list'
)
ssvm = list_ssvm_response[0]
self.debug('Setting up SSVM with ID %s' % ssvm.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = ssvm.id
cmd.ipaddress = '8.8.8.8'
cmd.type = 'ping'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertEqual(
'0',
cmd_response.exitcode,
'Failed to run remote Ping in SSVM'
)
def _disable_zone_and_delete_system_vms(self, virtual_router, verify_managed_system_vm_deleted=True):
self.zone.update(self.apiClient, id=self.zone.id, allocationstate="Disabled")
if virtual_router is not None:
Router.destroy(self.apiClient, virtual_router.id)
if verify_managed_system_vm_deleted:
cs_root_volume = self._get_root_volume_for_system_vm(virtual_router.id, 'Expunged')
self._verify_managed_system_vm_deleted(cs_root_volume.name)
# list_ssvms lists the secondary storage VM and the console proxy VM
system_vms = list_ssvms(self.apiClient)
for system_vm in system_vms:
destroy_ssvm_cmd = destroySystemVm.destroySystemVmCmd()
destroy_ssvm_cmd.id = system_vm.id
self.apiClient.destroySystemVm(destroy_ssvm_cmd)
if verify_managed_system_vm_deleted:
cs_root_volume = self._get_root_volume_for_system_vm(system_vm.id, 'Expunged')
self._verify_managed_system_vm_deleted(cs_root_volume.name)
def test_12_traceroute_in_cpvm(self):
'''
Test Traceroute command execution in CPVMM
'''
# Validate the following:
# 1. Traceroute command is executed remotely on CPVM
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
'Check list response returns a valid list'
)
cpvm = list_cpvm_response[0]
self.debug('Setting up CPVMM with ID %s' % cpvm.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = cpvm.id
cmd.ipaddress = '8.8.4.4'
cmd.type = 'traceroute'
cmd.params = '-m 5'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertEqual(
'0',
cmd_response.exitcode,
'Failed to run remote Traceroute in CPVM'
)
def test_15_retrieve_ssvm_default_files(self):
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
'Check list response returns a valid list'
)
ssvm = list_ssvm_response[0]
self.debug('Setting up SSVM with ID %s' % ssvm.id)
cmd = getDiagnosticsData.getDiagnosticsDataCmd()
cmd.targetid = ssvm.id
response = self.apiclient.getDiagnosticsData(cmd)
is_valid_url = self.check_url(response.url)
self.assertEqual(
True,
is_valid_url,
msg="Failed to create valid download url response"
)
def test_18_retrieve_cpvm_single_file(self):
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
'Check list response returns a valid list'
)
cpvm = list_cpvm_response[0]
self.debug('Setting up CPVM with ID %s' % cpvm.id)
cmd = getDiagnosticsData.getDiagnosticsDataCmd()
cmd.targetid = cpvm.id
cmd.type = "/var/log/cloud.log"
response = self.apiclient.getDiagnosticsData(cmd)
is_valid_url = self.check_url(response.url)
self.assertEqual(
True,
is_valid_url,
msg="Failed to create valid download url response"
)
def checkForRunningSSVM():
new_list_ssvm_response = list_ssvms(
self.apiclient,
id=ssvm.id
)
if isinstance(new_list_ssvm_response, list):
return new_list_ssvm_response[0].state == 'Running', None
def _check_number_of_running_system_vms(self, expected_number_of_system_vms):
# list_ssvms lists the secondary storage VM and the console proxy VM
system_vms = list_ssvms(self.apiClient, state="Running")
if system_vms is not None and len(system_vms) == expected_number_of_system_vms:
return True, system_vms
return False, "Timed out waiting for running system VMs"
def checkRunningState():
if not ssvm_type:
response = list_ssvms(
self.apiclient,
id=ssvm.id
)
else:
response = list_ssvms(
self.apiclient,
zoneid=self.zone.id,
systemvmtype=ssvm_type
)
if isinstance(response, list):
ssvm_response = response[0]
return ssvm_response.state == 'Running', ssvm_response
return False, None
def test_04_cpvm_internals(self):
"""Test CPVM Internals"""
# Validate the following
# 1. test that telnet access on 8250 is available to
# the management server for the CPVM
# 2. No telnet access, test FAIL
# 3. Service cloud status should report cloud agent status to be
# running
list_cpvm_response = list_ssvms(self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_cpvm_response, list), True,
"Check list response returns a valid list")
cpvm = list_cpvm_response[0]
hosts = list_hosts(self.apiclient, id=cpvm.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list response returns a valid list")
host = hosts[0]
try:
telnetlib.Telnet(str(self.apiclient.connection.mgtSvr), '8250')
self.debug("Telnet management server (IP: %s)" %
self.apiclient.connection.mgtSvr)
except Exception as e:
self.fail("Telnet Access failed for %s: %s" %
(self.apiclient.connection.mgtSvr, e))
self.debug("Checking cloud process status")
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
result = get_process_status(self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
cpvm.privateip,
"service cloud status",
hypervisor=self.hypervisor)
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(host.ipaddress, 22, host.user,
host.passwd, cpvm.linklocalip,
"service cloud status")
except KeyError:
self.skipTest("Marvin configuration has no host\
credentials to check router services")
res = str(result)
self.debug("Cloud Process status: %s" % res)
self.assertEqual(res.count("is running"), 1,
"Check cloud service is running or not")
return
def test_06_stop_cpvm(self):
"""Test stop CPVM
"""
# Validate the following
# 1. The CPVM should go to stop state
# 2. After a brief delay of say one minute, the SSVM should be
# restarted once again and return to Running state with previous
# two test cases still passing
# 3. If either of the two above steps fail the test is a failure
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
"Check list response returns a valid list"
)
cpvm = list_cpvm_response[0]
hosts = list_hosts(
self.apiclient,
id=cpvm.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
self.debug("Stopping CPVM: %s" % cpvm.id)
cmd = stopSystemVm.stopSystemVmCmd()
cmd.id = cpvm.id
self.apiclient.stopSystemVm(cmd)
cpvm_response = self.checkForRunningSystemVM(cpvm)
self.debug("CPVM state after debug: %s" % cpvm_response.state)
self.assertEqual(
cpvm_response.state,
'Running',
"Check whether CPVM is running or not"
)
# Wait for the agent to be up
self.waitForSystemVMAgent(cpvm_response.name)
# Call above tests to ensure CPVM is properly running
self.test_02_list_cpvm_vm()
self.test_04_cpvm_internals()
def test_06_stop_cpvm(self):
"""Test stop CPVM
"""
# Validate the following
# 1. The CPVM should go to stop state
# 2. After a brief delay of say one minute, the SSVM should be
# restarted once again and return to Running state with previous
# two test cases still passing
# 3. If either of the two above steps fail the test is a failure
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
"Check list response returns a valid list"
)
cpvm = list_cpvm_response[0]
hosts = list_hosts(
self.apiclient,
id=cpvm.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
self.debug("Stopping CPVM: %s" % cpvm.id)
cmd = stopSystemVm.stopSystemVmCmd()
cmd.id = cpvm.id
self.apiclient.stopSystemVm(cmd)
cpvm_response = self.checkForRunningSystemVM(cpvm)
self.debug("CPVM state after debug: %s" % cpvm_response.state)
self.assertEqual(
cpvm_response.state,
'Running',
"Check whether CPVM is running or not"
)
# Wait for the agent to be up
self.waitForSystemVMAgent(cpvm_response.name)
# Call above tests to ensure CPVM is properly running
self.test_02_list_cpvm_vm()
self.test_04_cpvm_internals()
def wait_for_svm_state(self, vmid, state, timeout, sleep_interval):
while timeout > 0:
list_svm_response = list_ssvms(self.apiclient, id=vmid)
if isinstance(list_svm_response, list) and list_svm_response[0].state == state:
self.logger.debug("SVM %s %s" % (vmid, state))
break
time.sleep(sleep_interval)
timeout -= sleep_interval
if timeout <= 0 and isinstance(list_svm_response, list) and list_svm_response[0].state != state:
self.fail("Timeout reached while waiting for system VM to be %s, actual state is %s" % (state, list_svm_response[0].state))
def test_09_reboot_ssvm_forced(self):
"""Test force reboot SSVM
"""
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
"Check list response returns a valid list"
)
ssvm_response = list_ssvm_response[0]
hosts = list_hosts(
self.apiclient,
id=ssvm_response.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
self.debug("Force rebooting SSVM: %s" % ssvm_response.id)
cmd = rebootSystemVm.rebootSystemVmCmd()
cmd.id = ssvm_response.id
cmd.forced = True
self.apiclient.rebootSystemVm(cmd)
ssvm_response = self.checkForRunningSystemVM(ssvm_response)
self.debug("SSVM State: %s" % ssvm_response.state)
self.assertEqual(
'Running',
str(ssvm_response.state),
"Check whether SSVM is running or not"
)
# Wait for the agent to be up
self.waitForSystemVMAgent(ssvm_response.name)
# Wait until NFS stores mounted before running the script
time.sleep(90)
# Call to verify cloud process is running
self.test_03_ssvm_internals()
def test_07_reboot_ssvm(self):
"""Test reboot SSVM
"""
# Validate the following
# 1. The SSVM should go to stop and return to Running state
# 2. SSVM's public-ip and private-ip must remain the same
# before and after reboot
# 3. The cloud process should still be running within the SSVM
list_ssvm_response = list_ssvms(self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_ssvm_response, list), True,
"Check list response returns a valid list")
ssvm_response = list_ssvm_response[0]
hosts = list_hosts(self.apiclient, id=ssvm_response.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list response returns a valid list")
# Store the public & private IP values before reboot
old_public_ip = ssvm_response.publicip
old_private_ip = ssvm_response.privateip
self.debug("Rebooting SSVM: %s" % ssvm_response.id)
cmd = rebootSystemVm.rebootSystemVmCmd()
cmd.id = ssvm_response.id
self.apiclient.rebootSystemVm(cmd)
ssvm_response = self.checkForRunningSystemVM(ssvm_response)
self.debug("SSVM State: %s" % ssvm_response.state)
self.assertEqual('Running', str(ssvm_response.state),
"Check whether CPVM is running or not")
self.assertEqual(
ssvm_response.publicip, old_public_ip,
"Check Public IP after reboot with that of before reboot")
# Private IP Address of System VMs are allowed to change after reboot - CLOUDSTACK-7745
# Wait for the agent to be up
self.waitForSystemVMAgent(ssvm_response.name)
# Wait until NFS stores mounted before running the script
time.sleep(30)
# Call to verify cloud process is running
self.test_03_ssvm_internals()
def test_09_destroy_ssvm(self):
"""Test destroy SSVM
"""
# Validate the following
# 1. SSVM should be completely destroyed and a new one will spin up
# 2. listSystemVMs will show a different name for the
# systemVM from what it was before
# 3. new SSVM will have a public/private and link-local-ip
# 4. cloud process within SSVM must be up and running
list_ssvm_response = list_ssvms(self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_ssvm_response, list), True,
"Check list response returns a valid list")
ssvm_response = list_ssvm_response[0]
old_name = ssvm_response.name
self.debug("Destroying SSVM: %s" % ssvm_response.id)
cmd = destroySystemVm.destroySystemVmCmd()
cmd.id = ssvm_response.id
self.apiclient.destroySystemVm(cmd)
ssvm_response = self.checkForRunningSystemVM(ssvm_response,
'secondarystoragevm')
# Verify Name, Public IP, Private IP and Link local IP
# for newly created SSVM
self.assertNotEqual(ssvm_response.name, old_name,
"Check SSVM new name with name of destroyed SSVM")
self.assertEqual(hasattr(ssvm_response, 'privateip'), True,
"Check whether SSVM has private IP field")
self.assertEqual(hasattr(ssvm_response, 'linklocalip'), True,
"Check whether SSVM has link local IP field")
self.assertEqual(hasattr(ssvm_response, 'publicip'), True,
"Check whether SSVM has public IP field")
# Wait for the agent to be up
self.waitForSystemVMAgent(ssvm_response.name)
# Call to verify cloud process is running
self.test_03_ssvm_internals()
def test_stop_svm(self, svm_type):
# Validate the following
# 1. The SVM should go to stop state
# 2. The SVM should be restarted and return to Running state with the checks of the previous two test cases still passing
# 3. If either of the two above steps fail the test is a failure
list_svm_response = list_ssvms(
self.apiclient,
systemvmtype=svm_type,
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_svm_response, list),
True,
"Check list response returns a valid list"
)
svm = list_svm_response[0]
hosts = list_hosts(
self.apiclient,
id=svm.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
self.logger.debug("Stopping System VM: %s" % svm.id)
cmd = stopSystemVm.stopSystemVmCmd()
cmd.id = svm.id
cmd.forced = "true"
self.apiclient.stopSystemVm(cmd)
self.wait_for_svm_state(svm.id, 'Stopped', self.services["timeout"], self.services["sleep"])
self.logger.debug("Starting System VM: %s" % svm.id)
cmd = startSystemVm.startSystemVmCmd()
cmd.id = svm.id
self.apiclient.startSystemVm(cmd)
self.wait_for_svm_state(svm.id, 'Running', self.services["timeout"], self.services["sleep"])
self.wait_for_system_vm_agent(svm.name)
return
def checkAllVmsRunningOnHost(self, hostId):
listVms1 = VirtualMachine.list(self.apiclient, hostid=hostId)
if (listVms1 is not None):
self.logger.debug('Vms found to test all running = {} '.format(
len(listVms1)))
for vm in listVms1:
if (vm.state != "Running"):
self.logger.debug(
'VirtualMachine on Host with id = {} is in {}'.format(
vm.id, vm.state))
return (False, None)
response = list_ssvms(self.apiclient, hostid=hostId)
if isinstance(response, list):
for systemvm in response:
if systemvm.state != 'Running':
self.logger.debug("Found not running VM {}".format(
systemvm.name))
return (False, None)
return (True, None)
def test_06_ping_in_cpvm_failure(self):
'''
Test Ping command execution in CPVM
'''
# Validate the following:
# 1. Ping command is executed remotely on CPVM
# 2. Validate Ping command execution with a non-existent/pingable IP address
if self.hypervisor.lower() == 'simulator':
raise self.skipTest("Skipping negative test case for Simulator hypervisor")
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
'Check list response returns a valid list'
)
cpvm = list_ssvm_response[0]
self.debug('Setting up CPVM with ID %s' % cpvm.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = cpvm.id
cmd.ipaddress = '192.0.2.2'
cmd.type = 'ping'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertNotEqual(
'0',
cmd_response.exitcode,
'Check diagnostics command returns a non-zero exit code'
)
def test_02_list_cpvm_vm(self):
"""Test List console proxy VMs
"""
# Validate the following:
# 1. listSystemVM (systemvmtype=consoleproxy) should return
# at least ONE CPVM per zone
# 2. The returned ConsoleProxyVM should be in Running state
# 3. listSystemVM for console proxy should list publicip, privateip
# and link-localip
# 4. The gateway programmed on the console proxy should be the same
# as the gateway returned by listZones
# 5. DNS entries must match those given for the zone
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
"Check list response returns a valid list"
)
# Verify CPVM response
self.assertNotEqual(
len(list_cpvm_response),
0,
"Check list System VMs response"
)
list_zones_response = list_zones(self.apiclient)
# Number of Console Proxy VMs = No of Zones
self.assertEqual(
isinstance(list_zones_response, list),
True,
"Check list response returns a valid list"
)
self.debug("Number of zones: %s" % len(list_zones_response))
self.debug("Number of CPVMs: %s" % len(list_cpvm_response))
self.assertEqual(
len(list_cpvm_response),
len(list_zones_response),
"Check number of CPVMs with number of zones"
)
# For each CPVM check private IP, public IP, link local IP and DNS
for cpvm in list_cpvm_response:
self.debug("CPVM state: %s" % cpvm.state)
self.assertEqual(
cpvm.state,
'Running',
"Check whether state of CPVM is running"
)
self.assertEqual(
hasattr(cpvm, 'privateip'),
True,
"Check whether CPVM has private IP field"
)
self.assertEqual(
hasattr(cpvm, 'linklocalip'),
True,
"Check whether CPVM has link local IP field"
)
self.assertEqual(
hasattr(cpvm, 'publicip'),
True,
"Check whether CPVM has public IP field"
)
# Fetch corresponding ip ranges information from listVlanIpRanges
ipranges_response = list_vlan_ipranges(
self.apiclient,
zoneid=cpvm.zoneid
)
self.assertEqual(
isinstance(ipranges_response, list),
True,
"Check list response returns a valid list"
)
# Fetch corresponding Physical Network of SSVM's Zone
listphyntwk = PhysicalNetwork.list(
self.apiclient,
zoneid=cpvm.zoneid
)
# Execute the following assertion in all zones except EIP-ELB Zones
if not (
self.zone.networktype.lower() == 'basic' and isinstance(
NetScaler.list(
self.apiclient,
physicalnetworkid=listphyntwk[0].id),
list) is True):
gatewayFound = False
for iprange in ipranges_response:
if iprange.gateway == cpvm.gateway:
gatewayFound = True
break
self.assertTrue(
gatewayFound,
"Check gateway with that of corresponding ip range"
)
# Fetch corresponding zone information from listZones
zone_response = list_zones(
self.apiclient,
id=cpvm.zoneid
)
self.assertEqual(
cpvm.dns1,
zone_response[0].dns1,
"Check DNS1 with that of corresponding zone"
)
self.assertEqual(
cpvm.dns2,
zone_response[0].dns2,
"Check DNS2 with that of corresponding zone"
)
def test_11_ss_nfs_version_on_ssvm(self):
"""Test NFS Version on Secondary Storage mounted properly on SSVM
"""
# 1) List SSVM in zone
# 2) Get id and url from mounted nfs store
# 3) Update NFS version for previous image store
# 4) Stop SSVM
# 5) Check NFS version of mounted nfs store after SSVM starts
nfs_version = self.config.nfsVersion
if nfs_version == None:
self.skipTest('No NFS version provided in test data')
#List SSVM for zone id
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id
)
self.assertNotEqual(
list_ssvm_response,
None
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
"Check list response returns a valid list"
)
self.assertEqual(
len(list_ssvm_response),
1,
"Check list System VMs response"
)
ssvm = list_ssvm_response[0]
image_stores_response = ImageStore.list(self.apiclient,zoneid=self.zone.id)
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and Hyper-V
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
ssvm.privateip,
"mount | grep 'type nfs'",
hypervisor=self.hypervisor)
for res in result:
split_res = res.split("on")
mounted_img_store_url = split_res[0].strip()
for img_store in image_stores_response:
img_store_url = str(img_store.url)
if img_store_url.startswith("nfs://"):
img_store_url = img_store_url[6:]
#Add colon after ip address to match output from mount command
first_slash = img_store_url.find('/')
img_store_url = img_store_url[0:first_slash] + ':' + img_store_url[first_slash:]
if img_store_url == mounted_img_store_url:
img_store_id = img_store.id
break
self.assertNotEqual(
img_store_id,
None,
"Check image store id mounted on SSVM"
)
#Update NFS version for image store mounted on SSVM
updateConfigurationCmd = updateConfiguration.updateConfigurationCmd()
updateConfigurationCmd.name = "secstorage.nfs.version"
updateConfigurationCmd.value = nfs_version
updateConfigurationCmd.imagestoreuuid = img_store_id
updateConfigurationResponse = self.apiclient.updateConfiguration(updateConfigurationCmd)
self.logger.debug("updated the parameter %s with value %s"%(updateConfigurationResponse.name, updateConfigurationResponse.value))
#Stop SSVM
self.debug("Stopping SSVM: %s" % ssvm.id)
cmd = stopSystemVm.stopSystemVmCmd()
cmd.id = ssvm.id
self.apiclient.stopSystemVm(cmd)
def checkForRunningSSVM():
new_list_ssvm_response = list_ssvms(
self.apiclient,
id=ssvm.id
)
if isinstance(new_list_ssvm_response, list):
return new_list_ssvm_response[0].state == 'Running', None
res, _ = wait_until(self.services["sleep"], self.services["timeout"], checkForRunningSSVM)
if not res:
self.fail("List SSVM call failed!")
new_list_ssvm_response = list_ssvms(
self.apiclient,
id=ssvm.id
)
self.assertNotEqual(
new_list_ssvm_response,
None
)
self.assertEqual(
isinstance(new_list_ssvm_response, list),
True,
"Check list response returns a valid list"
)
ssvm = new_list_ssvm_response[0]
self.debug("SSVM state after debug: %s" % ssvm.state)
self.assertEqual(
ssvm.state,
'Running',
"Check whether SSVM is running or not"
)
# Wait for the agent to be up
self.waitForSystemVMAgent(ssvm.name)
#Check NFS version on mounted image store
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
ssvm.privateip,
"mount | grep '%s'"%mounted_img_store_url,
hypervisor=self.hypervisor)
self.assertNotEqual(
result,
None
)
self.assertEqual(
len(result),
1,
"Check result length"
)
res = result[0]
mounted_nfs_version = res.split("vers=")[1][0:1]
self.assertEqual(
int(mounted_nfs_version),
int(nfs_version),
"Check mounted NFS version to be the same as provided"
)
return
def test_03_destroy_ssvm(self):
"""Test destroy SSVM
"""
# Validate the following
# 1. SSVM should be completely destroyed and a new one will spin up
# 2. listSystemVMs will show a different name for the
# systemVM from what it was before
# 3. new SSVM will have a public/private and link-local-ip
# 4. cloud process within SSVM must be up and running
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
"Check list response returns a valid list"
)
ssvm_response = list_ssvm_response[0]
old_name = ssvm_response.name
self.logger.debug("Destroying SSVM: %s" % ssvm_response.id)
cmd = destroySystemVm.destroySystemVmCmd()
cmd.id = ssvm_response.id
self.apiclient.destroySystemVm(cmd)
timeout = self.services["timeout"]
while True:
list_ssvm_response = list_ssvms(
self.apiclient,
zoneid=self.zone.id,
systemvmtype='secondarystoragevm'
)
if isinstance(list_ssvm_response, list):
if list_ssvm_response[0].state == 'Running':
break
if timeout == 0:
self.logger.debug(
"Warning: List SSVM didn't return systemvms in Running state. This is a known issue, ignoring it for now!")
return
time.sleep(self.services["sleep"])
timeout = timeout - 1
ssvm_response = list_ssvm_response[0]
# Verify Name, Public IP, Private IP and Link local IP
# for newly created SSVM
self.assertNotEqual(
ssvm_response.name,
old_name,
"Check SSVM new name with name of destroyed SSVM"
)
self.assertEqual(
hasattr(ssvm_response, 'privateip'),
True,
"Check whether SSVM has private IP field"
)
self.assertEqual(
hasattr(ssvm_response, 'linklocalip'),
True,
"Check whether SSVM has link local IP field"
)
self.assertEqual(
hasattr(ssvm_response, 'publicip'),
True,
"Check whether SSVM has public IP field"
)
# Wait for the agent to be up
self.wait_for_system_vm_agent(ssvm_response.name)
return
def test_11_ss_nfs_version_on_ssvm(self):
"""Test NFS Version on Secondary Storage mounted properly on SSVM
"""
# 1) List SSVM in zone
# 2) Get id and url from mounted nfs store
# 3) Update NFS version for previous image store
# 4) Stop SSVM
# 5) Check NFS version of mounted nfs store after SSVM starts
nfs_version = self.config.nfsVersion
if nfs_version == None:
self.skipTest('No NFS version provided in test data')
#List SSVM for zone id
list_ssvm_response = list_ssvms(self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id)
self.assertNotEqual(list_ssvm_response, None)
self.assertEqual(isinstance(list_ssvm_response, list), True,
"Check list response returns a valid list")
self.assertEqual(len(list_ssvm_response), 1,
"Check list System VMs response")
ssvm = list_ssvm_response[0]
image_stores_response = ImageStore.list(self.apiclient,
zoneid=self.zone.id)
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and Hyper-V
result = get_process_status(self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
ssvm.privateip,
"mount | grep 'type nfs'",
hypervisor=self.hypervisor)
for res in result:
split_res = res.split("on")
mounted_img_store_url = split_res[0].strip()
for img_store in image_stores_response:
img_store_url = str(img_store.url)
if img_store_url.startswith("nfs://"):
img_store_url = img_store_url[6:]
#Add colon after ip address to match output from mount command
first_slash = img_store_url.find('/')
img_store_url = img_store_url[
0:first_slash] + ':' + img_store_url[first_slash:]
if img_store_url == mounted_img_store_url:
img_store_id = img_store.id
break
self.assertNotEqual(img_store_id, None,
"Check image store id mounted on SSVM")
#Update NFS version for image store mounted on SSVM
updateConfigurationCmd = updateConfiguration.updateConfigurationCmd()
updateConfigurationCmd.name = "secstorage.nfs.version"
updateConfigurationCmd.value = nfs_version
updateConfigurationCmd.imagestoreuuid = img_store_id
updateConfigurationResponse = self.apiclient.updateConfiguration(
updateConfigurationCmd)
self.logger.debug("updated the parameter %s with value %s" %
(updateConfigurationResponse.name,
updateConfigurationResponse.value))
#Stop SSVM
self.debug("Stopping SSVM: %s" % ssvm.id)
cmd = stopSystemVm.stopSystemVmCmd()
cmd.id = ssvm.id
self.apiclient.stopSystemVm(cmd)
def checkForRunningSSVM():
new_list_ssvm_response = list_ssvms(self.apiclient, id=ssvm.id)
if isinstance(new_list_ssvm_response, list):
return new_list_ssvm_response[0].state == 'Running', None
res, _ = wait_until(self.services["sleep"], self.services["timeout"],
checkForRunningSSVM)
if not res:
self.fail("List SSVM call failed!")
new_list_ssvm_response = list_ssvms(self.apiclient, id=ssvm.id)
self.assertNotEqual(new_list_ssvm_response, None)
self.assertEqual(isinstance(new_list_ssvm_response, list), True,
"Check list response returns a valid list")
ssvm = new_list_ssvm_response[0]
self.debug("SSVM state after debug: %s" % ssvm.state)
self.assertEqual(ssvm.state, 'Running',
"Check whether SSVM is running or not")
# Wait for the agent to be up
self.waitForSystemVMAgent(ssvm.name)
#Check NFS version on mounted image store
result = get_process_status(self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
ssvm.privateip,
"mount | grep '%s'" %
mounted_img_store_url,
hypervisor=self.hypervisor)
self.assertNotEqual(result, None)
self.assertEqual(len(result), 1, "Check result length")
res = result[0]
mounted_nfs_version = res.split("vers=")[1][0:1]
self.assertEqual(
int(mounted_nfs_version), int(nfs_version),
"Check mounted NFS version to be the same as provided")
return
def checkForRunningSSVM():
new_list_ssvm_response = list_ssvms(self.apiclient, id=ssvm.id)
if isinstance(new_list_ssvm_response, list):
return new_list_ssvm_response[0].state == 'Running', None
def test_03_ssvm_internals(self):
"""Test SSVM Internals"""
# Validate the following
# 1. The SSVM check script should not return any
# WARN|ERROR|FAIL messages
# 2. If you are unable to login to the SSVM with the signed key
# then test is deemed a failure
# 3. There should be only one ""cloud"" process running within the SSVM
# 4. If no process is running/multiple process are running
# then the test is a failure
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
"Check list response returns a valid list"
)
ssvm = list_ssvm_response[0]
hosts = list_hosts(
self.apiclient,
id=ssvm.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
host = hosts[0]
self.debug("Running SSVM check script")
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
ssvm.privateip,
"/usr/local/cloud/systemvm/ssvm-check.sh |grep -e ERROR -e WARNING -e FAIL",
hypervisor=self.hypervisor)
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(
host.ipaddress,
22,
host.user,
host.passwd,
ssvm.linklocalip,
"/usr/local/cloud/systemvm/ssvm-check.sh |grep -e ERROR -e WARNING -e FAIL")
except KeyError:
self.skipTest(
"Marvin configuration has no host\
credentials to check router services")
res = str(result)
self.debug("SSVM script output: %s" % res)
self.assertEqual(
res.count("ERROR"),
1,
"Check for Errors in tests"
)
self.assertEqual(
res.count("WARNING"),
1,
"Check for warnings in tests"
)
# Check status of cloud service
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
ssvm.privateip,
"service cloud status",
hypervisor=self.hypervisor
)
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(
host.ipaddress,
22,
host.user,
host.passwd,
ssvm.linklocalip,
"service cloud status"
)
except KeyError:
self.skipTest(
"Marvin configuration has no host\
credentials to check router services")
res = str(result)
self.debug("Cloud Process status: %s" % res)
# cloud.com service (type=secstorage) is running: process id: 2346
self.assertEqual(
res.count("is running"),
1,
"Check cloud service is running or not"
)
return
def test_02_list_cpvm_vm(self):
"""Test List console proxy VMs
"""
# Validate the following:
# 1. listSystemVM (systemvmtype=consoleproxy) should return
# at least ONE CPVM per zone
# 2. The returned ConsoleProxyVM should be in Running state
# 3. listSystemVM for console proxy should list publicip, privateip
# and link-localip
# 4. The gateway programmed on the console proxy should be the same
# as the gateway returned by listZones
# 5. DNS entries must match those given for the zone
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
)
self.assertEqual(isinstance(list_cpvm_response, list), True,
"Check list response returns a valid list")
# Verify CPVM response
self.assertNotEqual(len(list_cpvm_response), 0,
"Check list System VMs response")
list_zones_response = list_zones(self.apiclient)
# Number of Console Proxy VMs = No of Zones
self.assertEqual(isinstance(list_zones_response, list), True,
"Check list response returns a valid list")
self.debug("Number of zones: %s" % len(list_zones_response))
self.debug("Number of CPVMs: %s" % len(list_cpvm_response))
self.assertEqual(len(list_cpvm_response), len(list_zones_response),
"Check number of CPVMs with number of zones")
# For each CPVM check private IP, public IP, link local IP and DNS
for cpvm in list_cpvm_response:
self.debug("CPVM state: %s" % cpvm.state)
self.assertEqual(cpvm.state, 'Running',
"Check whether state of CPVM is running")
self.assertEqual(hasattr(cpvm, 'privateip'), True,
"Check whether CPVM has private IP field")
self.assertEqual(hasattr(cpvm, 'linklocalip'), True,
"Check whether CPVM has link local IP field")
self.assertEqual(hasattr(cpvm, 'publicip'), True,
"Check whether CPVM has public IP field")
# Fetch corresponding ip ranges information from listVlanIpRanges
ipranges_response = list_vlan_ipranges(self.apiclient,
zoneid=cpvm.zoneid)
self.assertEqual(isinstance(ipranges_response, list), True,
"Check list response returns a valid list")
# Fetch corresponding Physical Network of SSVM's Zone
listphyntwk = PhysicalNetwork.list(self.apiclient,
zoneid=cpvm.zoneid)
# Execute the following assertion in all zones except EIP-ELB Zones
if not (self.zone.networktype.lower() == 'basic' and isinstance(
NetScaler.list(self.apiclient,
physicalnetworkid=listphyntwk[0].id), list)
is True):
gatewayFound = False
for iprange in ipranges_response:
if iprange.gateway == cpvm.gateway:
gatewayFound = True
break
self.assertTrue(
gatewayFound,
"Check gateway with that of corresponding ip range")
# Fetch corresponding zone information from listZones
zone_response = list_zones(self.apiclient, id=cpvm.zoneid)
self.assertEqual(cpvm.dns1, zone_response[0].dns1,
"Check DNS1 with that of corresponding zone")
self.assertEqual(cpvm.dns2, zone_response[0].dns2,
"Check DNS2 with that of corresponding zone")
def test_06_stop_cpvm(self):
"""Test stop CPVM
"""
# Validate the following
# 1. The CPVM should go to stop state
# 2. After a brief delay of say one minute, the SSVM should be
# restarted once again and return to Running state with previous
# two test cases still passing
# 3. If either of the two above steps fail the test is a failure
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
"Check list response returns a valid list"
)
cpvm = list_cpvm_response[0]
hosts = list_hosts(
self.apiclient,
id=cpvm.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
self.debug("Stopping CPVM: %s" % cpvm.id)
cmd = stopSystemVm.stopSystemVmCmd()
cmd.id = cpvm.id
self.apiclient.stopSystemVm(cmd)
timeout = self.services["timeout"]
while True:
list_cpvm_response = list_ssvms(
self.apiclient,
id=cpvm.id
)
if isinstance(list_cpvm_response, list):
if list_cpvm_response[0].state == 'Running':
break
if timeout == 0:
raise Exception("List CPVM call failed!")
time.sleep(self.services["sleep"])
timeout = timeout - 1
cpvm_response = list_cpvm_response[0]
self.debug("CPVM state after debug: %s" % cpvm_response.state)
self.assertEqual(
cpvm_response.state,
'Running',
"Check whether CPVM is running or not"
)
# Wait for the agent to be up
self.waitForSystemVMAgent(cpvm_response.name)
# Call above tests to ensure CPVM is properly running
self.test_02_list_cpvm_vm()
# Wait for some time before running diagnostic scripts on SSVM
# as it may take some time to start all service properly
time.sleep(int(self.services["configurableData"]["systemVmDelay"]))
self.test_04_cpvm_internals()
return
def test_08_reboot_cpvm(self):
"""Test reboot CPVM
"""
# Validate the following
# 1. The CPVM should go to stop and return to Running state
# 2. CPVM's public-ip and private-ip must remain
# the same before and after reboot
# 3. the cloud process should still be running within the CPVM
list_cpvm_response = list_ssvms(self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_cpvm_response, list), True,
"Check list response returns a valid list")
cpvm_response = list_cpvm_response[0]
hosts = list_hosts(self.apiclient, id=cpvm_response.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list response returns a valid list")
# Store the public & private IP values before reboot
old_public_ip = cpvm_response.publicip
old_private_ip = cpvm_response.privateip
self.debug("Rebooting CPVM: %s" % cpvm_response.id)
cmd = rebootSystemVm.rebootSystemVmCmd()
cmd.id = cpvm_response.id
self.apiclient.rebootSystemVm(cmd)
timeout = self.services["timeout"]
while True:
list_cpvm_response = list_ssvms(self.apiclient,
id=cpvm_response.id)
if isinstance(list_cpvm_response, list):
if list_cpvm_response[0].state == 'Running':
break
if timeout == 0:
raise Exception("List CPVM call failed!")
time.sleep(self.services["sleep"])
timeout = timeout - 1
cpvm_response = list_cpvm_response[0]
self.debug("CPVM state: %s" % cpvm_response.state)
self.assertEqual('Running', str(cpvm_response.state),
"Check whether CPVM is running or not")
self.assertEqual(
cpvm_response.publicip, old_public_ip,
"Check Public IP after reboot with that of before reboot")
# Private IP Address of System VMs are allowed to change after reboot - CLOUDSTACK-7745
# Wait for the agent to be up
self.waitForSystemVMAgent(cpvm_response.name)
# Wait for some time before running diagnostic scripts on SSVM
# as it may take some time to start all service properly
time.sleep(int(self.services["configurableData"]["systemVmDelay"]))
# Call to verify cloud process is running
self.test_04_cpvm_internals()
return
def test_04_cpvm_internals(self):
"""Test CPVM Internals"""
# Validate the following
# 1. test that telnet access on 8250 is available to
# the management server for the CPVM
# 2. No telnet access, test FAIL
# 3. Service cloud status should report cloud agent status to be
# running
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
"Check list response returns a valid list"
)
cpvm = list_cpvm_response[0]
hosts = list_hosts(
self.apiclient,
id=cpvm.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
host = hosts[0]
try:
telnetlib.Telnet(
str(self.apiclient.connection.mgtSvr),
'8250'
)
self.debug("Telnet management server (IP: %s)" %
self.apiclient.connection.mgtSvr)
except Exception as e:
self.fail(
"Telnet Access failed for %s: %s" %
(self.apiclient.connection.mgtSvr, e)
)
self.debug("Checking cloud process status")
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
cpvm.privateip,
"systemctl is-active cloud",
hypervisor=self.hypervisor
)
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(
host.ipaddress,
22,
host.user,
host.passwd,
cpvm.linklocalip,
"systemctl is-active cloud"
)
except KeyError:
self.skipTest(
"Marvin configuration has no host\
credentials to check router services")
res = str(result)
self.debug("Cloud Process status: %s" % res)
self.assertEqual(
res.count("active"),
1,
"Check cloud service is running or not"
)
linklocal_ip = None
# Check status of cloud service
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
linklocal_ip = cpvm.privateip
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
cpvm.privateip,
"cat /var/cache/cloud/cmdline | xargs | sed \"s/ /\\n/g\" | grep eth1ip= | sed \"s/\=/ /g\" | awk '{print $2}'",
hypervisor=self.hypervisor
)
else:
try:
linklocal_ip = cpvm.linklocalip
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(
host.ipaddress,
22,
host.user,
host.passwd,
cpvm.linklocalip,
"cat /var/cache/cloud/cmdline | xargs | sed \"s/ /\\n/g\" | grep eth0ip= | sed \"s/\=/ /g\" | awk '{print $2}'"
)
except KeyError:
self.skipTest(
"Marvin configuration has no host\
credentials to check router services")
res = result[0]
self.debug("Cached Link Local IP: %s" % res)
self.assertEqual(
linklocal_ip,
res,
"The cached Link Local should be the same as the current Link Local IP, but they are different! Current ==> %s; Cached ==> %s " % (linklocal_ip, res)
)
def test_03_ssvm_internals(self):
"""Test SSVM Internals"""
# Validate the following
# 1. The SSVM check script should not return any
# WARN|ERROR|FAIL messages
# 2. If you are unable to login to the SSVM with the signed key
# then test is deemed a failure
# 3. There should be only one ""cloud"" process running within the SSVM
# 4. If no process is running/multiple process are running
# then the test is a failure
list_ssvm_response = list_ssvms(self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_ssvm_response, list), True,
"Check list response returns a valid list")
ssvm = list_ssvm_response[0]
hosts = list_hosts(self.apiclient, id=ssvm.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list response returns a valid list")
host = hosts[0]
self.debug("Running SSVM check script")
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
ssvm.privateip,
"/usr/local/cloud/systemvm/ssvm-check.sh |grep -e ERROR -e WARNING -e FAIL",
hypervisor=self.hypervisor)
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(
host.ipaddress, 22, host.user, host.passwd,
ssvm.linklocalip,
"/usr/local/cloud/systemvm/ssvm-check.sh |grep -e ERROR -e WARNING -e FAIL"
)
except KeyError:
self.skipTest("Marvin configuration has no host\
credentials to check router services")
res = str(result)
self.debug("SSVM script output: %s" % res)
self.assertEqual(res.count("ERROR"), 1, "Check for Errors in tests")
self.assertEqual(res.count("WARNING"), 1,
"Check for warnings in tests")
# Check status of cloud service
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
result = get_process_status(self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
ssvm.privateip,
"service cloud status",
hypervisor=self.hypervisor)
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(host.ipaddress, 22, host.user,
host.passwd, ssvm.linklocalip,
"service cloud status")
except KeyError:
self.skipTest("Marvin configuration has no host\
credentials to check router services")
res = str(result)
self.debug("Cloud Process status: %s" % res)
# cloud.com service (type=secstorage) is running: process id: 2346
self.assertEqual(res.count("is running"), 1,
"Check cloud service is running or not")
linklocal_ip = None
# Check status of cloud service
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
linklocal_ip = ssvm.privateip
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
ssvm.privateip,
"cat /var/cache/cloud/cmdline | xargs | sed \"s/ /\\n/g\" | grep eth1ip= | sed \"s/\=/ /g\" | awk '{print $2}'",
hypervisor=self.hypervisor)
else:
try:
linklocal_ip = ssvm.linklocalip
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(
host.ipaddress, 22, host.user, host.passwd,
ssvm.linklocalip,
"cat /var/cache/cloud/cmdline | xargs | sed \"s/ /\\n/g\" | grep eth0ip= | sed \"s/\=/ /g\" | awk '{print $2}'"
)
except KeyError:
self.skipTest("Marvin configuration has no host\
credentials to check router services")
res = result[0]
self.debug("Cached Link Local IP: %s" % res)
self.assertEqual(
linklocal_ip, res,
"The cached Link Local should be the same as the current Link Local IP, but they are different! Current ==> %s; Cached ==> %s "
% (linklocal_ip, res))
return
def test_01_list_sec_storage_vm(self):
"""Test List secondary storage VMs
"""
# Validate the following:
# 1. listSystemVM (systemvmtype=secondarystoragevm)
# should return only ONE SSVM per zone
# 2. The returned SSVM should be in Running state
# 3. listSystemVM for secondarystoragevm should list publicip,
# privateip and link-localip
# 4. The gateway programmed on the ssvm by listSystemVm should be
# the same as the gateway returned by listVlanIpRanges
# 5. DNS entries must match those given for the zone
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
"Check list response returns a valid list"
)
# Verify SSVM response
self.assertNotEqual(
len(list_ssvm_response),
0,
"Check list System VMs response"
)
list_zones_response = list_zones(self.apiclient)
self.assertEqual(
isinstance(list_zones_response, list),
True,
"Check list response returns a valid list"
)
self.debug("Number of zones: %s" % len(list_zones_response))
self.debug("Number of SSVMs: %s" % len(list_ssvm_response))
# Number of Sec storage VMs = No of Zones
self.assertEqual(
len(list_ssvm_response),
len(list_zones_response),
"Check number of SSVMs with number of zones"
)
# For each secondary storage VM check private IP,
# public IP, link local IP and DNS
for ssvm in list_ssvm_response:
self.debug("SSVM state: %s" % ssvm.state)
self.assertEqual(
ssvm.state,
'Running',
"Check whether state of SSVM is running"
)
self.assertEqual(
hasattr(ssvm, 'privateip'),
True,
"Check whether SSVM has private IP field"
)
self.assertEqual(
hasattr(ssvm, 'linklocalip'),
True,
"Check whether SSVM has link local IP field"
)
self.assertEqual(
hasattr(ssvm, 'publicip'),
True,
"Check whether SSVM has public IP field"
)
# Fetch corresponding ip ranges information from listVlanIpRanges
ipranges_response = list_vlan_ipranges(
self.apiclient,
zoneid=ssvm.zoneid
)
self.assertEqual(
isinstance(ipranges_response, list),
True,
"Check list response returns a valid list"
)
iprange = ipranges_response[0]
# Fetch corresponding Physical Network of SSVM's Zone
listphyntwk = PhysicalNetwork.list(
self.apiclient,
zoneid=ssvm.zoneid
)
# Execute the following assertion in all zones except EIP-ELB Zones
if not (
self.zone.networktype.lower() == 'basic' and isinstance(
NetScaler.list(
self.apiclient,
physicalnetworkid=listphyntwk[0].id),
list) is True):
self.assertEqual(
ssvm.gateway,
iprange.gateway,
"Check gateway with that of corresponding ip range"
)
# Fetch corresponding zone information from listZones
zone_response = list_zones(
self.apiclient,
id=ssvm.zoneid
)
self.assertEqual(
isinstance(zone_response, list),
True,
"Check list response returns a valid list"
)
self.assertEqual(
ssvm.dns1,
zone_response[0].dns1,
"Check DNS1 with that of corresponding zone"
)
self.assertEqual(
ssvm.dns2,
zone_response[0].dns2,
"Check DNS2 with that of corresponding zone"
)
return
def test_03_ssvm_internals(self):
"""Test SSVM Internals"""
# Validate the following
# 1. The SSVM check script should not return any
# WARN|ERROR|FAIL messages
# 2. If you are unable to login to the SSVM with the signed key
# then test is deemed a failure
# 3. There should be only one ""cloud"" process running within the SSVM
# 4. If no process is running/multiple process are running
# then the test is a failure
list_ssvm_response = list_ssvms(self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_ssvm_response, list), True,
"Check list response returns a valid list")
ssvm = list_ssvm_response[0]
hosts = list_hosts(self.apiclient, id=ssvm.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list response returns a valid list")
host = hosts[0]
self.logger.debug("Running SSVM check script")
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(
host.ipaddress, 22, host.user, host.passwd, ssvm.linklocalip,
"/opt/cosmic/agent/ssvm-check.sh |grep -e ERROR -e WARNING -e FAIL"
)
except KeyError:
self.skipTest(
"Marvin configuration has no host credentials to check router services"
)
res = str(result)
self.logger.debug("SSVM script output: %s" % res)
self.assertEqual(res.count("ERROR"), 1, "Check for Errors in tests")
self.assertEqual(res.count("WARNING"), 1,
"Check for warnings in tests")
# Check status of cosmic-agent service
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(host.ipaddress, 22, host.user,
host.passwd, ssvm.linklocalip,
"systemctl status cosmic-agent")
except KeyError:
self.skipTest(
"Marvin configuration has no host credentials to check router services"
)
res = str(result)
self.logger.debug("cosmic-agent Process status: %s" % res)
# cloud.com service (type=secstorage) is running: process id: 2346
self.assertEqual(res.count("active (running)"), 1,
"Check cosmic-agent service is running or not")
linklocal_ip = None
# Check status of cloud service
try:
linklocal_ip = ssvm.linklocalip
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(
host.ipaddress, 22, host.user, host.passwd, ssvm.linklocalip,
"cat /etc/cosmic/agent/agent.properties | grep eth0ip= | cut -d= -f2"
)
except KeyError:
self.skipTest(
"Marvin configuration has no host credentials to check router services"
)
res = result[0]
self.logger.debug("Cached Link Local IP: %s" % res)
self.assertEqual(
linklocal_ip, res,
"The cached Link Local should be the same as the current Link Local IP, but they are different! Current ==> %s; Cached ==> %s "
% (linklocal_ip, res))
return
def test_04_cpvm_internals(self):
"""Test CPVM Internals"""
# Validate the following
# 1. test that telnet access on 8250 is available to
# the management server for the CPVM
# 2. No telnet access, test FAIL
# 3. Service cloud status should report cloud agent status to be
# running
list_cpvm_response = list_ssvms(self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_cpvm_response, list), True,
"Check list response returns a valid list")
cpvm = list_cpvm_response[0]
hosts = list_hosts(self.apiclient, id=cpvm.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list response returns a valid list")
host = hosts[0]
try:
telnetlib.Telnet(str(self.apiclient.connection.mgtSvr), '8250')
self.debug("Telnet management server (IP: %s)" %
self.apiclient.connection.mgtSvr)
except Exception as e:
self.fail("Telnet Access failed for %s: %s" %
(self.apiclient.connection.mgtSvr, e))
self.debug("Checking cloud process status")
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
result = get_process_status(self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
cpvm.privateip,
"systemctl is-active cloud",
hypervisor=self.hypervisor)
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(host.ipaddress, 22, host.user,
host.passwd, cpvm.linklocalip,
"systemctl is-active cloud")
except KeyError:
self.skipTest("Marvin configuration has no host\
credentials to check router services")
res = str(result)
self.debug("Cloud Process status: %s" % res)
self.assertEqual(res.count("active"), 1,
"Check cloud service is running or not")
linklocal_ip = None
# Check status of cloud service
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
linklocal_ip = cpvm.privateip
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
cpvm.privateip,
"cat /var/cache/cloud/cmdline | xargs | sed \"s/ /\\n/g\" | grep eth1ip= | sed \"s/\=/ /g\" | awk '{print $2}'",
hypervisor=self.hypervisor)
else:
try:
linklocal_ip = cpvm.linklocalip
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(
host.ipaddress, 22, host.user, host.passwd,
cpvm.linklocalip,
"cat /var/cache/cloud/cmdline | xargs | sed \"s/ /\\n/g\" | grep eth0ip= | sed \"s/\=/ /g\" | awk '{print $2}'"
)
except KeyError:
self.skipTest("Marvin configuration has no host\
credentials to check router services")
res = result[0]
self.debug("Cached Link Local IP: %s" % res)
self.assertEqual(
linklocal_ip, res,
"The cached Link Local should be the same as the current Link Local IP, but they are different! Current ==> %s; Cached ==> %s "
% (linklocal_ip, res))
def test_09_destroy_ssvm(self):
"""Test destroy SSVM
"""
# Validate the following
# 1. SSVM should be completely destroyed and a new one will spin up
# 2. listSystemVMs will show a different name for the
# systemVM from what it was before
# 3. new SSVM will have a public/private and link-local-ip
# 4. cloud process within SSVM must be up and running
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
"Check list response returns a valid list"
)
ssvm_response = list_ssvm_response[0]
old_name = ssvm_response.name
self.debug("Destroying SSVM: %s" % ssvm_response.id)
cmd = destroySystemVm.destroySystemVmCmd()
cmd.id = ssvm_response.id
self.apiclient.destroySystemVm(cmd)
ssvm_response = self.checkForRunningSystemVM(ssvm_response, 'secondarystoragevm')
# Verify Name, Public IP, Private IP and Link local IP
# for newly created SSVM
self.assertNotEqual(
ssvm_response.name,
old_name,
"Check SSVM new name with name of destroyed SSVM"
)
self.assertEqual(
hasattr(ssvm_response, 'privateip'),
True,
"Check whether SSVM has private IP field"
)
self.assertEqual(
hasattr(ssvm_response, 'linklocalip'),
True,
"Check whether SSVM has link local IP field"
)
self.assertEqual(
hasattr(ssvm_response, 'publicip'),
True,
"Check whether SSVM has public IP field"
)
# Wait for the agent to be up
self.waitForSystemVMAgent(ssvm_response.name)
# Call to verify cloud process is running
self.test_03_ssvm_internals()
def test_10_destroy_cpvm(self):
"""Test destroy CPVM
"""
# Validate the following
# 1. CPVM should be completely destroyed and a new one will spin up
# 2. listSystemVMs will show a different name for the systemVM from
# what it was before
# 3. new CPVM will have a public/private and link-local-ip
# 4. cloud process within CPVM must be up and running
list_cpvm_response = list_ssvms(self.apiclient,
systemvmtype='consoleproxy',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_cpvm_response, list), True,
"Check list response returns a valid list")
cpvm_response = list_cpvm_response[0]
old_name = cpvm_response.name
self.debug("Destroying CPVM: %s" % cpvm_response.id)
cmd = destroySystemVm.destroySystemVmCmd()
cmd.id = cpvm_response.id
self.apiclient.destroySystemVm(cmd)
timeout = self.services["timeout"]
while True:
list_cpvm_response = list_ssvms(self.apiclient,
systemvmtype='consoleproxy',
zoneid=self.zone.id)
if isinstance(list_cpvm_response, list):
if list_cpvm_response[0].state == 'Running':
break
if timeout == 0:
raise Exception("List CPVM call failed!")
time.sleep(self.services["sleep"])
timeout = timeout - 1
cpvm_response = list_cpvm_response[0]
# Verify Name, Public IP, Private IP and Link local IP
# for newly created CPVM
self.assertNotEqual(cpvm_response.name, old_name,
"Check SSVM new name with name of destroyed CPVM")
self.assertEqual(hasattr(cpvm_response, 'privateip'), True,
"Check whether CPVM has private IP field")
self.assertEqual(hasattr(cpvm_response, 'linklocalip'), True,
"Check whether CPVM has link local IP field")
self.assertEqual(hasattr(cpvm_response, 'publicip'), True,
"Check whether CPVM has public IP field")
# Wait for the agent to be up
self.waitForSystemVMAgent(cpvm_response.name)
# Wait for some time before running diagnostic scripts on SSVM
# as it may take some time to start all service properly
time.sleep(int(self.services["configurableData"]["systemVmDelay"]))
# Call to verify cloud process is running
self.test_04_cpvm_internals()
return
def test_08_reboot_cpvm(self):
"""Test reboot CPVM
"""
# Validate the following
# 1. The CPVM should go to stop and return to Running state
# 2. CPVM's public-ip and private-ip must remain
# the same before and after reboot
# 3. the cloud process should still be running within the CPVM
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
"Check list response returns a valid list"
)
cpvm_response = list_cpvm_response[0]
hosts = list_hosts(
self.apiclient,
id=cpvm_response.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
# Store the public & private IP values before reboot
old_public_ip = cpvm_response.publicip
old_private_ip = cpvm_response.privateip
self.debug("Rebooting CPVM: %s" % cpvm_response.id)
cmd = rebootSystemVm.rebootSystemVmCmd()
cmd.id = cpvm_response.id
self.apiclient.rebootSystemVm(cmd)
cpvm_response = self.checkForRunningSystemVM(cpvm_response)
self.debug("CPVM state: %s" % cpvm_response.state)
self.assertEqual(
'Running',
str(cpvm_response.state),
"Check whether CPVM is running or not"
)
self.assertEqual(
cpvm_response.publicip,
old_public_ip,
"Check Public IP after reboot with that of before reboot"
)
# Private IP Address of System VMs are allowed to change after reboot - CLOUDSTACK-7745
# Wait for the agent to be up
self.waitForSystemVMAgent(cpvm_response.name)
# Call to verify cloud process is running
self.test_04_cpvm_internals()
def test_01_list_sec_storage_vm(self):
"""Test List secondary storage VMs
"""
# Validate the following:
# 1. listSystemVM (systemvmtype=secondarystoragevm)
# should return only ONE SSVM per zone
# 2. The returned SSVM should be in Running state
# 3. listSystemVM for secondarystoragevm should list publicip,
# privateip and link-localip
# 4. The gateway programmed on the ssvm by listSystemVm should be
# the same as the gateway returned by listVlanIpRanges
# 5. DNS entries must match those given for the zone
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
)
self.assertEqual(isinstance(list_ssvm_response, list), True,
"Check list response returns a valid list")
# Verify SSVM response
self.assertNotEqual(len(list_ssvm_response), 0,
"Check list System VMs response")
list_zones_response = list_zones(self.apiclient)
self.assertEqual(isinstance(list_zones_response, list), True,
"Check list response returns a valid list")
self.debug("Number of zones: %s" % len(list_zones_response))
self.debug("Number of SSVMs: %s" % len(list_ssvm_response))
# Number of Sec storage VMs = No of Zones
self.assertEqual(len(list_ssvm_response), len(list_zones_response),
"Check number of SSVMs with number of zones")
# For each secondary storage VM check private IP,
# public IP, link local IP and DNS
for ssvm in list_ssvm_response:
self.debug("SSVM state: %s" % ssvm.state)
self.assertEqual(ssvm.state, 'Running',
"Check whether state of SSVM is running")
self.assertEqual(hasattr(ssvm, 'privateip'), True,
"Check whether SSVM has private IP field")
self.assertEqual(hasattr(ssvm, 'linklocalip'), True,
"Check whether SSVM has link local IP field")
self.assertEqual(hasattr(ssvm, 'publicip'), True,
"Check whether SSVM has public IP field")
# Fetch corresponding ip ranges information from listVlanIpRanges
ipranges_response = list_vlan_ipranges(self.apiclient,
zoneid=ssvm.zoneid)
self.assertEqual(isinstance(ipranges_response, list), True,
"Check list response returns a valid list")
iprange = ipranges_response[0]
# Fetch corresponding Physical Network of SSVM's Zone
listphyntwk = PhysicalNetwork.list(self.apiclient,
zoneid=ssvm.zoneid)
# Execute the following assertion in all zones except EIP-ELB Zones
if not (self.zone.networktype.lower() == 'basic' and isinstance(
NetScaler.list(self.apiclient,
physicalnetworkid=listphyntwk[0].id), list)
is True):
self.assertEqual(
ssvm.gateway, iprange.gateway,
"Check gateway with that of corresponding ip range")
# Fetch corresponding zone information from listZones
zone_response = list_zones(self.apiclient, id=ssvm.zoneid)
self.assertEqual(isinstance(zone_response, list), True,
"Check list response returns a valid list")
self.assertEqual(ssvm.dns1, zone_response[0].dns1,
"Check DNS1 with that of corresponding zone")
self.assertEqual(ssvm.dns2, zone_response[0].dns2,
"Check DNS2 with that of corresponding zone")
return
def test_04_cpvm_internals(self):
"""Test CPVM Internals"""
# Validate the following
# 1. test that telnet access on 8250 is available to
# the management server for the CPVM
# 2. No telnet access, test FAIL
# 3. Service cloud status should report cloud agent status to be
# running
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
"Check list response returns a valid list"
)
cpvm = list_cpvm_response[0]
hosts = list_hosts(
self.apiclient,
id=cpvm.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
host = hosts[0]
try:
telnetlib.Telnet(
str(self.apiclient.connection.mgtSvr),
'8250'
)
self.debug("Telnet management server (IP: %s)" %
self.apiclient.connection.mgtSvr)
except Exception as e:
self.fail(
"Telnet Access failed for %s: %s" %
(self.apiclient.connection.mgtSvr, e)
)
self.debug("Checking cloud process status")
if self.hypervisor.lower() in ('vmware', 'hyperv'):
# SSH into SSVMs is done via management server for Vmware and
# Hyper-V
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
cpvm.privateip,
"service cloud status",
hypervisor=self.hypervisor
)
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(
host.ipaddress,
22,
host.user,
host.passwd,
cpvm.linklocalip,
"service cloud status"
)
except KeyError:
self.skipTest(
"Marvin configuration has no host\
credentials to check router services")
res = str(result)
self.debug("Cloud Process status: %s" % res)
self.assertEqual(
res.count("is running"),
1,
"Check cloud service is running or not"
)
return
if (options.input) and (os.path.isfile(options.input)):
apiClient = obj_tc_client.getApiClient()
tmp_dict = {}
zones = Zone.list(apiClient)
if zones:
for zone in zones:
print "zone name={}, id={}".format(zone.name, zone.id)
if zone.allocationstate == 'Enabled':
print "Disable zone"
zoneCmd = updateZone.updateZoneCmd()
zoneCmd.id = zone.id
zoneCmd.allocationstate = 'Disabled'
apiClient.updateZone(zoneCmd)
ssvms = list_ssvms(apiClient)
if ssvms:
for ssvm in ssvms:
print "ssvm name={}, id={}".format(ssvm.name, ssvm.id)
print "Destroy SSVM"
cmd = destroySystemVm.destroySystemVmCmd()
cmd.id = ssvm.id
apiClient.destroySystemVm(cmd)
storages = StoragePool.list(apiClient)
if storages:
for storage in storages:
print "storage name={}, id={}".format(storage.name, storage.id)
if storage.state == 'Maintenance':
print "delete StoragePool"
cmd = deleteStoragePool.deleteStoragePoolCmd()
def test_08_reboot_cpvm(self):
"""Test reboot CPVM
"""
# Validate the following
# 1. The CPVM should go to stop and return to Running state
# 2. CPVM's public-ip and private-ip must remain
# the same before and after reboot
# 3. the cloud process should still be running within the CPVM
list_cpvm_response = list_ssvms(
self.apiclient,
systemvmtype='consoleproxy',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_cpvm_response, list),
True,
"Check list response returns a valid list"
)
cpvm_response = list_cpvm_response[0]
hosts = list_hosts(
self.apiclient,
id=cpvm_response.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
# Store the public & private IP values before reboot
old_public_ip = cpvm_response.publicip
old_private_ip = cpvm_response.privateip
self.debug("Rebooting CPVM: %s" % cpvm_response.id)
cmd = rebootSystemVm.rebootSystemVmCmd()
cmd.id = cpvm_response.id
self.apiclient.rebootSystemVm(cmd)
timeout = self.services["timeout"]
while True:
list_cpvm_response = list_ssvms(
self.apiclient,
id=cpvm_response.id
)
if isinstance(list_cpvm_response, list):
if list_cpvm_response[0].state == 'Running':
break
if timeout == 0:
raise Exception("List CPVM call failed!")
time.sleep(self.services["sleep"])
timeout = timeout - 1
cpvm_response = list_cpvm_response[0]
self.debug("CPVM state: %s" % cpvm_response.state)
self.assertEqual(
'Running',
str(cpvm_response.state),
"Check whether CPVM is running or not"
)
self.assertEqual(
cpvm_response.publicip,
old_public_ip,
"Check Public IP after reboot with that of before reboot"
)
self.assertEqual(
cpvm_response.privateip,
old_private_ip,
"Check Private IP after reboot with that of before reboot"
)
# Wait for the agent to be up
self.waitForSystemVMAgent(cpvm_response.name)
# Wait for some time before running diagnostic scripts on SSVM
# as it may take some time to start all service properly
time.sleep(int(self.services["configurableData"]["systemVmDelay"]))
# Call to verify cloud process is running
self.test_04_cpvm_internals()
return
def test_09_destroy_ssvm(self):
"""Test destroy SSVM
"""
# Validate the following
# 1. SSVM should be completely destroyed and a new one will spin up
# 2. listSystemVMs will show a different name for the
# systemVM from what it was before
# 3. new SSVM will have a public/private and link-local-ip
# 4. cloud process within SSVM must be up and running
list_ssvm_response = list_ssvms(self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id)
self.assertEqual(isinstance(list_ssvm_response, list), True,
"Check list response returns a valid list")
ssvm_response = list_ssvm_response[0]
old_name = ssvm_response.name
self.logger.debug("Destroying SSVM: %s" % ssvm_response.id)
cmd = destroySystemVm.destroySystemVmCmd()
cmd.id = ssvm_response.id
self.apiclient.destroySystemVm(cmd)
timeout = self.services["timeout"]
while True:
list_ssvm_response = list_ssvms(self.apiclient,
zoneid=self.zone.id,
systemvmtype='secondarystoragevm')
if isinstance(list_ssvm_response, list):
if list_ssvm_response[0].state == 'Running':
break
if timeout == 0:
self.logger.debug(
"Warning: List SSVM didn't return systemvms in Running state. This is a known issue, ignoring it for now!"
)
return
time.sleep(self.services["sleep"])
timeout = timeout - 1
ssvm_response = list_ssvm_response[0]
# Verify Name, Public IP, Private IP and Link local IP
# for newly created SSVM
self.assertNotEqual(ssvm_response.name, old_name,
"Check SSVM new name with name of destroyed SSVM")
self.assertEqual(hasattr(ssvm_response, 'privateip'), True,
"Check whether SSVM has private IP field")
self.assertEqual(hasattr(ssvm_response, 'linklocalip'), True,
"Check whether SSVM has link local IP field")
self.assertEqual(hasattr(ssvm_response, 'publicip'), True,
"Check whether SSVM has public IP field")
# Wait for the agent to be up
self.wait_for_system_vm_agent(ssvm_response.name)
# Wait for some time before running diagnostic scripts on SSVM
# as it may take some time to start all service properly
time.sleep(int(self.services["configurableData"]["systemVmDelay"]))
# Call to verify cloud process is running
self.test_03_ssvm_internals()
return
def test_09_destroy_ssvm(self):
"""Test destroy SSVM
"""
# Validate the following
# 1. SSVM should be completely destroyed and a new one will spin up
# 2. listSystemVMs will show a different name for the
# systemVM from what it was before
# 3. new SSVM will have a public/private and link-local-ip
# 4. cloud process within SSVM must be up and running
list_ssvm_response = list_ssvms(
self.apiclient,
systemvmtype='secondarystoragevm',
state='Running',
zoneid=self.zone.id
)
self.assertEqual(
isinstance(list_ssvm_response, list),
True,
"Check list response returns a valid list"
)
ssvm_response = list_ssvm_response[0]
old_name = ssvm_response.name
self.debug("Destroying SSVM: %s" % ssvm_response.id)
cmd = destroySystemVm.destroySystemVmCmd()
cmd.id = ssvm_response.id
self.apiclient.destroySystemVm(cmd)
timeout = self.services["timeout"]
while True:
list_ssvm_response = list_ssvms(
self.apiclient,
zoneid=self.zone.id,
systemvmtype='secondarystoragevm'
)
if isinstance(list_ssvm_response, list):
if list_ssvm_response[0].state == 'Running':
break
if timeout == 0:
raise Exception("List SSVM call failed!")
time.sleep(self.services["sleep"])
timeout = timeout - 1
ssvm_response = list_ssvm_response[0]
# Verify Name, Public IP, Private IP and Link local IP
# for newly created SSVM
self.assertNotEqual(
ssvm_response.name,
old_name,
"Check SSVM new name with name of destroyed SSVM"
)
self.assertEqual(
hasattr(ssvm_response, 'privateip'),
True,
"Check whether SSVM has private IP field"
)
self.assertEqual(
hasattr(ssvm_response, 'linklocalip'),
True,
"Check whether SSVM has link local IP field"
)
self.assertEqual(
hasattr(ssvm_response, 'publicip'),
True,
"Check whether SSVM has public IP field"
)
# Wait for the agent to be up
self.waitForSystemVMAgent(ssvm_response.name)
# Wait for some time before running diagnostic scripts on SSVM
# as it may take some time to start all service properly
time.sleep(int(self.services["configurableData"]["systemVmDelay"]))
# Call to verify cloud process is running
self.test_03_ssvm_internals()
return
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,
)
