def test_vm_nic_adapter_vmxnet3(self):
"""
# 1. Register a template for VMware with nicAdapter vmxnet3
# 2. Deploy a VM using this template
# 3. Create an isolated network
# 4. Add network to VM
# 5. Verify that the NIC adapter for VM for both the nics
# is vmxnet3
"""
if self.hypervisor.lower() not in ["vmware"]:
self.skipTest("This test case is written specifically\
for Vmware hypervisor")
# Register a private template in the account with nic adapter vmxnet3
template = Template.register(
self.userapiclient,
self.testdata["configurableData"]["vmxnet3template"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
details=[{"nicAdapter": self.testdata["configurableData"]["vmxnet3template"]["nicadapter"]}]
)
self.cleanup.append(template)
template.download(self.apiclient)
templates = Template.list(
self.userapiclient,
listall=True,
id=template.id,
templatefilter="self")
self.assertEqual(
validateList(templates)[0],
PASS,
"Templates list validation failed")
self.testdata["virtual_machine"]["zoneid"] = self.zone.id
self.testdata["virtual_machine"]["template"] = template.id
virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
isolated_network = Network.create(
self.apiclient,
self.testdata["isolated_network"],
self.account.name,
self.account.domainid,
networkofferingid=self.isolated_network_offering.id)
virtual_machine.add_nic(self.apiclient, isolated_network.id)
# TODO: Add steps to check the Nic Adapter type in VCenter
# using VCenter APIs
return
def registerTemplate(self, inProject=False):
"""Register and download template by default in the account/domain,
in project if stated so"""
try:
builtin_info = get_builtin_template_info(self.apiclient, self.zone.id)
self.services["template_2"]["url"] = builtin_info[0]
self.services["template_2"]["hypervisor"] = builtin_info[1]
self.services["template_2"]["format"] = builtin_info[2]
template = Template.register(self.apiclient,
self.services["template_2"],
zoneid=self.zone.id,
account=self.child_do_admin.name if not inProject else None,
domainid=self.child_do_admin.domainid if not inProject else None,
projectid=self.project.id if inProject else None)
template.download(self.apiclient)
templates = Template.list(self.apiclient,
templatefilter=\
self.services["template_2"]["templatefilter"],
id=template.id)
self.assertEqual(validateList(templates)[0], PASS,\
"templates list validation failed")
self.templateSize = (templates[0].size / (1024**3))
except Exception as e:
return [FAIL, e]
return [PASS, None]
def test_02_create_template_snapshot(self, value):
"""Test create snapshot and templates from volume
# Validate the following
1. Create root domain/child domain admin account
2. Deploy VM in the account
3. Create snapshot from the virtual machine root volume
4. Create template from the snapshot
5. Verify that the secondary storage count of the account equals
the size of the template"""
response = self.setupAccount(value)
self.assertEqual(response[0], PASS, response[1])
self.virtualMachine = VirtualMachine.create(
self.api_client,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
)
self.assertNotEqual(self.virtualMachine, FAILED, "VM deployment failed")
apiclient = self.testClient.getUserApiClient(UserName=self.account.name, DomainName=self.account.domain)
self.assertNotEqual(apiclient, FAILED, "Failed to create api client for account: %s" % self.account.name)
try:
self.virtualMachine.stop(apiclient)
except Exception as e:
self.fail("Failed to stop instance: %s" % e)
self.debug("Creating snapshot from ROOT volume: %s" % self.virtualMachine.name)
response = createSnapshotFromVirtualMachineVolume(apiclient, self.account, self.virtualMachine.id)
self.assertEqual(response[0], PASS, response[1])
snapshot = response[1]
snapshotSize = snapshot.physicalsize / (1024 ** 3)
try:
template = Template.create_from_snapshot(apiclient, snapshot=snapshot, services=self.services["template_2"])
except Exception as e:
self.fail("Failed to create template: %s" % e)
templates = Template.list(
apiclient, templatefilter=self.services["template_2"]["templatefilter"], id=template.id
)
self.assertEqual(validateList(templates)[0], PASS, "templates list validation failed")
templateSize = templates[0].size / (1024 ** 3)
expectedSecondaryStorageCount = int(templateSize + snapshotSize)
response = matchResourceCount(
self.apiclient,
expectedSecondaryStorageCount,
resourceType=RESOURCE_SECONDARY_STORAGE,
accountid=self.account.id,
)
self.assertEqual(response[0], PASS, response[1])
return
def test_es_1863_register_template_s3_domain_admin_user(self):
"""
@Desc: Test whether cloudstack allows Domain admin or user
to register a template using S3/Swift object store.
@Steps:
Step1: create a Domain and users in it.
Step2: Register a template as Domain admin.
Step3: Register a template as Domain user.
Step4: Template should be registered successfully.
"""
# Step1: create a Domain and users in it.
self.newdomain = Domain.create(self.apiClient,
self.services["domain"])
# create account in the domain
self.account_domain = Account.create(
self.apiClient,
self.services["account"],
domainid=self.newdomain.id
)
self.cleanup.append(self.account_domain)
self.cleanup.append(self.newdomain)
# Getting authentication for user in newly created Account in domain
self.domain_user = self.account_domain.user[0]
self.domain_userapiclient = self.testClient.getUserApiClient(
self.domain_user.username, self.newdomain.name
)
# Step2: Register a template as Domain admin.
self.services["templateregister"]["ostype"] = self.services["ostype"]
self.domain_template = Template.register(
self.apiClient,
self.services["templateregister"],
zoneid=self.zone.id,
account=self.account_domain.name,
domainid=self.newdomain.id,
hypervisor=self.hypervisor
)
# Wait for template to download
self.domain_template.download(self.api_client)
# Wait for template status to be changed across
time.sleep(60)
# Step3: Register a template as Domain user.
self.domain_user_template = Template.register(
self.domain_userapiclient,
self.services["templateregister"],
zoneid=self.zone.id,
account=self.account_domain.name,
domainid=self.newdomain.id,
hypervisor=self.hypervisor
)
# Wait for template to download
self.domain_user_template.download(self.api_client)
# Wait for template status to be changed across
time.sleep(60)
# TODO: Step4: Template should be registered successfully.
return
def test_listtemplate(self):
# Register template under one domain admin(root/domain1->account 1)
template_register = Template.register(
self.apiclient,
self.testdata["privatetemplate"],
zoneid=self.zone.id,
hypervisor=self.hypervisor,
account=self.account1.name,
domainid=self.domain1.id)
template_register.download(self.apiclient)
self.download(self.apiclient, template_register.id)
listtemplate = Template.list(
self.apiclient,
zoneid=self.zone.id,
hypervisor=self.hypervisor,
account=self.account2.name,
domainid=self.account2.domainid,
templatefilter="executable")
self.assertEqual(
listtemplate,
None,
"Check templates are not listed - CLOUDSTACK-10149"
)
return
def test_01_create_template(self):
"""Test create public & private template
"""
# Validate the following:
# 1. database (vm_template table) should be updated
# with newly created template
# 2. UI should show the newly added template
# 3. ListTemplates API should show the newly added template
#Create template from Virtual machine and Volume ID
template = Template.create(
self.apiclient,
self.services["template"],
self.volume.id,
account=self.account.name,
domainid=self.account.domainid
)
self.cleanup.append(template)
self.debug("Created template with ID: %s" % template.id)
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["templatefilter"],
id=template.id
)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
#Verify template response to check whether template added successfully
self.assertNotEqual(
len(list_template_response),
0,
"Check template available in List Templates"
)
template_response = list_template_response[0]
self.assertEqual(
template_response.displaytext,
self.services["template"]["displaytext"],
"Check display text of newly created template"
)
name = template_response.name
self.assertEqual(
name.count(self.services["template"]["name"]),
1,
"Check name of newly created template"
)
self.assertEqual(
template_response.ostypeid,
self.services["template"]["ostypeid"],
"Check osTypeID of newly created template"
)
return
def test_01_register_template(self, value):
"""Test register template
# Validate the following:
1. Create a root domain admin/ child domain admin account
2. Register and download a template according to hypervisor type
3. Verify that the template is listed
4. Verify that the secondary storage count for the account equals the size
of the template
5. Delete the template
6. Verify that the secondary storage resource count of the account equals 0
"""
response = self.setupAccount(value)
self.assertEqual(response[0], PASS, response[1])
builtin_info = get_builtin_template_info(self.apiclient, self.zone.id)
self.services["template_2"]["url"] = builtin_info[0]
self.services["template_2"]["hypervisor"] = builtin_info[1]
self.services["template_2"]["format"] = builtin_info[2]
try:
template = Template.register(self.apiclient,
self.services["template_2"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
hypervisor=self.hypervisor)
template.download(self.apiclient)
except Exception as e:
self.fail("Failed to register template: %s" % e)
templates = Template.list(self.apiclient,
templatefilter=\
self.services["template_2"]["templatefilter"],
id=template.id)
self.assertEqual(validateList(templates)[0],PASS,\
"templates list validation failed")
templateSize = (templates[0].size / (1024**3))
expectedCount = templateSize
response = matchResourceCount(
self.apiclient, expectedCount,
RESOURCE_SECONDARY_STORAGE,
accountid=self.account.id)
self.assertEqual(response[0], PASS, response[1])
try:
template.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete template: %s" % e)
expectedCount = 0
response = matchResourceCount(
self.apiclient, expectedCount,
RESOURCE_SECONDARY_STORAGE,
accountid=self.account.id)
self.assertEqual(response[0], PASS, response[1])
return
def get_builtin_template_info(apiclient, zoneid):
"""Returns hypervisor specific infor for templates"""
list_template_response = Template.list(apiclient, templatefilter="featured", zoneid=zoneid)
for b_template in list_template_response:
if b_template.templatetype == "BUILTIN":
break
extract_response = Template.extract(apiclient, b_template.id, "HTTP_DOWNLOAD", zoneid)
return extract_response.url, b_template.hypervisor, b_template.format
def test_03_delete_template(self):
"""Test Delete template
"""
# Validate the following:
# 1. Create a template and verify it is shown in list templates response
# 2. Delete the created template and again verify list template response
# Verify template response for updated attributes
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["template"]["templatefilter"],
id=self.template.id,
zoneid=self.zone.id)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check for list template response return valid list"
)
self.assertNotEqual(
len(list_template_response),
0,
"Check template available in List Templates"
)
template_response = list_template_response[0]
self.assertEqual(
template_response.id,
self.template.id,
"Template id %s in the list is not matching with created template id %s" %
(template_response.id, self.template.id)
)
self.debug("Deleting template: %s" % self.template)
# Delete the template
self.template.delete(self.apiclient)
self.debug("Delete template: %s successful" % self.template)
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["template"]["templatefilter"],
id=self.template.id,
zoneid=self.zone.id
)
self.assertEqual(
list_template_response,
None,
"Check template available in List Templates"
)
return
def test_04_template_from_snapshot(self):
"""Create Template from snapshot
"""
# Validate the following
# 2. Snapshot the Root disk
# 3. Create Template from snapshot
# 4. Deploy Virtual machine using this template
# 5. VM should be in running state
userapiclient = self.testClient.getUserApiClient(UserName=self.account.name, DomainName=self.account.domain)
volumes = Volume.list(userapiclient, virtualmachineid=self.virtual_machine.id, type="ROOT", listall=True)
volume = volumes[0]
self.debug("Creating a snapshot from volume: %s" % volume.id)
# Create a snapshot of volume
snapshot = Snapshot.create(userapiclient, volume.id, account=self.account.name, domainid=self.account.domainid)
self.debug("Creating a template from snapshot: %s" % snapshot.id)
# Generate template from the snapshot
template = Template.create_from_snapshot(userapiclient, snapshot, self.services["template"])
self.cleanup.append(template)
# Verify created template
templates = Template.list(
userapiclient, templatefilter=self.services["template"]["templatefilter"], id=template.id
)
self.assertNotEqual(templates, None, "Check if result exists in list item call")
self.assertEqual(templates[0].id, template.id, "Check new template id in list resources call")
self.debug("Deploying a VM from template: %s" % template.id)
# Deploy new virtual machine using template
virtual_machine = VirtualMachine.create(
userapiclient,
self.services["virtual_machine"],
templateid=template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
)
self.cleanup.append(virtual_machine)
vm_response = VirtualMachine.list(
userapiclient, id=virtual_machine.id, account=self.account.name, domainid=self.account.domainid
)
self.assertEqual(isinstance(vm_response, list), True, "Check for list VM response return valid list")
# Verify VM response to check whether VM deployment was successful
self.assertNotEqual(len(vm_response), 0, "Check VMs available in List VMs response")
vm = vm_response[0]
self.assertEqual(vm.state, "Running", "Check the state of VM created from Template")
return
def setUpClass(cls):
# We want to fail quicker if it's failure
socket.setdefaulttimeout(60)
cls.testClient = super(TestVPCRedundancy, 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.hypervisor = cls.testClient.getHypervisorInfo()
cls.template = Template.register(cls.api_client, cls.services["template"][cls.hypervisor.lower(
)], cls.zone.id, hypervisor=cls.hypervisor.lower(), domainid=cls.domain.id)
cls.template.download(cls.api_client)
if cls.template == FAILED:
assert False, "get_template() failed to return template"
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"])
cls._cleanup = [cls.service_offering, cls.template]
cls.logger = logging.getLogger('TestVPCRedundancy')
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
return
def test_03_delete_template(self):
"""Test delete template
"""
# Validate the following:
# 1. UI should not show the deleted template
# 2. database (vm_template table) should not contain deleted template
self.debug("Deleting Template ID: %s" % self.template_1.id)
self.template_1.delete(self.apiclient)
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["templatefilter"],
id=self.template_1.id,
account=self.account.name,
domainid=self.account.domainid
)
# Verify template is deleted properly using ListTemplates
self.assertEqual(
list_template_response,
None,
"Check if template exists in List Templates"
)
return
def test_08_list_system_templates(self):
"""Test System templates are not visible to normal user"""
# Validate the following
# 1. ListTemplates should not show 'SYSTEM' templates for normal user
list_template_response = Template.list(
self.apiclient,
templatefilter='featured',
account=self.user.name,
domainid=self.user.domainid
)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_template_response),
0,
"Check template available in List Templates"
)
for template in list_template_response:
self.assertNotEqual(
template.templatetype,
'SYSTEM',
"ListTemplates should not list any system templates"
)
return
def test_01_check_template_size(self):
"""TS_BUG_009-Test the size of template created from root disk
"""
# Validate the following:
# 1. Deploy new VM using the template created from Volume
# 2. VM should be in Up and Running state
#Create template from volume
template = Template.create(
self.apiclient,
self.services["template"],
self.volume.id,
account=self.account.name,
domainid=self.account.domainid
)
self.debug("Creating template with ID: %s" % template.id)
# Volume and Template Size should be same
self.assertEqual(
template.size,
self.volume.size,
"Check if size of template and volume are same"
)
return
def test_02_deploy_vm_account_limit_reached(self):
"""Test Try to deploy VM with admin account where account has used
the resources but @ domain they are available
# Validate the following
# 1. Try to register template with admin account where account has used the
# resources but @ domain they are available
# 2. Template registration should fail"""
response = self.setupAccounts()
self.assertEqual(response[0], PASS, response[1])
response = self.registerTemplate()
self.assertEqual(response[0], PASS, response[1])
expectedCount = self.templateSize
response = matchResourceCount(
self.apiclient, expectedCount,
RESOURCE_SECONDARY_STORAGE,
accountid=self.child_do_admin.id)
self.assertEqual(response[0], PASS, response[1])
accountLimit = self.templateSize
response = self.updateSecondaryStorageLimits(accountLimit=accountLimit)
self.assertEqual(response[0], PASS, response[1])
with self.assertRaises(Exception):
template = Template.register(self.apiclient,
self.services["template_2"],
zoneid=self.zone.id,
account=self.child_do_admin.name,
domainid=self.child_do_admin.domainid)
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.hypervisor = self.testClient.getHypervisorInfo()
self.dbclient = self.testClient.getDbConnection()
self.services = Services().services
self.services["virtual_machine"]["zoneid"] = self.zone.id
self.account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id)
builtin_info = get_builtin_template_info(self.apiclient, self.zone.id)
self.services["template"]["url"] = builtin_info[0]
self.services["template"]["hypervisor"] = builtin_info[1]
self.services["template"]["format"] = builtin_info[2]
# Register new template
self.template = Template.register(
self.apiclient,
self.services["template"],
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" % (self.services["template"]["format"], self.template.id)
)
try:
self.template.download(self.apiclient)
except Exception as e:
raise Exception("Template download failed: %s" % e)
self.cleanup = [self.account]
return
def test_07_list_public_templates(self):
"""Test only public templates are visible to normal user"""
# Validate the following
# 1. ListTemplates should show only 'public' templates for normal user
list_template_response = Template.list(
self.apiclient,
templatefilter='featured',
account=self.user.name,
domainid=self.user.domainid
)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_template_response),
0,
"Check template available in List Templates"
)
#Template response should list all 'public' templates
for template in list_template_response:
self.assertEqual(
template.ispublic,
True,
"ListTemplates should list only public templates"
)
return
def setUpClass(cls):
cls.logger = logging.getLogger('TestVPCSite2SiteVPN')
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
testClient = super(TestVpcSite2SiteVpn, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = Services().services
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.domain = get_domain(cls.apiclient)
cls.service_offering = ServiceOffering.create(
cls.apiclient,
cls.services["compute_offering"]
)
cls.account = Account.create(
cls.apiclient, services=cls.services["account"])
cls.hypervisor = cls.services["default_hypervisor"]
cls.logger.debug("Downloading Template: %s from: %s" % (cls.services["template"][
cls.hypervisor]["name"], cls.services["template"][cls.hypervisor]["url"]))
cls.template = Template.register(cls.apiclient, cls.services["template"][
cls.hypervisor], cls.zone.id, hypervisor=cls.hypervisor, account=cls.account.name, domainid=cls.domain.id)
cls.template.download(cls.apiclient)
if cls.template == FAILED:
assert False, "get_template() failed to return template with description %s" % cls.services[
"compute_offering"]
cls.services["virtual_machine"][
"hypervisor"] = cls.services["default_hypervisor"]
cls.cleanup = [cls.account]
def setUpClass(cls):
testClient = super(TestSnapshotRootDisk, 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.services['mode'] = cls.zone.networktype
cls.hypervisorNotSupported = False
cls.hypervisor = cls.testClient.getHypervisorInfo()
if cls.hypervisor.lower() in ['hyperv', 'lxc'] or 'kvm-centos6' in cls.testClient.getZoneForTests():
cls.hypervisorNotSupported = True
cls._cleanup = []
if not cls.hypervisorNotSupported:
macchinina = Templates().templates["macchinina"]
cls.template = Template.register(cls.apiclient, macchinina[cls.hypervisor.lower()],
cls.zone.id, hypervisor=cls.hypervisor.lower(), domainid=cls.domain.id)
cls.template.download(cls.apiclient)
if cls.template == FAILED:
assert False, "get_template() failed to return template"
cls.services["domainid"] = cls.domain.id
cls.services["small"]["zoneid"] = cls.zone.id
cls.services["templates"]["ostypeid"] = cls.template.ostypeid
cls.services["zoneid"] = cls.zone.id
# Create VMs, NAT Rules etc
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
domainid=cls.domain.id
)
cls.service_offering = ServiceOffering.create(
cls.apiclient,
cls.services["service_offerings"]["tiny"]
)
cls.virtual_machine = cls.virtual_machine_with_disk = \
VirtualMachine.create(
cls.apiclient,
cls.services["small"],
templateid=cls.template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
zoneid=cls.zone.id,
serviceofferingid=cls.service_offering.id,
mode=cls.services["mode"]
)
cls._cleanup.append(cls.virtual_machine)
cls._cleanup.append(cls.service_offering)
cls._cleanup.append(cls.account)
cls._cleanup.append(cls.template)
return
def test_Scale_VM(self):
"""
@desc:
1. Enable dynamic scaling in Global settings
2. Register an CentOS 7 tempplate(with tools) and tick dynamic scaling
3. Deploy VM with this template
4.Start the VM and try to change service offering
"""
self.hypervisor = str(get_hypervisor_type(self.api_client)).lower()
if self.hypervisor != "xenserver":
self.skipTest("This test can be run only on xenserver")
self.updateConfigurAndRestart("enable.dynamic.scale.vm","true")
template = Template.register(
self.userapiclient,
self.services["CentOS7template"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
self.assertIsNotNone(template,"Failed to register CentOS 7 template")
self.debug(
"Registered a template with format {} and id {}".format(
self.services["CentOS7template"]["format"],template.id)
)
template.download(self.userapiclient)
self.cleanup.append(template)
vm = VirtualMachine.create(
self.userapiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
templateid=template.id,
zoneid=self.zone.id
)
self.assertIsNotNone(vm,"Failed to deploy virtual machine")
self.cleanup.append(vm)
response = VirtualMachine.list(self.userapiclient,id=vm.id)
status = validateList(response)
self.assertEqual(status[0],PASS,"list vm response returned invalid list")
self.assertEqual(status[1].state,"Running", "vm is not running")
service_offering = ServiceOffering.create(
self.apiClient,
self.services["service_offerings"]["big"]
)
time.sleep(self.services["sleep"])
vm.scale(self.userapiclient,service_offering.id)
scaleresponse = VirtualMachine.list(self.userapiclient,id=vm.id)
scalestatus = validateList(scaleresponse)
self.assertEqual(scalestatus[0],PASS,"list vm response returned invalid list")
self.assertEqual(scalestatus[1].serviceofferingname,service_offering.name, " service offering is not same")
self.assertEqual(scalestatus[1].serviceofferingid,service_offering.id, " service offering ids are not same")
return
def test_03_concurrent_snapshots_create_template(self):
"""Test while parent concurrent snapshot job in progress,create
template from completed snapshot
1.Configure the concurrent.snapshots.threshold.perhost=3
2.Deploy a Linux VM using default CentOS template, use small
service offering, disk offering
3.Perform snapshot on root disk of this newly created VMs(10 vms)
4.while parent concurrent snapshot job in progress,create template
from completed snapshot"""
# Validate the following
# a.Able to create Template from snapshots
# b.check all snapshots jobs are running concurrently on back grounds
# c.listSnapshots should list this newly created snapshot.
self.debug("Create virtual machine and snapshot on ROOT disk")
self.create_Snapshot_VM()
self.debug("Verify whether snapshots were created properly or not?")
self.verify_Snapshots()
self.debug("Fetch the list of snapshots belong to account: %s" %
self.account.name)
snapshots = self.get_Snapshots_For_Account(
self.account.name,
self.account.domainid)
jobs = []
for snapshot in snapshots:
self.debug("Create a template from snapshot: %s" % snapshot.name)
jobs.append(self.create_Template_from_Snapshot(snapshot))
userapiclient = self.testClient.getUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
# Verify IO usage by submitting the concurrent jobs
self.testClient.submitCmdsAndWait(jobs, apiclient=userapiclient)
self.debug("Verifying if templates are created properly or not?")
templates = Template.list(
self.apiclient,
templatefilter=self.services["template"]["templatefilter"],
account=self.account.name,
domainid=self.account.domainid,
listall=True)
self.assertNotEqual(templates,
None,
"Check if result exists in list item call")
for template in templates:
self.assertEqual(template.isready,
True,
"Check new template state in list templates call")
self.debug("Test completed successfully.")
return
def test_es_47_list_os_types_win_2012(self):
"""
@Desc: Test VM creation while "apply.allocation.algorithm.to.pods"
is set to true
@Reference: https://issues.apache.org/jira/browse/CLOUDSTACK-4947
@Steps:
Step1: register windows 2012 VM template as windows 8 template
Step2: deploy a VM with windows2012 template and Verify
that VM creation is successful
"""
if not is_config_suitable(apiclient=self.apiClient,
name='apply.allocation.algorithm.to.pods',
value='true'):
self.skipTest('apply.allocation.algorithm.to.pods '
'should be true. skipping')
# register windows 2012 VM template as windows 8 template
self.hypervisor = self.testClient.getHypervisorInfo()
if self.hypervisor.lower() in ['lxc']:
self.skipTest(
"windows VM is not supported on %s" %
self.hypervisor.lower())
self.win2012_template = Template.register(
self.apiClient,
self.services["win2012template"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.domain.id,
hypervisor=self.hypervisor
)
# Wait for template to download
self.win2012_template.download(self.apiClient)
self.cleanup.append(self.win2012_template)
# Wait for template status to be changed across
time.sleep(60)
# Deploy
self.debug("Deploying win 2012 VM in account: %s" % self.account.name)
self.services["virtual_machine"]["displayname"] = "win2012"
self.services["virtual_machine"]["zoneid"] = self.zone.id
self.services["virtual_machine"]["template"] = self.win2012_template.id
vm1 = VirtualMachine.create(
self.apiClient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id
)
self.cleanup.append(vm1)
# Verify VM state
self.assertEqual(
vm1.state,
'Running',
"Check VM state is Running or not"
)
return
def setUpClass(cls):
cls.logger = logging.getLogger("TestVPCRemoteAccessVPN")
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
cls.startTime = time.time()
testClient = super(TestVpcRemoteAccessVpn, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = Services().services
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.domain = get_domain(cls.apiclient)
cls.compute_offering = ServiceOffering.create(cls.apiclient, cls.services["compute_offering"])
cls.account = Account.create(cls.apiclient, services=cls.services["account"])
if cls.services["default_hypervisor"] == "kvm":
cls.template = Template.register(
cls.apiclient,
cls.services["template_kvm"],
cls.zone.id,
hypervisor=cls.services["template_kvm"]["hypervisor"],
account=cls.account.name,
domainid=cls.domain.id,
)
else:
cls.template = Template.register(
cls.apiclient,
cls.services["template_xen"],
cls.zone.id,
hypervisor=cls.services["template_xen"]["hypervisor"],
account=cls.account.name,
domainid=cls.domain.id,
)
if cls.template == FAILED:
assert False, (
"get_template() failed to return template with description %s" % cls.services["compute_offering"]
)
cls.services["virtual_machine"]["hypervisor"] = cls.services["default_hypervisor"]
cls.cleanup = [cls.account]
def test_05_use_private_template_in_project(self):
"""Test use of private template in a project
"""
# 1. Create a project
# 2. Verify that in order to use somebody's Private template for vm
# creation in the project, permission to use the template has to
# be granted to the Project (use API 'updateTemplatePermissions'
# with project id to achieve that).
try:
self.debug("Deploying VM for with public template: %s" % self.template.id)
virtual_machine_1 = VirtualMachine.create(
self.apiclient,
self.services["server"],
templateid=self.template.id,
serviceofferingid=self.service_offering.id,
projectid=self.project.id,
)
self.cleanup.append(virtual_machine_1)
# Verify VM state
self.assertEqual(virtual_machine_1.state, "Running", "Check VM state is Running or not")
virtual_machine_1.stop(self.apiclient)
# Get the Root disk of VM
volumes = list_volumes(self.apiclient, projectid=self.project.id, type="ROOT", listall=True)
self.assertEqual(isinstance(volumes, list), True, "Check for list volume response return valid data")
volume = volumes[0]
self.debug("Creating template from volume: %s" % volume.id)
# Create a template from the ROOTDISK
template_1 = Template.create(self.userapiclient, self.services["template"], volumeid=volume.id)
self.cleanup.append(template_1)
# Verify Template state
self.assertEqual(template_1.isready, True, "Check Template is in ready state or not")
# Update template permissions to grant permission to project
self.debug(
"Updating template permissions:%s to grant access to project: %s" % (template_1.id, self.project.id)
)
template_1.updatePermissions(self.apiclient, op="add", projectids=self.project.id)
self.debug("Deploying VM for with privileged template: %s" % self.template.id)
virtual_machine_2 = VirtualMachine.create(
self.apiclient,
self.services["server"],
templateid=template_1.id,
serviceofferingid=self.service_offering.id,
projectid=self.project.id,
)
self.cleanup.append(virtual_machine_2)
# Verify VM state
self.assertEqual(virtual_machine_2.state, "Running", "Check VM state is Running or not")
except Exception as e:
self.fail("Exception occured: %s" % e)
return
def test_02_list_templates_with_templatefilter_all_domain_admin(self):
"""
Test list templates with templatefilter=all is not permitted for domain admin
"""
domain_user_api_client = self.testClient.getUserApiClient(
UserName=self.newdomain_account.name,
DomainName=self.newdomain_account.domain)
try:
list_template_response = Template.list(domain_user_api_client, templatefilter='all')
except Exception as e:
self.fail("Domain admin should be able to use templatefilter='all' in listTemplates API call")
def test_listtemplate(self):
# Register template under one domain admin(root/domain1->account 1)
template_register = Template.register(
self.apiclient,
self.testdata["privatetemplate"],
zoneid=self.zone.id,
hypervisor=self.hypervisor,
account=self.account1.name,
domainid=self.domain1.id,
)
template_register.download(self.apiclient)
# self.cleanup.append(self.template_register)
time.sleep(self.testdata["sleep"])
timeout = self.testdata["timeout"]
while True:
listTemplateResponse = Template.list(
self.apiclient,
templatefilter="all",
id=template_register.id,
account=self.account1.name,
domainid=self.domain1.id,
)
status = validateList(listTemplateResponse)
self.assertEquals(PASS, status[0], "Template creation failed")
listtemplate = Template.list(
self.apiclient,
zoneid=self.zone.id,
hypervisor=self.hypervisor,
account=self.account2.name,
domainid=self.account2.domainid,
templatefilter=self.testdata["templatefilter"],
)
self.assertEqual(listtemplate, None, "Check templates are not listed")
return
def test_01_list_templates_with_templatefilter_all_normal_user(self):
"""
Test list templates with templatefilter=all is not permitted for normal user
"""
user_api_client = self.testClient.getUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
try:
list_template_response = Template.list(self.user_api_client, templatefilter='all')
self.fail("Regular User is able to use templatefilter='all' in listTemplates API call")
except Exception as e:
self.debug("ListTemplates API with templatefilter='all' is not permitted for normal user")
def test_05_template_permissions(self):
"""Update & Test for template permissions"""
# Validate the following
# 1. listTemplatePermissions returns valid
# permissions set for template
# 2. permission changes should be reflected in vm_template
# table in database
self.debug("Updating Template permissions ID:%s" % self.template_2.id)
cmd = updateTemplatePermissions.updateTemplatePermissionsCmd()
# Update template permissions
cmd.id = self.template_2.id
cmd.isfeatured = self.services["isfeatured"]
cmd.ispublic = self.services["ispublic"]
cmd.isextractable = self.services["isextractable"]
self.apiclient.updateTemplatePermissions(cmd)
list_template_response = Template.list(
self.apiclient,
templatefilter='featured',
id=self.template_2.id,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
# Verify template response for updated permissions for normal user
template_response = list_template_response[0]
self.assertEqual(
template_response.id,
self.template_2.id,
"Check template ID"
)
self.assertEqual(
template_response.ispublic,
int(True),
"Check ispublic permission of template"
)
self.assertNotEqual(
template_response.templatetype,
'SYSTEM',
"ListTemplates should not list any system templates"
)
return
def test_01_positive_tests_vm_deploy_shared_nw(self):
""" Positive tests for VMLC test path - Advanced Zone in Shared Network
# 1. List created service offering in setUpClass by name
# 2. List registered template with name
# 3. Create VM in account
"""
# List created service offering in setUpClass by name
listServiceOfferings = ServiceOffering.list(
self.apiclient,
name=self.service_offering_1.name,
listall=True
)
self.assertEqual(validateList(listServiceOfferings)[0], PASS,
"List validation failed for service offerings list")
self.assertEqual(listServiceOfferings[0].name,
self.service_offering_1.name,
"Names of created service offering\
and listed service offering not matching")
# List registered template with name
listTemplates = Template.list(
self.userapiclient,
templatefilter="self",
name=self.template.name,
listall=True,
zone=self.zone.id)
self.assertEqual(validateList(listTemplates)[0], PASS,
"List validation failed for templates list")
self.assertEqual(listTemplates[0].name, self.template.name,
"Names of created template and listed template\
not matching")
network = CreateNetwork(self, SHARED_NETWORK)
# Create VM in account
self.virtual_machine = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
networkids=[network.id, ],
zoneid=self.zone.id
)
self.cleanup.append(self.virtual_machine)
return
def setUpClass(cls):
cls.logger = logging.getLogger('TestInternalLb')
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
testClient = super(TestInternalLb, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = Services().services
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.domain = get_domain(cls.apiclient)
cls.compute_offering = ServiceOffering.create(
cls.apiclient,
cls.services["compute_offering"]
)
cls.account = Account.create(
cls.apiclient, services=cls.services["account"])
if cls.services["default_hypervisor"] == "kvm":
cls.template = Template.register(cls.apiclient, cls.services["template_kvm"], cls.zone.id, hypervisor=cls.services[
"template_kvm"]["hypervisor"], account=cls.account.name, domainid=cls.domain.id)
else:
cls.template = Template.register(cls.apiclient, cls.services["template_xen"], cls.zone.id, hypervisor=cls.services[
"template_xen"]["hypervisor"], account=cls.account.name, domainid=cls.domain.id)
if cls.template == FAILED:
assert False, "get_template() failed to return template"
cls.logger.debug("Successfully created account: %s, id: \
%s" % (cls.account.name,
cls.account.id))
cls.cleanup = [cls.account]
return
def test_02_check_size_snapshotTemplate(self):
"""TS_BUG_010-Test check size of snapshot and template
"""
# Validate the following
# 1. Deploy VM using default template, small service offering
# and small data disk offering.
# 2. Perform snapshot on the root disk of this VM.
# 3. Create a template from snapshot.
# 4. Check the size of snapshot and template
# Create a snapshot from the ROOTDISK
if self.hypervisor.lower() in ['hyperv']:
self.skipTest("Snapshots feature is not supported on Hyper-V")
snapshot = Snapshot.create(
self.apiclient,
self.volume.id,
account=self.account.name,
domainid=self.account.domainid
)
response = snapshot.validateState(self.apiclient, Snapshot.BACKED_UP)
self.assertEqual(response[0], PASS, response[1])
# Generate template from the snapshot
template = Template.create_from_snapshot(
self.apiclient,
snapshot,
self.services["template"]
)
self.cleanup.append(template)
self.debug("Created template from snapshot with ID: %s" % template.id)
templates = Template.list(
self.apiclient,
templatefilter=\
self.services["template"]["templatefilter"],
id=template.id
)
self.assertEqual(
isinstance(templates, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
templates,
None,
"Check if result exists in list item call"
)
self.assertEqual(
templates[0].isready,
True,
"Check new template state in list templates call"
)
# check size of template with that of snapshot
self.assertEqual(
templates[0].size,
self.volume.size,
"Derived template size (%s) does not match snapshot size (%s)" % (templates[0].size, self.volume.size)
)
return
def setUpClass(cls):
testClient = super(TestXDCCPInterop, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = testClient.getParsedTestDataConfig()
cls.hypervisor = cls.testClient.getHypervisorInfo()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
hosts = list_hosts(cls.apiclient, type="Routing")
if hosts is None:
raise unittest.SkipTest(
"There are no hypervisor's available.Check list hosts response"
)
for hypervisorhost in hosts:
if hypervisorhost.hypervisor == "XenServer":
cls.uploadtemplateformat = "VHD"
break
elif hypervisorhost.hypervisor == "VMware":
cls.uploadtemplateformat = "OVA"
break
elif hypervisorhost.hypervisor == "KVM":
cls.uploadtemplateformat = "KVM"
break
if cls.uploadtemplateformat == "KVM":
raise unittest.SkipTest("Interop is not supported on KVM")
cls.uploadurl = cls.services["interop"][
cls.uploadtemplateformat]["url"]
cls.xtemplate = get_template(cls.apiclient, cls.zone.id,
cls.services["ostype"])
if cls.xtemplate == FAILED:
assert False, "get_template() failed to return template with description %s" % cls.services[
"ostype"]
cls.account = Account.create(cls.apiclient,
cls.services["account"],
domainid=cls.domain.id,
admin=False)
cls.debug(cls.account.id)
cls.service_offering = ServiceOffering.create(
cls.apiclient, cls.services["service_offerings"]["large"])
cls.template = get_windows_template(cls.apiclient,
cls.zone.id,
ostype_desc="Windows 8 (64-bit)")
#cls.template = get_windows_template(cls.apiclient, cls.zone.id ,ostype_desc="Windows Server 2012 (64-bit)")
if cls.template == FAILED:
if "http://pleaseupdateURL/" in cls.uploadurl:
raise unittest.SkipTest(
"Check Test Data file if it has the valid template URL")
cls.template = Template.register(
cls.apiclient,
cls.services["interop"][cls.uploadtemplateformat],
zoneid=cls.zone.id,
domainid=cls.account.domainid,
account=cls.account.name)
timeout = cls.services["vgpu"]["timeout"]
while True:
time.sleep(cls.services["vgpu"]["sleep"])
list_template_response = Template.list(
cls.apiclient,
templatefilter=cls.services["templatefilter"],
id=cls.template.id)
if (isinstance(list_template_response, list)) is not True:
raise unittest.SkipTest(
"Check list template api response returns a valid list"
)
if len(list_template_response) is None:
raise unittest.SkipTest(
"Check template registered is in List Templates")
template_response = list_template_response[0]
if template_response.isready:
break
if timeout == 0:
raise unittest.SkipTest(
"Failed to download template(ID: %s). " %
template_response.id)
timeout = timeout - 1
cls.volume = []
# Set Zones and disk offerings
cls.services["small"]["zoneid"] = cls.zone.id
cls.services["small"]["template"] = cls.template.id
user_data = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for x in range(2500))
cls.services["virtual_machine"]["userdata"] = user_data
# cls.services["large"]["zoneid"] = cls.zone.id
# cls.services["large"]["template"] = cls.template.id
cls.virtual_machine = VirtualMachine.create(
cls.apiclient,
cls.services["small"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
mode=cls.services['mode'],
startvm="false")
cls.user_api_client = cls.testClient.getUserApiClient(
UserName=cls.account.name, DomainName=cls.account.domain)
cls.cleanup = [cls.service_offering, cls.account]
def test_19_template_tag(self):
""" Test creation, listing and deletion tag on templates
"""
if self.hypervisor.lower() in ['lxc']:
self.skipTest(
"template creation from volume feature is not supported on %s"
% self.hypervisor.lower())
try:
noffering = NetworkOffering.list(
self.user_api_client,
name="DefaultIsolatedNetworkOfferingWithSourceNatService")
vm4network = Network.create(self.user_api_client,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=noffering[0].id,
zoneid=self.zone.id)
list_nw_response = Network.list(self.user_api_client,
id=vm4network.id)
self.assertEqual(
isinstance(list_nw_response, list), True,
"Check list response returns a valid networks list")
vm_1 = VirtualMachine.create(
self.user_api_client,
self.services["small"],
templateid=self.template.id,
networkids=vm4network.id,
serviceofferingid=self.service_offering.id,
accountid=self.account.name,
domainid=self.account.domainid,
mode=self.services['mode'],
startvm="true")
time.sleep(600)
self.debug("Stopping the virtual machine: %s" % vm_1.name)
# Stop virtual machine
vm_1.stop(self.user_api_client)
except Exception as e:
self.fail("Failed to stop VM: %s" % e)
timeout = self.services["timeout"]
while True:
list_volume = Volume.list(self.user_api_client,
virtualmachineid=vm_1.id,
type='ROOT',
listall=True)
if isinstance(list_volume, list):
break
elif timeout == 0:
raise Exception("List volumes failed.")
time.sleep(5)
timeout = timeout - 1
self.volume = list_volume[0]
self.debug("Creating template from ROOT disk of virtual machine: %s" %
vm_1.name)
# Create template from volume
template = Template.create(self.user_api_client,
self.services["template"], self.volume.id)
self.cleanup.append(template)
self.debug("Created the template(%s). Now restarting the userVm: %s" %
(template.name, vm_1.name))
vm_1.start(self.user_api_client)
self.debug("Creating a tag for the template")
tag = Tag.create(self.user_api_client,
resourceIds=template.id,
resourceType='Template',
tags={'OS': 'windows8'})
self.debug("Tag created: %s" % tag.__dict__)
tags = Tag.list(self.user_api_client,
listall=True,
resourceType='Template',
key='OS',
value='windows8')
self.assertEqual(isinstance(tags, list), True,
"List tags should not return empty response")
self.assertEqual(tags[0].value, 'windows8',
'The tag should have original value')
Template.list(
self.user_api_client,
templatefilter=self.services["template"]["templatefilter"],
listall=True,
key='OS',
value='windows8')
self.debug("Deleting the created tag..")
try:
tag.delete(self.user_api_client,
resourceIds=template.id,
resourceType='Template',
tags={'OS': 'windows8'})
except Exception as e:
self.fail("Failed to delete the tag - %s" % e)
self.debug("Verifying if tag is actually deleted!")
tags = Tag.list(self.user_api_client,
listall=True,
resourceType='Template',
key='OS',
value='windows8')
self.assertEqual(tags, None, "List tags should return empty response")
return
def test_02_host_maintenance_mode_with_activities(self):
"""Test host maintenance mode with activities
"""
# Validate the following
# 1. Create Vms. Acquire IP. Create port forwarding & load balancing
# rules for Vms.
# 2. While activities are ongoing: Create snapshots, recurring
# snapshots, create templates, download volumes, Host 1: put to
# maintenance mode. All Vms should failover to Host 2 in cluster
# Vms should be in running state. All port forwarding rules and
# load balancing Rules should work.
# 3. After failover to Host 2 succeeds, deploy Vms. Deploy Vms on host
# 2 should succeed. All ongoing activities in step 3 should succeed
# 4. Host 1: cancel maintenance mode.
# 5. While activities are ongoing: Create snapshots, recurring
# snapshots, create templates, download volumes, Host 2: put to
# maintenance mode. All Vms should failover to Host 1 in cluster.
# 6. After failover to Host 1 succeeds, deploy VMs. Deploy Vms on
# host 1 should succeed. All ongoing activities in step 6 should
# succeed.
hosts = Host.list(
self.apiclient,
zoneid=self.zone.id,
resourcestate='Enabled',
type='Routing'
)
self.assertEqual(
isinstance(hosts, list),
True,
"List hosts should return valid host response"
)
if len(hosts) < 2:
self.skipTest("There must be at least 2 hosts present in cluster")
self.debug("Checking HA with hosts: %s, %s" % (
hosts[0].name,
hosts[1].name
))
self.debug("Deploying VM in account: %s" % self.account.name)
# Spawn an instance in that network
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id
)
vms = VirtualMachine.list(
self.apiclient,
id=virtual_machine.id,
listall=True
)
self.assertEqual(
isinstance(vms, list),
True,
"List VMs should return valid response for deployed VM"
)
self.assertNotEqual(
len(vms),
0,
"List VMs should return valid response for deployed VM"
)
vm = vms[0]
self.debug("Deployed VM on host: %s" % vm.hostid)
self.assertEqual(
vm.state,
"Running",
"Deployed VM should be in RUnning state"
)
networks = Network.list(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True
)
self.assertEqual(
isinstance(networks, list),
True,
"List networks should return valid list for the account"
)
network = networks[0]
self.debug("Associating public IP for account: %s" %
self.account.name)
public_ip = PublicIPAddress.create(
self.apiclient,
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
networkid=network.id
)
self.debug("Associated %s with network %s" % (
public_ip.ipaddress.ipaddress,
network.id
))
self.debug("Creating PF rule for IP address: %s" %
public_ip.ipaddress.ipaddress)
NATRule.create(
self.apiclient,
virtual_machine,
self.services["natrule"],
ipaddressid=public_ip.ipaddress.id
)
self.debug("Creating LB rule on IP with NAT: %s" %
public_ip.ipaddress.ipaddress)
# Create Load Balancer rule on IP already having NAT rule
lb_rule = LoadBalancerRule.create(
self.apiclient,
self.services["lbrule"],
ipaddressid=public_ip.ipaddress.id,
accountid=self.account.name
)
self.debug("Created LB rule with ID: %s" % lb_rule.id)
# Should be able to SSH VM
try:
self.debug("SSH into VM: %s" % virtual_machine.id)
virtual_machine.get_ssh_client(
ipaddress=public_ip.ipaddress.ipaddress)
except Exception as e:
self.fail("SSH Access failed for %s: %s" %
(virtual_machine.ipaddress, e)
)
# Get the Root disk of VM
volumes = list_volumes(
self.apiclient,
virtualmachineid=virtual_machine.id,
type='ROOT',
listall=True
)
volume = volumes[0]
self.debug(
"Root volume of VM(%s): %s" % (
virtual_machine.name,
volume.name
))
# Create a snapshot from the ROOTDISK
self.debug("Creating snapshot on ROOT volume: %s" % volume.name)
snapshot = Snapshot.create(self.apiclient, volumes[0].id)
self.debug("Snapshot created: ID - %s" % snapshot.id)
snapshots = list_snapshots(
self.apiclient,
id=snapshot.id,
listall=True
)
self.assertEqual(
isinstance(snapshots, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
snapshots,
None,
"Check if result exists in list snapshots call"
)
self.assertEqual(
snapshots[0].id,
snapshot.id,
"Check snapshot id in list resources call"
)
# Generate template from the snapshot
self.debug("Generating template from snapshot: %s" % snapshot.name)
template = Template.create_from_snapshot(
self.apiclient,
snapshot,
self.services["templates"]
)
self.debug("Created template from snapshot: %s" % template.id)
templates = list_templates(
self.apiclient,
templatefilter=self.services["templates"]["templatefilter"],
id=template.id
)
self.assertEqual(
isinstance(templates, list),
True,
"List template call should return the newly created template"
)
self.assertEqual(
templates[0].isready,
True,
"The newly created template should be in ready state"
)
first_host = vm.hostid
self.debug("Enabling maintenance mode for host %s" % vm.hostid)
cmd = prepareHostForMaintenance.prepareHostForMaintenanceCmd()
cmd.id = first_host
self.apiclient.prepareHostForMaintenance(cmd)
self.debug("Waiting for SSVMs to come up")
wait_for_ssvms(
self.apiclient,
zoneid=self.zone.id,
podid=self.pod.id,
)
timeout = self.services["timeout"]
# Poll and check state of VM while it migrates from one host to another
while True:
vms = VirtualMachine.list(
self.apiclient,
id=virtual_machine.id,
listall=True
)
self.assertEqual(
isinstance(vms, list),
True,
"List VMs should return valid response for deployed VM"
)
self.assertNotEqual(
len(vms),
0,
"List VMs should return valid response for deployed VM"
)
vm = vms[0]
self.debug("VM 1 state: %s" % vm.state)
if vm.state in ["Stopping",
"Stopped",
"Running",
"Starting",
"Migrating"]:
if vm.state == "Running":
break
else:
time.sleep(self.services["sleep"])
timeout = timeout - 1
else:
self.fail(
"VM migration from one-host-to-other failed\
while enabling maintenance"
)
second_host = vm.hostid
self.assertEqual(
vm.state,
"Running",
"VM should be in Running state after enabling host maintenance"
)
# Should be able to SSH VM
try:
self.debug("SSH into VM: %s" % virtual_machine.id)
virtual_machine.get_ssh_client(
ipaddress=public_ip.ipaddress.ipaddress)
except Exception as e:
self.fail("SSH Access failed for %s: %s" %
(virtual_machine.ipaddress, e)
)
self.debug("Deploying VM in account: %s" % self.account.name)
# Spawn an instance on other host
virtual_machine_2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id
)
vms = VirtualMachine.list(
self.apiclient,
id=virtual_machine_2.id,
listall=True
)
self.assertEqual(
isinstance(vms, list),
True,
"List VMs should return valid response for deployed VM"
)
self.assertNotEqual(
len(vms),
0,
"List VMs should return valid response for deployed VM"
)
vm = vms[0]
self.debug("Deployed VM on host: %s" % vm.hostid)
self.debug("VM 2 state: %s" % vm.state)
self.assertEqual(
vm.state,
"Running",
"Deployed VM should be in Running state"
)
self.debug("Canceling host maintenance for ID: %s" % first_host)
cmd = cancelHostMaintenance.cancelHostMaintenanceCmd()
cmd.id = first_host
self.apiclient.cancelHostMaintenance(cmd)
self.debug("Maintenance mode canceled for host: %s" % first_host)
# Get the Root disk of VM
volumes = list_volumes(
self.apiclient,
virtualmachineid=virtual_machine_2.id,
type='ROOT',
listall=True
)
volume = volumes[0]
self.debug(
"Root volume of VM(%s): %s" % (
virtual_machine_2.name,
volume.name
))
# Create a snapshot from the ROOTDISK
self.debug("Creating snapshot on ROOT volume: %s" % volume.name)
snapshot = Snapshot.create(self.apiclient, volumes[0].id)
self.debug("Snapshot created: ID - %s" % snapshot.id)
snapshots = list_snapshots(
self.apiclient,
id=snapshot.id,
listall=True
)
self.assertEqual(
isinstance(snapshots, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
snapshots,
None,
"Check if result exists in list snapshots call"
)
self.assertEqual(
snapshots[0].id,
snapshot.id,
"Check snapshot id in list resources call"
)
# Generate template from the snapshot
self.debug("Generating template from snapshot: %s" % snapshot.name)
template = Template.create_from_snapshot(
self.apiclient,
snapshot,
self.services["templates"]
)
self.debug("Created template from snapshot: %s" % template.id)
templates = list_templates(
self.apiclient,
templatefilter=self.services["templates"]["templatefilter"],
id=template.id
)
self.assertEqual(
isinstance(templates, list),
True,
"List template call should return the newly created template"
)
self.assertEqual(
templates[0].isready,
True,
"The newly created template should be in ready state"
)
self.debug("Enabling maintenance mode for host %s" % second_host)
cmd = prepareHostForMaintenance.prepareHostForMaintenanceCmd()
cmd.id = second_host
self.apiclient.prepareHostForMaintenance(cmd)
self.debug("Maintenance mode enabled for host: %s" % second_host)
self.debug("Waiting for SSVMs to come up")
wait_for_ssvms(
self.apiclient,
zoneid=self.zone.id,
podid=self.pod.id,
)
# Poll and check the status of VMs
timeout = self.services["timeout"]
while True:
vms = VirtualMachine.list(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True
)
self.assertEqual(
isinstance(vms, list),
True,
"List VMs should return valid response for deployed VM"
)
self.assertNotEqual(
len(vms),
0,
"List VMs should return valid response for deployed VM"
)
vm = vms[0]
self.debug(
"VM state after enabling maintenance on first host: %s" %
vm.state)
if vm.state in ["Stopping",
"Stopped",
"Running",
"Starting",
"Migrating"]:
if vm.state == "Running":
break
else:
time.sleep(self.services["sleep"])
timeout = timeout - 1
else:
self.fail(
"VM migration from one-host-to-other failed\
while enabling maintenance"
)
# Poll and check the status of VMs
timeout = self.services["timeout"]
while True:
vms = VirtualMachine.list(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True
)
self.assertEqual(
isinstance(vms, list),
True,
"List VMs should return valid response for deployed VM"
)
self.assertNotEqual(
len(vms),
0,
"List VMs should return valid response for deployed VM"
)
vm = vms[1]
self.debug(
"VM state after enabling maintenance on first host: %s" %
vm.state)
if vm.state in ["Stopping",
"Stopped",
"Running",
"Starting",
"Migrating"]:
if vm.state == "Running":
break
else:
time.sleep(self.services["sleep"])
timeout = timeout - 1
else:
self.fail(
"VM migration from one-host-to-other failed\
while enabling maintenance"
)
for vm in vms:
self.debug(
"VM states after enabling maintenance mode on host: %s - %s" %
(first_host, vm.state))
self.assertEqual(
vm.state,
"Running",
"Deployed VM should be in Running state"
)
# Spawn an instance on other host
virtual_machine_3 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id
)
vms = VirtualMachine.list(
self.apiclient,
id=virtual_machine_3.id,
listall=True
)
self.assertEqual(
isinstance(vms, list),
True,
"List VMs should return valid response for deployed VM"
)
self.assertNotEqual(
len(vms),
0,
"List VMs should return valid response for deployed VM"
)
vm = vms[0]
self.debug("Deployed VM on host: %s" % vm.hostid)
self.debug("VM 3 state: %s" % vm.state)
self.assertEqual(
vm.state,
"Running",
"Deployed VM should be in Running state"
)
self.debug("Canceling host maintenance for ID: %s" % second_host)
cmd = cancelHostMaintenance.cancelHostMaintenanceCmd()
cmd.id = second_host
self.apiclient.cancelHostMaintenance(cmd)
self.debug("Maintenance mode canceled for host: %s" % second_host)
self.debug("Waiting for SSVMs to come up")
wait_for_ssvms(
self.apiclient,
zoneid=self.zone.id,
podid=self.pod.id,
)
return
def test_04_copy_template(self):
"""
@Desc: Test to copy Template from one zone to another
@steps:
Step1: Listing Zones available for a user
Step2: Verifying if the zones listed are greater than 1.
If Yes continuing.
If not halting the test.
Step3: Listing all the templates for a user in zone1
Step4: Verifying that no templates are listed
Step5: Listing all the templates for a user in zone2
Step6: Verifying that no templates are listed
Step7: Creating a Template in zone 1
Step8: Listing all the Templates again for a user in zone1
Step9: Verifying that list size is 1
Step10: Listing all the templates for a user in zone2
Step11: Verifying that no templates are listed
Step12: Copying the template created in step7 from zone1 to zone2
Step13: Listing all the templates for a user in zone2
Step14: Verifying that list size is 1
Step15: Listing all the Templates for a user in zone1
Step16: Verifying that list size is 1
"""
# Listing Zones available for a user
zones_list = Zone.list(
self.userapiclient,
available=True
)
status = validateList(zones_list)
self.assertEquals(
PASS,
status[0],
"Failed to list Zones"
)
if not len(zones_list) > 1:
raise unittest.SkipTest("Not enough zones exist to copy template")
else:
# Listing all the Templates for a User in Zone 1
list_templates_zone1 = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
zoneid=zones_list[0].id
)
# Verifying that no Templates are listed
self.assertIsNone(
list_templates_zone1,
"Templates listed for newly created User in Zone1"
)
# Listing all the Templates for a User in Zone 2
list_templates_zone2 = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
zoneid=zones_list[1].id
)
# Verifying that no Templates are listed
self.assertIsNone(
list_templates_zone2,
"Templates listed for newly created User in Zone2"
)
self.services["privatetemplate"][
"ostype"] = self.services["ostype"]
# Listing Hypervisors in Zone 1
hypervisor_list = Hypervisor.list(
self.apiClient,
zoneid=zones_list[0].id
)
status = validateList(zones_list)
self.assertEquals(
PASS,
status[0],
"Failed to list Hypervisors in Zone 1"
)
# Creating aTemplate in Zone 1
template_created = Template.register(
self.userapiclient,
self.services["privatetemplate"],
zones_list[0].id,
hypervisor=hypervisor_list[0].name
)
self.assertIsNotNone(
template_created,
"Template creation failed"
)
# Listing all the Templates for a User in Zone 1
list_templates_zone1 = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
zoneid=zones_list[0].id
)
status = validateList(list_templates_zone1)
self.assertEquals(
PASS,
status[0],
"Templates creation failed in Zone1"
)
# Verifying that list size is 1
self.assertEquals(
1,
len(list_templates_zone1),
"Failed to create a Template"
)
# Listing all the Templates for a User in Zone 2
list_templates_zone2 = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
zoneid=zones_list[1].id
)
# Verifying that no Templates are listed
self.assertIsNone(
list_templates_zone2,
"Templates listed for newly created User in Zone2"
)
# Verifying the state of the template to be ready. If not waiting
# for state to become ready till time out
template_ready = False
count = 0
while template_ready is False:
list_template = Template.list(
self.userapiclient,
id=template_created.id,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
)
status = validateList(list_template)
self.assertEquals(
PASS,
status[0],
"Failed to list Templates by Id"
)
if list_template[0].isready is True:
template_ready = True
elif (str(list_template[0].status) == "Error"):
self.fail("Created Template is in Errored state")
break
elif count > 10:
self.fail(
"Timed out before Template came into ready state")
break
else:
time.sleep(self.services["sleep"])
count = count + 1
# Copying the Template from Zone1 to Zone2
copied_template = template_created.copy(
self.userapiclient,
sourcezoneid=template_created.zoneid,
destzoneid=zones_list[1].id
)
self.assertIsNotNone(
copied_template,
"Copying Template from Zone1 to Zone2 failed"
)
# Listing all the Templates for a User in Zone 1
list_templates_zone1 = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
zoneid=zones_list[0].id
)
status = validateList(list_templates_zone1)
self.assertEquals(
PASS,
status[0],
"Templates creation failed in Zone1"
)
# Verifying that list size is 1
self.assertEquals(
1,
len(list_templates_zone1),
"Failed to create a Template"
)
# Listing all the Templates for a User in Zone 2
list_templates_zone2 = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
zoneid=zones_list[1].id
)
status = validateList(list_templates_zone2)
self.assertEquals(
PASS,
status[0],
"Template failed to copy into Zone2"
)
# Verifying that list size is 1
self.assertEquals(
1,
len(list_templates_zone2),
"Template failed to copy into Zone2"
)
self.assertNotEquals(
"Connection refused",
list_templates_zone2[0].status,
"Failed to copy Template"
)
self.assertEquals(
True,
list_templates_zone2[0].isready,
"Failed to copy Template"
)
del self.services["privatetemplate"]["ostype"]
return
def test_02_download_template(self):
"""
@Desc: Test to Download Template
@steps:
Step1: Listing all the Templates for a user
Step2: Verifying that no Templates are listed
Step3: Creating a Templates
Step4: Listing all the Templates again for a user
Step5: Verifying that list size is 1
Step6: Verifying if the template is in ready state.
If yes the continuing
If not waiting and checking for template to be ready till timeout
Step7: Downloading the template (Extract)
Step8: Verifying that Template is downloaded
"""
# Listing all the Templates for a User
list_templates_before = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"]
)
# Verifying that no Templates are listed
self.assertIsNone(
list_templates_before,
"Templates listed for newly created User"
)
self.services["privatetemplate"]["ostype"] = self.services["ostype"]
self.services["privatetemplate"]["isextractable"] = True
# Creating aTemplate
template_created = Template.register(
self.userapiclient,
self.services["privatetemplate"],
self.zone.id,
hypervisor=self.hypervisor
)
self.assertIsNotNone(
template_created,
"Template creation failed"
)
# Listing all the Templates for a User
list_templates_after = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"]
)
status = validateList(list_templates_after)
self.assertEquals(
PASS,
status[0],
"Templates creation failed"
)
# Verifying that list size is 1
self.assertEquals(
1,
len(list_templates_after),
"Failed to create a Template"
)
# Verifying the state of the template to be ready. If not waiting for
# state to become ready till time out
template_ready = False
count = 0
while template_ready is False:
list_template = Template.list(
self.userapiclient,
id=template_created.id,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
)
status = validateList(list_template)
self.assertEquals(
PASS,
status[0],
"Failed to list Templates by Id"
)
if list_template[0].isready is True:
template_ready = True
elif (str(list_template[0].status) == "Error"):
self.fail("Created Template is in Errored state")
break
elif count > 10:
self.fail("Timed out before Template came into ready state")
break
else:
time.sleep(self.services["sleep"])
count = count + 1
# Downloading the Template name
download_template = Template.extract(
self.userapiclient,
template_created.id,
mode="HTTP_DOWNLOAD",
zoneid=self.zone.id
)
self.assertIsNotNone(
download_template,
"Download Template failed"
)
# Verifying the details of downloaded template
self.assertEquals(
"DOWNLOAD_URL_CREATED",
download_template.state,
"Download URL not created for Template"
)
self.assertIsNotNone(
download_template.url,
"Download URL not created for Template"
)
self.assertEquals(
template_created.id,
download_template.id,
"Download Template details are not same as Template created"
)
del self.services["privatetemplate"]["ostype"]
del self.services["privatetemplate"]["isextractable"]
return
def setUpClass(cls):
cls.testClient = super(TestTemplates, 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.services['mode'] = cls.zone.networktype
cls._cleanup = []
cls.unsupportedHypervisor = False
cls.hypervisor = cls.testClient.getHypervisorInfo()
if cls.hypervisor.lower() in ['lxc']:
cls.unsupportedHypervisor = True
return
# populate second zone id for iso copy
cmd = listZones.listZonesCmd()
zones = cls.api_client.listZones(cmd)
if not isinstance(zones, list):
raise Exception("Failed to find zones.")
if len(zones) >= 2:
cls.services["destzoneid"] = zones[1].id
template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
try:
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=cls.domain.id)
cls._cleanup.append(cls.account)
cls.services["account"] = cls.account.name
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
cls._cleanup.append(cls.service_offering)
# create virtual machine
cls.virtual_machine = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
templateid=template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
)
# Stop virtual machine
cls.virtual_machine.stop(cls.api_client)
timeout = cls.services["timeout"]
while True:
list_volume = Volume.list(
cls.api_client,
virtualmachineid=cls.virtual_machine.id,
type='ROOT',
listall=True)
if isinstance(list_volume, list):
break
elif timeout == 0:
raise Exception("List volumes failed.")
time.sleep(5)
timeout = timeout - 1
cls.volume = list_volume[0]
# Create template from volume
cls.template = Template.create(cls.api_client,
cls.services["template"],
cls.volume.id)
except Exception as e:
cls.tearDownClass()
raise unittest.SkipTest("Failure in setUpClass: %s" % e)
def test_01_create_template(self):
"""Test create public & private template
"""
# Validate the following:
# 1. Upload a templates in raw img format. Create a Vm instances from
# raw img template.
# 2. Upload a templates in zip file format. Create a Vm instances from
# zip template.
# 3. Upload a templates in tar format.Create a Vm instances from tar
# template.
# 4. Upload a templates in tar gzip format.Create a Vm instances from
# tar gzip template.
# 5. Upload a templates in tar bzip format. Create a Vm instances from
# tar bzip template.
# 6. Verify VMs & Templates is up and in ready state
builtin_info = get_builtin_template_info(self.apiclient, self.zone.id)
self.services["templates"][0]["url"] = builtin_info[0]
self.services["templates"][0]["hypervisor"] = builtin_info[1]
self.services["templates"][0]["format"] = builtin_info[2]
# Register new template
template = Template.register(self.apiclient,
self.services["templates"][0],
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" %
(self.services["templates"][0]["format"], template.id))
# Wait for template to download
template.download(self.apiclient)
self.cleanup.append(template)
# Wait for template status to be changed across
time.sleep(self.services["sleep"])
timeout = self.services["timeout"]
while True:
list_template_response = Template.list(
self.apiclient,
templatefilter='all',
id=template.id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid)
if isinstance(list_template_response, list):
break
elif timeout == 0:
raise Exception("List template failed!")
time.sleep(5)
timeout = timeout - 1
# Verify template response to check whether template added successfully
self.assertEqual(isinstance(list_template_response, list), True,
"Check for list template response return valid data")
self.assertNotEqual(len(list_template_response), 0,
"Check template available in List Templates")
template_response = list_template_response[0]
self.assertEqual(
template_response.isready, True,
"Template state is not ready, it is %s" %
template_response.isready)
# Deploy new virtual machine using template
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
mode=self.services["mode"])
self.debug("creating an instance with template ID: %s" % template.id)
vm_response = VirtualMachine.list(self.apiclient,
id=virtual_machine.id,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(vm_response, list), True,
"Check for list VMs response after VM deployment")
# Verify VM response to check whether VM deployment was successful
self.assertNotEqual(len(vm_response), 0,
"Check VMs available in List VMs response")
vm = vm_response[0]
self.assertEqual(vm.state, 'Running',
"Check the state of VM created from Template")
return
def test_07_templates_per_project(self):
"""Test Templates limit per project
"""
# 1. set max no of templates per project to 1.
# 2. Create a template in this project. Both template should be in
# ready state
# 3. Try create 2nd template in the project. It should give the user
# appropriate error and an alert should be generated.
# Reset the volume limits
update_resource_limit(
self.apiclient,
2, # Volume
max=5,
projectid=self.project.id)
self.debug("Updating template resource limits for domain: %s" %
self.account.domainid)
# Set usage_vm=1 for Account 1
update_resource_limit(
self.apiclient,
4, # Template
max=1,
projectid=self.project.id)
# Register the First Template in the project
self.debug("Register the First Template in the project")
builtin_info = get_builtin_template_info(self.apiclient, self.zone.id)
self.services["template"]["url"] = builtin_info[0]
self.services["template"]["hypervisor"] = builtin_info[1]
self.services["template"]["format"] = builtin_info[2]
# Register new template
template = Template.register(self.userapiclient,
self.services["template"],
zoneid=self.zone.id,
projectid=self.project.id)
self.debug("Registered a template of format: %s with ID: %s" %
(self.services["template"]["format"], template.id))
self.cleanup.append(template)
# Wait for template status to be changed across
time.sleep(self.services["sleep"])
timeout = self.services["timeout"]
while True:
list_template_response = Template.list(
self.apiclient,
templatefilter='all',
id=template.id,
zoneid=self.zone.id,
projectid=self.project.id,
)
if list_template_response[0].isready is True:
break
elif timeout == 0:
raise Exception("Template state is not ready, it is %s" %
list_template_response[0].isready)
time.sleep(self.services["sleep"])
timeout = timeout - 1
# Verify template response to check whether template added successfully
self.assertEqual(isinstance(list_template_response, list), True,
"Check for list template response return valid data")
self.assertNotEqual(len(list_template_response), 0,
"Check template available in List Templates")
template_response = list_template_response[0]
self.assertEqual(
template_response.isready, True,
"Template state is not ready, it is %s" %
template_response.isready)
# Exception should be raised for second template
with self.assertRaises(Exception):
Template.register(self.userapiclient,
self.services["template"],
zoneid=self.zone.id,
projectid=self.project.id)
return
def test_01_attach_volume_ide(self):
"""
@desc: Exception when attaching data disk to RHEL VM on vSphere
Step1: Confirm that vmware.root.disk.controller = "ide" in Global Settings.
Step2: Register RHEl 6.0 template and deploy a VM.
Step3: Note that the root disk is attached to IDE.
Step4: Create new DATA disk and attempt to attach it to the VM.
Verify that step4 succeeds without any exception
"""
self.hypervisor = str(get_hypervisor_type(self.api_client)).lower()
if self.hypervisor != "vmware":
self.skipTest("This test can be run only on vmware")
cmd = listConfigurations.listConfigurationsCmd()
cmd.name = "vmware.root.disk.controller"
cmd.listAll = True
try:
config_descs = self.api_client.listConfigurations(cmd)
except Exception as e:
raise Exception("Failed to fetch configurations: %s" % e)
if not isinstance(config_descs, list):
raise Exception("List configs didn't returned a valid data")
config_desc = config_descs[0]
if str(config_desc.value).lower() != "ide":
self.skipTest(
"This test is invalid if {} is not set to ide".format(
config_desc.name))
"""
Register RHEL 6.0 template and deploy vm
"""
template = Template.register(self.userapiclient,
self.services["rhel60template"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
hypervisor=self.hypervisor)
self.assertIsNotNone(template, "Failed to register Rhel6 template")
self.debug("Registered a template with format {} and id {}".format(
self.services["rhel60template"]["format"], template.id))
template.download(self.userapiclient)
self.cleanup.append(template)
vm = VirtualMachine.create(self.userapiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
templateid=template.id,
zoneid=self.zone.id)
self.assertIsNotNone(vm, "Failed to deploy virtual machine")
self.cleanup.append(vm)
response = VirtualMachine.list(self.userapiclient, id=vm.id)
status = validateList(response)
self.assertEqual(status[0], PASS,
"list vm response returned invalid list")
"""
list root disk of the vm created above and make sure that device type is ide
"""
volume_res = Volume.list(self.userapiclient,
virtualmachineid=vm.id,
type="root",
listAll="true")
self.assertEqual(
validateList(volume_res)[0], PASS,
"list vm response returned invalid list")
chaininfo = volume_res[0].chaininfo
device_Bus = literal_eval(chaininfo)["diskDeviceBusName"]
if "ide" not in device_Bus:
self.fail("Root disk is not created with device type IDE")
disk = Volume.create(self.userapiclient,
self.services["volume"],
zoneid=self.zone.id,
diskofferingid=self.disk_offering.id)
self.assertIsNotNone(disk, "Failed to create custom volume")
self.cleanup.append(disk)
try:
vm.attach_volume(self.userapiclient, disk)
list_volumes = Volume.list(self.userapiclient,
listall=self.services["listall"],
id=disk.id)
attached_volume = list_volumes[0]
self.assertEqual(
disk.id, attached_volume.id,
"list volume response does not match with the volume created and attached to vm"
)
except Exception as e:
self.fail(
"Failed to attach data disk to RHEL vm whose root disk type is IDE"
)
return
def test01_template_download_URL_expire(self):
"""
@Desc:Template files are deleted from secondary storage after download URL expires
Step1:Deploy vm with default cent os template
Step2:Stop the vm
Step3:Create template from the vm's root volume
Step4:Extract Template and wait for the download url to expire
Step5:Deploy another vm with the template created at Step3
Step6:Verify that vm deployment succeeds
"""
params = [
'extract.url.expiration.interval', 'extract.url.cleanup.interval'
]
wait_time = 0
for param in params:
config = Configurations.list(
self.apiClient,
name=param,
)
self.assertEqual(
validateList(config)[0], PASS,
"Config list returned invalid response")
wait_time = wait_time + int(config[0].value)
self.debug("Total wait time for url expiry: %s" % wait_time)
# Creating Virtual Machine
self.virtual_machine = VirtualMachine.create(
self.userapiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
)
self.assertIsNotNone(self.virtual_machine,
"Virtual Machine creation failed")
self.cleanup.append(self.virtual_machine)
#Stop virtual machine
self.virtual_machine.stop(self.userapiclient)
list_volume = Volume.list(self.userapiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall=True)
self.assertEqual(
validateList(list_volume)[0], PASS,
"list volumes with type ROOT returned invalid list")
self.volume = list_volume[0]
self.create_template = Template.create(self.userapiclient,
self.services["template"],
volumeid=self.volume.id,
account=self.account.name,
domainid=self.account.domainid)
self.assertIsNotNone(self.create_template,
"Failed to create template from root volume")
self.cleanup.append(self.create_template)
"""
Extract template
"""
try:
Template.extract(self.userapiclient, self.create_template.id,
'HTTP_DOWNLOAD', self.zone.id)
except Exception as e:
self.fail("Extract template failed with error %s" % e)
self.debug("Waiting for %s seconds for url to expire" %
repr(wait_time + 20))
time.sleep(wait_time + 20)
self.debug("Waited for %s seconds for url to expire" %
repr(wait_time + 20))
"""
Deploy vm with the template created from the volume. After url expiration interval only
url should be deleted not the template. To validate this deploy vm with the template
"""
try:
self.vm = VirtualMachine.create(
self.userapiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
templateid=self.create_template.id)
self.cleanup.append(self.vm)
except Exception as e:
self.fail("Template is automatically deleted after URL expired.\
So vm deployment failed with error: %s" % e)
return
def setUpClass(cls):
cls.logger = logging.getLogger('TestRedundantIsolateNetworks')
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
cls.testClient = super(TestRedundantIsolateNetworks, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
macchinina = Templates().templates["macchinina"]
cls.hypervisor = cls.testClient.getHypervisorInfo()
cls.logger.debug("Downloading Template: %s from: %s" % (macchinina[cls.hypervisor.lower()],
macchinina[cls.hypervisor.lower()]["url"]))
cls.template = Template.register(cls.api_client, macchinina[cls.hypervisor.lower()],
cls.zone.id, hypervisor=cls.hypervisor.lower(), domainid=cls.domain.id)
cls.template.download(cls.api_client)
if cls.template == FAILED:
assert False, "get_template() failed to return template"
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
# Create an account, network, VM and IP addresses
cls.account = Account.create(
cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls.services["nw_off_persistent_RVR_egress_true"] = cls.services["nw_off_persistent_RVR"].copy()
cls.services["nw_off_persistent_RVR_egress_true"]["egress_policy"] = "true"
cls.services["nw_off_persistent_RVR_egress_false"] = cls.services["nw_off_persistent_RVR"].copy()
cls.services["nw_off_persistent_RVR_egress_false"]["egress_policy"] = "false"
cls.services["egress_80"] = {
"startport": 80,
"endport": 80,
"protocol": "TCP",
"cidrlist": ["0.0.0.0/0"]
}
cls.services["egress_53"] = {
"startport": 53,
"endport": 53,
"protocol": "UDP",
"cidrlist": ["0.0.0.0/0"]
}
cls._cleanup = [
cls.service_offering,
cls.account,
cls.template
]
return
def test_01_volume_snapshot(self):
""" Test Volume (root) Snapshot
# 1. Deploy a VM on primary storage and .
# 2. Take snapshot on root disk
# 3. Verify the snapshot's entry in the "snapshots" table
and presence of the corresponding
snapshot on the Secondary Storage
# 4. Create Template from the Snapshot and Deploy a
VM using the Template
# 5. Log in to the VM from template and make verify
the contents of the ROOT disk matches with the snapshot.
# 6. Delete Snapshot and Deploy a Linux VM from the
Template and verify the successful deployment of the VM.
# 7. Create multiple snapshots on the same volume and
Check the integrity of all the snapshots by creating
a template from the snapshot and deploying a Vm from it
and delete one of the snapshots
# 8. Verify that the original checksum matches with the checksum
of VM's created from remaning snapshots
# 9. Make verify the contents of the ROOT disk
matches with the snapshot
# 10.Verify that Snapshot of both DATA and ROOT volume should
succeed when snapshot of Data disk of a VM is taken
when snapshot of ROOT volume of VM is in progress
# 11.Create snapshot of data disk and verify the original checksum
matches with the volume created from snapshot
# 12.Verify that volume's state should not change when snapshot of
a DATA volume is taken that is attached to a VM
# 13.Verify that volume's state should not change when snapshot of
a DATA volume is taken that is not attached to a VM
# 14.Verify that create Snapshot with quiescevm=True should succeed
# 15.revertSnapshot() to revert VM to a specified
Volume snapshot for root volume
"""
# Step 1
# Get ROOT Volume Id
root_volumes_cluster_list = list_volumes(self.apiclient,
virtualmachineid=self.vm_1.id,
type='ROOT',
listall=True)
root_volume_cluster = root_volumes_cluster_list[0]
disk_volumes_cluster_list = list_volumes(self.apiclient,
virtualmachineid=self.vm_1.id,
type='DATADISK',
listall=True)
data_disk = disk_volumes_cluster_list[0]
root_vol_state = root_volume_cluster.state
ckecksum_random_root_cluster = createChecksum(
service=self.testdata,
virtual_machine=self.vm_1,
disk=root_volume_cluster,
disk_type="rootdiskdevice")
self.vm_1.stop(self.apiclient)
root_vol_snap = Snapshot.create(self.apiclient, root_volume_cluster.id)
self.assertEqual(root_vol_snap.state, "BackedUp",
"Check if the snapshot state is correct ")
self.assertEqual(root_vol_state, root_volume_cluster.state,
"Check if volume state has changed")
self.vm_1.start(self.apiclient)
# Step 2
snapshot_list = list_snapshots(self.apiclient, id=root_vol_snap.id)
self.assertNotEqual(snapshot_list, None,
"Check if result exists in list item call")
self.assertEqual(snapshot_list[0].id, root_vol_snap.id,
"Check resource id in list resources call")
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, root_vol_snap.id))
events = list_events(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='SNAPSHOT.CREATE')
event_list_validation_result = validateList(events)
self.assertEqual(
event_list_validation_result[0], PASS,
"event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event SNAPSHOT.CREATE")
qresultset = self.dbclient.execute(
"select * from event where type='SNAPSHOT.CREATE' AND \
description like '%%%s%%' AND state='Completed';" %
root_volume_cluster.id)
event_validation_result = validateList(qresultset)
self.assertEqual(
event_validation_result[0], PASS,
"event list validation failed due to %s" %
event_validation_result[2])
self.assertNotEqual(len(qresultset), 0, "Check DB Query result set")
qresult = str(qresultset)
self.assertEqual(
qresult.count('SNAPSHOT.CREATE') > 0, True,
"Check SNAPSHOT.CREATE event in events table")
#Usage_Event
qresultset = self.dbclient.execute(
"select * from usage_event where type='SNAPSHOT.CREATE' AND \
resource_name='%s'" % root_vol_snap.name)
usage_event_validation_result = validateList(qresultset)
self.assertEqual(
usage_event_validation_result[0], PASS,
"event list validation failed due to %s" %
usage_event_validation_result[2])
self.assertNotEqual(len(qresultset), 0, "Check DB Query result set")
self.assertEqual(
self.dbclient.execute(
"select size from usage_event where type='SNAPSHOT.CREATE' AND \
resource_name='%s'" % root_vol_snap.name)[0][0],
root_vol_snap.physicalsize)
# Step 3
# create template from snapshot root_vol_snap
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient, root_vol_snap, self.testdata["template_2"])
self.assertNotEqual(templateFromSnapshot, None,
"Check if result exists in list item call")
vm_from_temp = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
self.assertNotEqual(vm_from_temp, None,
"Check if result exists in list item call")
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp)
vm_from_temp.delete(self.apiclient)
# Step 4
root_vol_snap.delete(self.userapiclient)
self.assertEqual(
list_snapshots(
self.apiclient,
volumeid=root_volume_cluster.id,
), None, "Snapshot list should be empty")
events = list_events(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='SNAPSHOT.DELETE')
event_list_validation_result = validateList(events)
self.assertEqual(
event_list_validation_result[0], PASS,
"event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event SNAPSHOT.DELETE")
self.debug("select id from account where uuid = '%s';" %
self.account.id)
qresultset = self.dbclient.execute(
"select id from account where uuid = '%s';" % self.account.id)
account_validation_result = validateList(qresultset)
self.assertEqual(
account_validation_result[0], PASS,
"event list validation failed due to %s" %
account_validation_result[2])
self.assertNotEqual(len(qresultset), 0, "Check DB Query result set")
qresult = qresultset[0]
account_id = qresult[0]
qresultset = self.dbclient.execute(
"select * from event where type='SNAPSHOT.DELETE' AND \
account_id='%s' AND state='Completed';" % account_id)
delete_snap_validation_result = validateList(qresultset)
self.assertEqual(
delete_snap_validation_result[0], PASS,
"event list validation failed due to %s" %
delete_snap_validation_result[2])
self.assertNotEqual(len(qresultset), 0, "Check DB Query result set")
qresult = str(qresultset)
self.assertEqual(
qresult.count('SNAPSHOT.DELETE') > 0, True,
"Check SNAPSHOT.DELETE event in events table")
# Step 5
# delete snapshot and deploy vm from snapshot
vm_from_temp_2 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
self.assertNotEqual(vm_from_temp_2, None,
"Check if result exists in list item call")
# Step 6:
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp_2)
vm_from_temp_2.delete(self.apiclient)
# Step 7
# Multiple Snapshots
self.vm_1.stop(self.apiclient)
snaps = []
for i in range(2):
root_vol_snap = Snapshot.create(self.apiclient,
root_volume_cluster.id)
self.assertEqual(
root_vol_snap.state, "BackedUp",
"Check if the data vol snapshot state is correct ")
snaps.append(root_vol_snap)
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient, root_vol_snap, self.testdata["template_2"])
self.assertNotEqual(templateFromSnapshot, None,
"Check if result exists in list item call")
vm_from_temp = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
self.assertNotEqual(vm_from_temp, None,
"Check if result exists in list item call")
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp)
vm_from_temp.delete(self.apiclient)
templateFromSnapshot.delete(self.apiclient)
self.vm_1.start(self.apiclient)
delete_snap = snaps.pop(1)
delete_snap.delete(self.apiclient)
self.assertEqual(Snapshot.list(self.apiclient, id=delete_snap.id),
None, "Snapshot list should be empty")
# Step 8
for snap in snaps:
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient, snap, self.testdata["template_2"])
self.assertNotEqual(templateFromSnapshot, None,
"Check if result exists in list item call")
vm_from_temp = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
self.assertNotEqual(vm_from_temp, None,
"Check if result exists in list item call")
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp)
templateFromSnapshot.delete(self.apiclient)
vm_from_temp.delete(self.apiclient)
for snap in snaps:
snap.delete(self.apiclient)
# Step 9
ckecksum_root_cluster = createChecksum(service=self.testdata,
virtual_machine=self.vm_1,
disk=root_volume_cluster,
disk_type="rootdiskdevice")
self.vm_1.stop(self.apiclient)
root_vol_snap_2 = Snapshot.create(self.apiclient,
root_volume_cluster.id)
self.assertEqual(root_vol_snap_2.state, "BackedUp",
"Check if the data vol snapshot state is correct ")
snap_list_validation_result = validateList(events)
self.assertEqual(
snap_list_validation_result[0], PASS,
"snapshot list validation failed due to %s" %
snap_list_validation_result[2])
self.assertNotEqual(snapshot_list, None,
"Check if result exists in list item call")
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient, root_vol_snap_2, self.testdata["template_2"])
self.debug("create template event comlites with template %s name" %
templateFromSnapshot.name)
self.assertNotEqual(templateFromSnapshot, None,
"Check if result exists in list item call")
vm_from_temp_2 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
self.assertNotEqual(vm_from_temp_2, None,
"Check if result exists in list item call")
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp_2)
vm_from_temp_2.delete(self.apiclient)
# Step 10
# Take snapshot of Data disk of a VM , when snapshot of ROOT volume of
# VM is in progress
try:
self.vm_1.stop(self.apiclient)
t1 = Thread(target=Snapshot.create,
args=(self.apiclient, root_volume_cluster.id))
t2 = Thread(target=Snapshot.create,
args=(self.apiclient, data_disk.id))
t1.start()
t2.start()
t1.join()
t2.join()
except:
self.debug("Error: unable to start thread")
# Step 11
# Data Disk
self.vm_1.start(self.apiclient)
ckecksum_data_disk = createChecksum(service=self.testdata,
virtual_machine=self.vm_1,
disk=data_disk,
disk_type="datadiskdevice_1")
data_vol_state = data_disk.state
self.vm_1.stop(self.apiclient)
data_vol_snap = Snapshot.create(self.apiclient, data_disk.id)
self.assertEqual(data_vol_snap.state, "BackedUp",
"Check if the data vol snapshot state is correct ")
self.assertEqual(data_vol_state, data_disk.state,
"Check if volume state has changed")
data_snapshot_list = list_snapshots(self.apiclient,
id=data_vol_snap.id)
self.assertNotEqual(data_snapshot_list, None,
"Check if result exists in list item call")
self.assertEqual(data_snapshot_list[0].id, data_vol_snap.id,
"Check resource id in list resources call")
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, data_vol_snap.id))
events = list_events(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='SNAPSHOT.CREATE')
event_list_validation_result = validateList(events)
self.assertEqual(
event_list_validation_result[0], PASS,
"event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event SNAPSHOT.CREATE")
self.testdata["volume"]["zoneid"] = self.zone.id
volumeFromSnap = Volume.create_from_snapshot(
self.apiclient,
data_vol_snap.id,
self.testdata["volume"],
account=self.account.name,
domainid=self.account.domainid,
)
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, data_vol_snap.id))
new_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,
mode=self.zone.networktype)
new_vm.attach_volume(self.apiclient, volumeFromSnap)
new_vm.reboot(self.apiclient)
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_data_disk,
disk_type="datadiskdevice_1",
virt_machine=new_vm)
# Step 12
data_volume_2 = Volume.create(self.apiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id)
self.vm_1.start(self.apiclient)
self.vm_1.attach_volume(self.userapiclient, data_volume_2)
self.vm_1.reboot(self.apiclient)
self.vm_1.stop(self.apiclient)
data_vol_snap_1 = Snapshot.create(self.apiclient, data_volume_2.id)
self.assertEqual(data_vol_snap_1.state, "BackedUp",
"Check if the snapshot state is correct ")
data_disk_2_list = Volume.list(self.userapiclient,
listall=self.testdata["listall"],
id=data_volume_2.id)
self.vm_1.start(self.apiclient)
checksum_data_2 = createChecksum(service=self.testdata,
virtual_machine=self.vm_1,
disk=data_disk_2_list[0],
disk_type="datadiskdevice_2")
# Step 13
self.vm_1.detach_volume(self.apiclient, data_volume_2)
self.vm_1.reboot(self.apiclient)
prev_state = data_volume_2.state
data_vol_snap_2 = Snapshot.create(self.apiclient, data_volume_2.id)
self.assertEqual(data_vol_snap_2.state, prev_state,
"Check if the volume state is correct ")
data_snapshot_list_2 = list_snapshots(self.apiclient,
id=data_vol_snap_2.id)
self.assertNotEqual(data_snapshot_list_2, None,
"Check if result exists in list item call")
self.assertEqual(data_snapshot_list_2[0].id, data_vol_snap_2.id,
"Check resource id in list resources call")
self.testdata["volume"]["zoneid"] = self.zone.id
volumeFromSnap_2 = Volume.create_from_snapshot(
self.apiclient,
data_vol_snap_2.id,
self.testdata["volume"],
account=self.account.name,
domainid=self.account.domainid,
)
self.vm_2.attach_volume(self.userapiclient, volumeFromSnap_2)
self.vm_2.reboot(self.apiclient)
data_disk_2_list = Volume.list(self.userapiclient,
listall=self.testdata["listall"],
id=volumeFromSnap_2.id)
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=checksum_data_2,
disk_type="datadiskdevice_2",
virt_machine=self.vm_2)
# Step 14
self.vm_1.stop(self.apiclient)
with self.assertRaises(Exception):
root_vol_snap.revertVolToSnapshot(self.apiclient)
# Step 15
root_snap = Snapshot.create(self.apiclient, root_volume_cluster.id)
with self.assertRaises(Exception):
root_snap.revertVolToSnapshot(self.apiclient)
return
def test_05_create_template_from_non_native_snapshot(self):
old_supports_resign = self.supports_resign
self._set_supports_resign(False)
primary_storage_db_id = self._get_cs_storage_pool_db_id(
self.primary_storage)
virtual_machine = VirtualMachine.create(
self.apiClient,
self.testdata[TestData.virtualMachine],
accountid=self.account.name,
zoneid=self.zone.id,
serviceofferingid=self.compute_offering.id,
templateid=self.template.id,
domainid=self.domain.id,
startvm=True)
self.assertEqual(virtual_machine.state.lower(), "running",
TestSnapshots._vm_not_in_running_state_err_msg)
list_volumes_response = list_volumes(
self.apiClient, virtualmachineid=virtual_machine.id, listall=True)
self._check_list(
list_volumes_response, 1,
TestSnapshots._should_only_be_one_volume_in_list_err_msg)
vm_1_root_volume = list_volumes_response[0]
dt_volume = self._get_dt_volume_for_cs_volume(vm_1_root_volume)
self.assertNotEqual(dt_volume, None,
TestSnapshots._should_be_a_valid_volume_err)
vol_snap_1 = self._create_and_test_non_native_snapshot(
vm_1_root_volume.id, primary_storage_db_id, 1,
TestSnapshots._should_only_be_one_snapshot_in_list_err_msg)
vol_snap_2 = self._create_and_test_non_native_snapshot(
vm_1_root_volume.id, primary_storage_db_id, 2,
TestSnapshots._should_be_two_snapshots_in_list_err_msg)
vol_snap_3 = self._create_and_test_non_native_snapshot(
vm_1_root_volume.id, primary_storage_db_id, 3,
TestSnapshots._should_be_three_snapshots_in_list_err_msg)
services = {
"displaytext": "Template-1",
"name": "Template-1-name",
"ostype": "CentOS 5.6 (64-bit)",
"ispublic": "true"
}
template = Template.create_from_snapshot(self.apiClient, vol_snap_2,
services)
self.cleanup.append(template)
virtual_machine_dict = {"name": "TestVM2", "displayname": "Test VM 2"}
virtual_machine_2 = VirtualMachine.create(
self.apiClient,
virtual_machine_dict,
accountid=self.account.name,
zoneid=self.zone.id,
serviceofferingid=self.compute_offering.id,
templateid=template.id,
domainid=self.domain.id,
startvm=True)
list_volumes_response = list_volumes(
self.apiClient,
virtualmachineid=virtual_machine_2.id,
listall=True)
self.assertEqual(virtual_machine_2.state.lower(), "running",
TestSnapshots._vm_not_in_running_state_err_msg)
self._check_list(
list_volumes_response, 1,
TestSnapshots._should_only_be_one_volume_in_list_err_msg)
vm_2_root_volume = list_volumes_response[0]
dt_volume_2 = self._get_dt_volume_for_cs_volume(vm_2_root_volume)
self.assertNotEqual(dt_volume_2, None,
TestSnapshots._should_be_a_valid_volume_err)
virtual_machine.delete(self.apiClient, True)
virtual_machine_2.delete(self.apiClient, True)
self._delete_and_test_non_native_snapshot(vol_snap_1)
self._delete_and_test_non_native_snapshot(vol_snap_2)
self._delete_and_test_non_native_snapshot(vol_snap_3)
self._set_supports_resign(old_supports_resign)
def test_01_list_templates_pagination(self):
"""
@Desc: Test to List Templates pagination
@steps:
Step1: Listing all the Templates for a user
Step2: Verifying that no Templates are listed
Step3: Creating (page size + 1) number of Templates
Step4: Listing all the Templates again for a user
Step5: Verifying that list size is (page size + 1)
Step6: Listing all the Templates in page1
Step7: Verifying that list size is (page size)
Step8: Listing all the Templates in page2
Step9: Verifying that list size is 1
Step10: Listing the template by Id
Step11: Verifying if the template is downloaded and ready.
If yes the continuing
If not waiting and checking for template to be ready till timeout
Step12: Deleting the Template present in page 2
Step13: Listing all the Templates in page2
Step14: Verifying that no Templates are listed
"""
# Listing all the Templates for a User
list_templates_before = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"]
)
# Verifying that no Templates are listed
self.assertIsNone(
list_templates_before,
"Templates listed for newly created User"
)
self.services["privatetemplate"]["ostype"] = self.services["ostype"]
# Creating pagesize + 1 number of Templates
for i in range(0, (self.services["pagesize"] + 1)):
template_created = Template.register(
self.userapiclient,
self.services["privatetemplate"],
self.zone.id,
hypervisor=self.hypervisor
)
self.assertIsNotNone(
template_created,
"Template creation failed"
)
# Listing all the Templates for a User
list_templates_after = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"]
)
status = validateList(list_templates_after)
self.assertEquals(
PASS,
status[0],
"Templates creation failed"
)
# Verifying that list size is pagesize + 1
self.assertEquals(
self.services["pagesize"] + 1,
len(list_templates_after),
"Failed to create pagesize + 1 number of Templates"
)
# Listing all the Templates in page 1
list_templates_page1 = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
page=1,
pagesize=self.services["pagesize"]
)
status = validateList(list_templates_page1)
self.assertEquals(
PASS,
status[0],
"Failed to list Templates in page 1"
)
# Verifying the list size to be equal to pagesize
self.assertEquals(
self.services["pagesize"],
len(list_templates_page1),
"Size of Templates in page 1 is not matching"
)
# Listing all the Templates in page 2
list_templates_page2 = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
page=2,
pagesize=self.services["pagesize"]
)
status = validateList(list_templates_page2)
self.assertEquals(
PASS,
status[0],
"Failed to list Templates in page 2"
)
# Verifying the list size to be equal to 1
self.assertEquals(
1,
len(list_templates_page2),
"Size of Templates in page 2 is not matching"
)
# Verifying the state of the template to be ready. If not waiting for
# state to become ready
template_ready = False
count = 0
while template_ready is False:
list_template = Template.list(
self.userapiclient,
id=template_created.id,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
)
status = validateList(list_template)
self.assertEquals(
PASS,
status[0],
"Failed to list Templates by Id"
)
if list_template[0].isready is True:
template_ready = True
elif (str(list_template[0].status) == "Error"):
self.fail("Created Template is in Errored state")
break
elif count > 10:
self.fail("Timed out before Template came into ready state")
break
else:
time.sleep(self.services["sleep"])
count = count + 1
# Deleting the Template present in page 2
Template.delete(
template_created,
self.userapiclient
)
# Listing all the Templates in page 2 again
list_templates_page2 = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
page=2,
pagesize=self.services["pagesize"]
)
# Verifying that there are no Templates listed
self.assertIsNone(
list_templates_page2,
"Templates not deleted from page 2"
)
del self.services["privatetemplate"]["ostype"]
return
def test_04_template_from_snapshot(self):
"""Create Template from snapshot
"""
# Validate the following
# 2. Snapshot the Root disk
# 3. Create Template from snapshot
# 4. Deploy Virtual machine using this template
# 5. VM should be in running state
if self.hypervisor.lower() in ['hyperv', 'lxc']:
self.skipTest("Snapshots feature is not supported on %s" %
self.hypervisor.lower())
userapiclient = self.testClient.getUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
volumes = Volume.list(userapiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall=True)
volume = volumes[0]
self.debug("Creating a snapshot from volume: %s" % volume.id)
# Create a snapshot of volume
snapshot = Snapshot.create(userapiclient,
volume.id,
account=self.account.name,
domainid=self.account.domainid)
self.debug("Creating a template from snapshot: %s" % snapshot.id)
# Generate template from the snapshot
template = Template.create_from_snapshot(userapiclient, snapshot,
self.services["template"])
self.cleanup.append(template)
# Verify created template
templates = Template.list(
userapiclient,
templatefilter=self.services["template"]["templatefilter"],
id=template.id)
self.assertNotEqual(templates, None,
"Check if result exists in list item call")
self.assertEqual(templates[0].id, template.id,
"Check new template id in list resources call")
self.debug("Deploying a VM from template: %s" % template.id)
# Deploy new virtual machine using template
virtual_machine = VirtualMachine.create(
userapiclient,
self.services["virtual_machine"],
templateid=template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
)
self.cleanup.append(virtual_machine)
vm_response = VirtualMachine.list(userapiclient,
id=virtual_machine.id,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(vm_response, list), True,
"Check for list VM response return valid list")
# Verify VM response to check whether VM deployment was successful
self.assertNotEqual(len(vm_response), 0,
"Check VMs available in List VMs response")
vm = vm_response[0]
self.assertEqual(vm.state, 'Running',
"Check the state of VM created from Template")
return
def test_03_edit_template_details(self):
"""
@Desc: Test to Edit Template name, displaytext, OSType
@steps:
Step1: Listing all the Templates for a user
Step2: Verifying that no Templates are listed
Step3: Creating a Templates
Step4: Listing all the Templates again for a user
Step5: Verifying that list size is 1
Step6: Verifying if the template is in ready state.
If yes the continuing
If not waiting and checking for template to be ready till timeout
Step7: Editing the template name
Step8: Verifying that Template name is edited
Step9: Editing the template displaytext
Step10: Verifying that Template displaytext is edited
Step11: Editing the template ostypeid
Step12: Verifying that Template ostypeid is edited
Step13: Editing the template name, displaytext
Step14: Verifying that Template name, displaytext are edited
Step15: Editing the template name, displaytext, ostypeid
Step16: Verifying that Template name, displaytext and ostypeid are edited
"""
# Listing all the Templates for a User
list_templates_before = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"]
)
# Verifying that no Templates are listed
self.assertIsNone(
list_templates_before,
"Templates listed for newly created User"
)
self.services["privatetemplate"]["ostype"] = self.services["ostype"]
# Creating aTemplate
template_created = Template.register(
self.userapiclient,
self.services["privatetemplate"],
self.zone.id,
hypervisor=self.hypervisor
)
self.assertIsNotNone(
template_created,
"Template creation failed"
)
# Listing all the Templates for a User
list_templates_after = Template.list(
self.userapiclient,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"]
)
status = validateList(list_templates_after)
self.assertEquals(
PASS,
status[0],
"Templates creation failed"
)
# Verifying that list size is 1
self.assertEquals(
1,
len(list_templates_after),
"Failed to create a Template"
)
# Verifying the state of the template to be ready. If not waiting for
# state to become ready till time out
template_ready = False
count = 0
while template_ready is False:
list_template = Template.list(
self.userapiclient,
id=template_created.id,
listall=self.services["listall"],
templatefilter=self.services["templatefilter"],
)
status = validateList(list_template)
self.assertEquals(
PASS,
status[0],
"Failed to list Templates by Id"
)
if list_template[0].isready is True:
template_ready = True
elif (str(list_template[0].status) == "Error"):
self.fail("Created Template is in Errored state")
break
elif count > 10:
self.fail("Timed out before Template came into ready state")
break
else:
time.sleep(self.services["sleep"])
count = count + 1
# Editing the Template name
edited_template = Template.update(
template_created,
self.userapiclient,
name="NewTemplateName"
)
self.assertIsNotNone(
edited_template,
"Editing Template failed"
)
# Verifying the details of edited template
expected_dict = {
"id": template_created.id,
"name": "NewTemplateName",
"displaytest": template_created.displaytext,
"account": template_created.account,
"domainid": template_created.domainid,
"format": template_created.format,
"ostypeid": template_created.ostypeid,
"templatetype": template_created.templatetype,
}
actual_dict = {
"id": edited_template.id,
"name": edited_template.name,
"displaytest": edited_template.displaytext,
"account": edited_template.account,
"domainid": edited_template.domainid,
"format": edited_template.format,
"ostypeid": edited_template.ostypeid,
"templatetype": edited_template.templatetype,
}
edit_template_status = self.__verify_values(
expected_dict,
actual_dict
)
self.assertEqual(
True,
edit_template_status,
"Edited Template details are not as expected"
)
# Editing the Template displaytext
edited_template = Template.update(
template_created,
self.userapiclient,
displaytext="TemplateDisplaytext"
)
self.assertIsNotNone(
edited_template,
"Editing Template failed"
)
# Verifying the details of edited template
expected_dict = {
"id": template_created.id,
"name": "NewTemplateName",
"displaytest": "TemplateDisplaytext",
"account": template_created.account,
"domainid": template_created.domainid,
"format": template_created.format,
"ostypeid": template_created.ostypeid,
"templatetype": template_created.templatetype,
}
actual_dict = {
"id": edited_template.id,
"name": edited_template.name,
"displaytest": edited_template.displaytext,
"account": edited_template.account,
"domainid": edited_template.domainid,
"format": edited_template.format,
"ostypeid": edited_template.ostypeid,
"templatetype": edited_template.templatetype,
}
edit_template_status = self.__verify_values(
expected_dict,
actual_dict
)
self.assertEqual(
True,
edit_template_status,
"Edited Template details are not as expected"
)
# Editing the Template ostypeid
ostype_list = list_os_types(self.userapiclient)
status = validateList(ostype_list)
self.assertEquals(
PASS,
status[0],
"Failed to list OS Types"
)
for i in range(0, len(ostype_list)):
if ostype_list[i].id != template_created.ostypeid:
newostypeid = ostype_list[i].id
break
edited_template = Template.update(
template_created,
self.userapiclient,
ostypeid=newostypeid
)
self.assertIsNotNone(
edited_template,
"Editing Template failed"
)
# Verifying the details of edited template
expected_dict = {
"id": template_created.id,
"name": "NewTemplateName",
"displaytest": "TemplateDisplaytext",
"account": template_created.account,
"domainid": template_created.domainid,
"format": template_created.format,
"ostypeid": newostypeid,
"templatetype": template_created.templatetype,
}
actual_dict = {
"id": edited_template.id,
"name": edited_template.name,
"displaytest": edited_template.displaytext,
"account": edited_template.account,
"domainid": edited_template.domainid,
"format": edited_template.format,
"ostypeid": edited_template.ostypeid,
"templatetype": edited_template.templatetype,
}
edit_template_status = self.__verify_values(
expected_dict,
actual_dict
)
self.assertEqual(
True,
edit_template_status,
"Edited Template details are not as expected"
)
# Editing the Template name, displaytext
edited_template = Template.update(
template_created,
self.userapiclient,
name=template_created.name,
displaytext=template_created.displaytext
)
self.assertIsNotNone(
edited_template,
"Editing Template failed"
)
# Verifying the details of edited template
expected_dict = {
"id": template_created.id,
"name": template_created.name,
"displaytest": template_created.displaytext,
"account": template_created.account,
"domainid": template_created.domainid,
"format": template_created.format,
"ostypeid": newostypeid,
"templatetype": template_created.templatetype,
}
actual_dict = {
"id": edited_template.id,
"name": edited_template.name,
"displaytest": edited_template.displaytext,
"account": edited_template.account,
"domainid": edited_template.domainid,
"format": edited_template.format,
"ostypeid": edited_template.ostypeid,
"templatetype": edited_template.templatetype,
}
edit_template_status = self.__verify_values(
expected_dict,
actual_dict
)
self.assertEqual(
True,
edit_template_status,
"Edited Template details are not as expected"
)
# Editing the Template name, displaytext, ostypeid
edited_template = Template.update(
template_created,
self.userapiclient,
name="NewTemplateName",
displaytext="TemplateDisplaytext",
ostypeid=template_created.ostypeid
)
self.assertIsNotNone(
edited_template,
"Editing Template failed"
)
# Verifying the details of edited template
expected_dict = {
"id": template_created.id,
"name": "NewTemplateName",
"displaytest": "TemplateDisplaytext",
"account": template_created.account,
"domainid": template_created.domainid,
"format": template_created.format,
"ostypeid": template_created.ostypeid,
"templatetype": template_created.templatetype,
}
actual_dict = {
"id": edited_template.id,
"name": edited_template.name,
"displaytest": edited_template.displaytext,
"account": edited_template.account,
"domainid": edited_template.domainid,
"format": edited_template.format,
"ostypeid": edited_template.ostypeid,
"templatetype": edited_template.templatetype,
}
edit_template_status = self.__verify_values(
expected_dict,
actual_dict
)
self.assertEqual(
True,
edit_template_status,
"Edited Template details are not as expected"
)
del self.services["privatetemplate"]["ostype"]
return
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_vm_nic_adapter_vmxnet3(self):
"""
# 1. Register a template for VMware with nicAdapter vmxnet3
# 2. Deploy a VM using this template
# 3. Create an isolated network
# 4. Add network to VM
# 5. Verify that the NIC adapter for VM for both the nics
# is vmxnet3
"""
if self.hypervisor.lower() not in ["vmware"]:
self.skipTest("This test case is written specifically\
for Vmware hypervisor")
# Register a private template in the account with nic adapter vmxnet3
template = Template.register(
self.userapiclient,
self.testdata["configurableData"]["vmxnet3template"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
details=[{
"nicAdapter":
self.testdata["configurableData"]["vmxnet3template"]
["nicadapter"]
}])
self.cleanup.append(template)
template.download(self.apiclient)
templates = Template.list(self.userapiclient,
listall=True,
id=template.id,
templatefilter="self")
self.assertEqual(
validateList(templates)[0], PASS,
"Templates list validation failed")
self.testdata["virtual_machine"]["zoneid"] = self.zone.id
self.testdata["virtual_machine"]["template"] = template.id
virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
isolated_network = Network.create(
self.apiclient,
self.testdata["isolated_network"],
self.account.name,
self.account.domainid,
networkofferingid=self.isolated_network_offering.id)
virtual_machine.add_nic(self.apiclient, isolated_network.id)
# TODO: Add steps to check the Nic Adapter type in VCenter
# using VCenter APIs
return
def test_01_create_template(self):
"""TS_BUG_002-Test to create and deploy VM using password enabled template
"""
# Validate the following:
#1. Create a password enabled template
#2. Deploy VM using this template
#3. Deploy VM should return password set in template.
builtin_info = get_builtin_template_info(self.apiclient, self.zone.id)
self.services["template"]["url"] = builtin_info[0]
self.services["template"]["hypervisor"] = builtin_info[1]
self.services["template"]["format"] = builtin_info[2]
self.debug("Registering a new template")
# Register new template
template = Template.register(self.apiclient,
self.services["template"],
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" %
(self.services["template"]["format"], template.id))
try:
# Wait for template to download
template.download(self.apiclient)
except Exception as e:
self.fail("Exception while downloading template %s: %s"\
% (template.id, e))
self.cleanup.append(template)
# Wait for template status to be changed across
time.sleep(self.services["sleep"])
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["template"]["templatefilter"],
id=template.id,
zoneid=self.zone.id
)
self.assertEqual(isinstance(list_template_response, list), True,
"Check list response returns a valid list")
#Verify template response to check whether template added successfully
self.assertNotEqual(len(list_template_response), 0,
"Check template available in List Templates")
template_response = list_template_response[0]
self.assertEqual(
template_response.isready, True,
"Template state is not ready, it is %s" %
template_response.isready)
# Deploy new virtual machine using template
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
)
self.debug("Deployed VM with ID: %s " % virtual_machine.id)
self.assertEqual(hasattr(virtual_machine, "password"), True,
"Check if the deployed VM returned a password")
return
def setUpClass(cls):
cls.testClient = super(TestDirectDownloadTemplates, cls).getClsTestClient()
cls.apiclient = cls.testClient.getApiClient()
cls.hypervisor = cls.testClient.getHypervisorInfo()
cls.dbclient = cls.testClient.getDbConnection()
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.pod = get_pod(cls.apiclient, cls.zone.id)
cls.services = cls.testClient.getParsedTestDataConfig()
cls._cleanup = []
cls.hypervisorSupported = False
cls.nfsStorageFound = False
cls.localStorageFound = False
cls.sharedMountPointFound = False
if cls.hypervisor.lower() in ['kvm', 'lxc']:
cls.hypervisorSupported = True
if cls.hypervisorSupported:
cls.services["test_templates"]["kvm"]["directdownload"] = "true"
cls.template = Template.register(cls.apiclient, cls.services["test_templates"]["kvm"],
zoneid=cls.zone.id, hypervisor=cls.hypervisor)
cls._cleanup.append(cls.template)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.services["virtual_machine"]["hypervisor"] = cls.hypervisor
cls.service_offering = ServiceOffering.create(
cls.apiclient,
cls.services["service_offerings"]["tiny"]
)
cls._cleanup.append(cls.service_offering)
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["l2-network_offering"],
)
cls.network_offering.update(cls.apiclient, state='Enabled')
cls.services["network"]["networkoffering"] = cls.network_offering.id
cls.l2_network = Network.create(
cls.apiclient,
cls.services["l2-network"],
zoneid=cls.zone.id,
networkofferingid=cls.network_offering.id
)
cls._cleanup.append(cls.l2_network)
cls._cleanup.append(cls.network_offering)
storage_pools = StoragePool.list(
cls.apiclient,
zoneid=cls.zone.id
)
for pool in storage_pools:
if not cls.nfsStorageFound and pool.type == "NetworkFilesystem":
cls.nfsStorageFound = True
cls.nfsPoolId = pool.id
elif not cls.localStorageFound and pool.type == "Filesystem":
cls.localStorageFound = True
cls.localPoolId = pool.id
elif not cls.sharedMountPointFound and pool.type == "SharedMountPoint":
cls.sharedMountPointFound = True
cls.sharedPoolId = pool.id
cls.nfsKvmNotAvailable = not cls.hypervisorSupported or not cls.nfsStorageFound
cls.localStorageKvmNotAvailable = not cls.hypervisorSupported or not cls.localStorageFound
cls.sharedMountPointKvmNotAvailable = not cls.hypervisorSupported or not cls.sharedMountPointFound
return
def test_03_reuse_template_name(self):
"""TS_BUG_011-Test Reusing deleted template name
"""
# Validate the following
# 1. Deploy VM using default template, small service offering
# and small data disk offering.
# 2. Perform snapshot on the root disk of this VM.
# 3. Create a template from snapshot.
# 4. Delete the template and create a new template with same name
# 5. Template should be created succesfully
# Create a snapshot from the ROOTDISK
snapshot = Snapshot.create(self.apiclient,
self.volume.id,
account=self.account.name,
domainid=self.account.domainid)
self.debug("Created snapshot with ID: %s" % snapshot.id)
snapshots = Snapshot.list(self.apiclient, id=snapshot.id)
self.assertEqual(isinstance(snapshots, list), True,
"Check list response returns a valid list")
self.assertNotEqual(snapshots, None,
"Check if result exists in list snapshots call")
self.assertEqual(snapshots[0].id, snapshot.id,
"Check snapshot id in list resources call")
# Generate template from the snapshot
template = Template.create_from_snapshot(self.apiclient,
snapshot,
self.services["template"],
random_name=False)
self.debug("Created template from snapshot: %s" % template.id)
templates = Template.list(
self.apiclient,
templatefilter=\
self.services["template"]["templatefilter"],
id=template.id
)
self.assertEqual(isinstance(templates, list), True,
"Check list response returns a valid list")
self.assertNotEqual(templates, None,
"Check if result exists in list item call")
self.assertEqual(templates[0].isready, True,
"Check new template state in list templates call")
self.debug("Deleting template: %s" % template.id)
template.delete(self.apiclient)
# Wait for some time to ensure template state is reflected in other calls
time.sleep(self.services["sleep"])
# Generate template from the snapshot
self.debug("Creating template from snapshot: %s with same name" %
template.id)
template = Template.create_from_snapshot(self.apiclient,
snapshot,
self.services["template"],
random_name=False)
templates = Template.list(
self.apiclient,
templatefilter=\
self.services["template"]["templatefilter"],
id=template.id
)
self.assertEqual(isinstance(templates, list), True,
"Check list response returns a valid list")
self.assertNotEqual(templates, None,
"Check if result exists in list item call")
self.assertEqual(templates[0].name, self.services["template"]["name"],
"Check the name of the template")
return
def test_16_create_template_volume(self):
"""Test Create template from volume
"""
noffering = NetworkOffering.list(
self.user_api_client,
name="DefaultIsolatedNetworkOfferingWithSourceNatService")
vm2network = Network.create(self.user_api_client,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=noffering[0].id,
zoneid=self.zone.id)
list_nw_response = Network.list(self.user_api_client, id=vm2network.id)
self.assertEqual(isinstance(list_nw_response, list), True,
"Check list response returns a valid networks list")
templatevm = VirtualMachine.create(
self.user_api_client,
self.services["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
networkids=vm2network.id,
serviceofferingid=self.service_offering.id,
mode=self.services['mode'],
startvm="true")
time.sleep(600)
vm_response = VirtualMachine.list(self.user_api_client,
id=templatevm.id)
self.assertNotEqual(len(vm_response), 0,
"Check VMs available in List VMs response")
vm = vm_response[0]
self.assertEqual(vm.state, 'Running',
"Check the state of VM created from Template")
templatevm.stop(self.user_api_client, forced="false")
vm_response = VirtualMachine.list(self.user_api_client,
id=templatevm.id)
vm = vm_response[0]
self.assertEqual(
vm.state, 'Stopped',
"Check the state of VM is in Stopped state before creating the Template"
)
list_volume_response = Volume.list(self.user_api_client,
virtualmachineid=vm.id,
type="ROOT",
listall=True)
#Create template from Virtual machine and Volume ID
roottemplate = Template.create(
self.user_api_client,
self.services["interop"]["template"],
volumeid=list_volume_response[0].id,
account=self.account.name,
domainid=self.domain.id,
)
time.sleep(600)
list_template_response = Template.list(
self.user_api_client,
templatefilter=\
self.services["templatefilter"],
id=roottemplate.id
)
self.assertEqual(isinstance(list_template_response, list), True,
"Check list response returns a valid list")
#Verify template response to check whether template added successfully
self.assertNotEqual(len(list_template_response), 0,
"Check template available in List Templates")
template_response = list_template_response[0]
self.assertEqual(template_response.displaytext,
self.services["interop"]["template"]["displaytext"],
"Check display text of newly created template")
name = template_response.name
self.assertEqual(
name.count(self.services["interop"]["template"]["name"]), 1,
"Check name of newly created template")
templatevm.delete(self.apiclient)
vm2network.delete(self.user_api_client)
vm3network = Network.create(self.user_api_client,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=noffering[0].id,
zoneid=self.zone.id)
list_nw_response = Network.list(self.user_api_client, id=vm3network.id)
self.assertEqual(isinstance(list_nw_response, list), True,
"Check list response returns a valid networks list")
templatevm = VirtualMachine.create(
self.user_api_client,
self.services["small"],
templateid=roottemplate.id,
networkids=vm3network.id,
serviceofferingid=self.service_offering.id,
accountid=self.account.name,
domainid=self.account.domainid,
mode=self.services['mode'],
startvm="true")
time.sleep(600)
vm_response = VirtualMachine.list(self.user_api_client,
id=templatevm.id)
self.assertNotEqual(len(vm_response), 0,
"Check VMs available in List VMs response")
vm = vm_response[0]
self.assertEqual(vm.state, 'Running',
"Check the state of VM created from Template")
# Delete the template
roottemplate.delete(self.user_api_client)
list_template_response = Template.list(
self.user_api_client,
templatefilter=\
self.services["template"]["templatefilter"],
id=roottemplate.id,
zoneid=self.zone.id
)
self.assertEqual(list_template_response, None,
"Check template available in List Templates")
templatevm.delete(self.apiclient)
vm3network.delete(self.user_api_client)
return
def setUpClass(cls):
testClient = super(TestTemplates, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls._cleanup = []
cls.services = testClient.getParsedTestDataConfig()
cls.unsupportedHypervisor = False
cls.hypervisor = testClient.getHypervisorInfo()
if cls.hypervisor.lower() in ['lxc']:
# Template creation from root volume is not supported in LXC
cls.unsupportedHypervisor = True
return
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
#populate second zone id for iso copy
cls.zones = Zone.list(cls.apiclient)
if not isinstance(cls.zones, list):
raise Exception("Failed to find zones.")
cls.disk_offering = DiskOffering.create(cls.apiclient,
cls.services["disk_offering"])
template = get_template(cls.apiclient, cls.zone.id,
cls.services["ostype"])
if 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["volume"]["diskoffering"] = cls.disk_offering.id
cls.services["volume"]["zoneid"] = cls.zone.id
cls.services["template_2"]["zoneid"] = cls.zone.id
cls.services["sourcezoneid"] = cls.zone.id
cls.services["template"]["ostypeid"] = template.ostypeid
cls.services["template_2"]["ostypeid"] = template.ostypeid
cls.services["ostypeid"] = template.ostypeid
cls.account = Account.create(cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id)
cls.user = Account.create(cls.apiclient,
cls.services["account"],
domainid=cls.domain.id)
cls.service_offering = ServiceOffering.create(
cls.apiclient, cls.services["service_offerings"])
#create virtual machine
cls.virtual_machine = VirtualMachine.create(
cls.apiclient,
cls.services["virtual_machine"],
templateid=template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
mode=cls.services["mode"])
#Stop virtual machine
cls.virtual_machine.stop(cls.apiclient)
list_volume = Volume.list(cls.apiclient,
virtualmachineid=cls.virtual_machine.id,
type='ROOT',
listall=True)
try:
cls.volume = list_volume[0]
except Exception as e:
raise Exception(
"Exception: Unable to find root volume foe VM: %s - %s" %
(cls.virtual_machine.id, e))
#Create templates for Edit, Delete & update permissions testcases
cls.template_1 = Template.create(cls.apiclient,
cls.services["template"],
cls.volume.id,
account=cls.account.name,
domainid=cls.account.domainid)
cls.template_2 = Template.create(cls.apiclient,
cls.services["template_2"],
cls.volume.id,
account=cls.account.name,
domainid=cls.account.domainid)
cls._cleanup = [
cls.service_offering, cls.disk_offering, cls.account, cls.user
]
def test_02_edit_template(self):
"""Test Edit template
"""
# Validate the following:
# 1. UI should show the edited values for template
# 2. database (vm_template table) should have updated values
new_displayText = random_gen()
new_name = random_gen()
self.template_1.update(
self.apiclient,
displaytext=new_displayText,
name=new_name,
bootable=self.services["bootable"],
passwordenabled=self.services["passwordenabled"])
self.debug("Edited template with new name: %s" % new_name)
# Sleep to ensure update reflected across all the calls
time.sleep(self.services["sleep"])
timeout = self.services["timeout"]
while True:
# Verify template response for updated attributes
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["templatefilter"],
id=self.template_1.id,
account=self.account.name,
domainid=self.account.domainid
)
if isinstance(list_template_response, list):
break
elif timeout == 0:
raise Exception("List Template failed!")
time.sleep(10)
timeout = timeout - 1
self.assertEqual(isinstance(list_template_response, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(list_template_response), 0,
"Check template available in List Templates")
template_response = list_template_response[0]
self.debug("New Name: %s" % new_displayText)
self.debug("Name in Template response: %s" %
template_response.displaytext)
self.assertEqual(template_response.displaytext, new_displayText,
"Check display text of updated template")
self.assertEqual(template_response.name, new_name,
"Check name of updated template")
self.assertEqual(
str(template_response.passwordenabled).lower(),
str(self.services["passwordenabled"]).lower(),
"Check passwordenabled field of updated template")
self.assertEqual(template_response.ostypeid, self.services["ostypeid"],
"Check OSTypeID of updated template")
return
def test_06_copy_template(self):
"""Test for copy template from one zone to another"""
# Validate the following
# 1. copy template should be successful and
# secondary storage should contain new copied template.
if len(self.zones) <= 1:
self.skipTest(
"Not enough zones available to perform copy template")
self.services["destzoneid"] = filter(
lambda z: z.id != self.services["sourcezoneid"], self.zones)[0].id
self.debug(
"Copy template from Zone: %s to %s" %
(self.services["sourcezoneid"], self.services["destzoneid"]))
self.template_2.copy(self.apiclient,
sourcezoneid=self.services["sourcezoneid"],
destzoneid=self.services["destzoneid"])
# Verify template is copied to another zone using ListTemplates
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["templatefilter"],
id=self.template_2.id,
zoneid=self.services["destzoneid"]
)
self.assertEqual(isinstance(list_template_response, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(list_template_response), 0,
"Check template extracted in List Templates")
template_response = list_template_response[0]
self.assertEqual(template_response.id, self.template_2.id,
"Check ID of the downloaded template")
self.assertEqual(template_response.zoneid, self.services["destzoneid"],
"Check zone ID of the copied template")
# Cleanup- Delete the copied template
timeout = self.services["timeout"]
while True:
time.sleep(self.services["sleep"])
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["templatefilter"],
id=self.template_2.id,
zoneid=self.services["destzoneid"]
)
self.assertEqual(isinstance(list_template_response, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(list_template_response), 0,
"Check template extracted in List Templates")
template_response = list_template_response[0]
if template_response.isready == True:
break
if timeout == 0:
raise Exception("Failed to download copied template(ID: %s)" %
template_response.id)
timeout = timeout - 1
self.template_2.delete(self.apiclient,
zoneid=self.services["destzoneid"])
return
def test_07_template_from_snapshot(self):
"""Create Template from snapshot
"""
# 1. Login to machine; create temp/test directories on data volume
# 2. Snapshot the Volume
# 3. Create Template from snapshot
# 4. Deploy Virtual machine using this template
# 5. Login to newly created virtual machine
# 6. Compare data in the root disk with the one that was written on the
# volume, it should match
userapiclient = self.testClient.getUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
random_data_0 = random_gen(size=100)
random_data_1 = random_gen(size=100)
try:
# Login to virtual machine
ssh_client = self.virtual_machine.get_ssh_client()
cmds = [
"mkdir -p %s" % self.services["paths"]["mount_dir"],
"mount %s1 %s" %
(self.services["volume"][self.hypervisor]["rootdiskdevice"],
self.services["paths"]["mount_dir"]),
"mkdir -p %s/%s/{%s,%s} " %
(self.services["paths"]["mount_dir"],
self.services["paths"]["sub_dir"],
self.services["paths"]["sub_lvl_dir1"],
self.services["paths"]["sub_lvl_dir2"]),
"echo %s > %s/%s/%s/%s" %
(random_data_0, self.services["paths"]["mount_dir"],
self.services["paths"]["sub_dir"],
self.services["paths"]["sub_lvl_dir1"],
self.services["paths"]["random_data"]),
"echo %s > %s/%s/%s/%s" %
(random_data_1, self.services["paths"]["mount_dir"],
self.services["paths"]["sub_dir"],
self.services["paths"]["sub_lvl_dir2"],
self.services["paths"]["random_data"]),
"sync",
]
for c in cmds:
self.debug(c)
result = ssh_client.execute(c)
self.debug(result)
except Exception as e:
self.fail("SSH failed for VM with IP address: %s" %
self.virtual_machine.ipaddress)
# Unmount the Volume
cmds = [
"umount %s" % (self.services["paths"]["mount_dir"]),
]
for c in cmds:
self.debug(c)
ssh_client.execute(c)
volumes = list_volumes(userapiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall=True)
self.assertEqual(isinstance(volumes, list), True,
"Check list response returns a valid list")
volume = volumes[0]
# Create a snapshot of volume
snapshot = Snapshot.create(userapiclient,
volume.id,
account=self.account.name,
domainid=self.account.domainid)
self.debug("Snapshot created from volume ID: %s" % volume.id)
# Generate template from the snapshot
template = Template.create_from_snapshot(userapiclient, snapshot,
self.services["templates"])
self.cleanup.append(template)
self.debug("Template created from snapshot ID: %s" % snapshot.id)
# Verify created template
templates = list_templates(
userapiclient,
templatefilter=self.services["templates"]["templatefilter"],
id=template.id)
self.assertNotEqual(templates, None,
"Check if result exists in list item call")
self.assertEqual(templates[0].id, template.id,
"Check new template id in list resources call")
self.debug("Deploying new VM from template: %s" % template.id)
# Deploy new virtual machine using template
new_virtual_machine = VirtualMachine.create(
userapiclient,
self.services["server_without_disk"],
templateid=template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
mode=self.services["mode"])
try:
# Login to VM & mount directory
ssh = new_virtual_machine.get_ssh_client()
cmds = [
"mkdir -p %s" % self.services["paths"]["mount_dir"],
"mount %s1 %s" %
(self.services["volume"][self.hypervisor]["rootdiskdevice"],
self.services["paths"]["mount_dir"])
]
for c in cmds:
ssh.execute(c)
returned_data_0 = ssh.execute(
"cat %s/%s/%s/%s" % (self.services["paths"]["mount_dir"],
self.services["paths"]["sub_dir"],
self.services["paths"]["sub_lvl_dir1"],
self.services["paths"]["random_data"]))
self.debug(returned_data_0)
returned_data_1 = ssh.execute(
"cat %s/%s/%s/%s" % (self.services["paths"]["mount_dir"],
self.services["paths"]["sub_dir"],
self.services["paths"]["sub_lvl_dir2"],
self.services["paths"]["random_data"]))
self.debug(returned_data_1)
except Exception as e:
self.fail("SSH failed for VM with IP address: %s" %
new_virtual_machine.ipaddress)
# Verify returned data
self.assertEqual(
random_data_0, returned_data_0[0],
"Verify newly attached volume contents with existing one")
self.assertEqual(
random_data_1, returned_data_1[0],
"Verify newly attached volume contents with existing one")
# Unmount the volume
cmds = [
"umount %s" % (self.services["paths"]["mount_dir"]),
]
try:
for c in cmds:
self.debug(c)
ssh_client.execute(c)
except Exception as e:
self.fail("SSH failed for VM with IP address: %s, Exception: %s" %
(new_virtual_machine.ipaddress, e))
return
def test_01_data_persistency_root_disk(self):
"""
Test the timing issue of root disk data sync
# 1. Write data to root disk of a VM
# 2. Create a template from the root disk of VM
# 3. Create a new VM from this template
# 4. Check that the data is present in the new VM
This is to test that data is persisted on root disk of VM or not
when template is created immediately from it
"""
ssh = self.virtual_machine.get_ssh_client()
sampleText = "This is sample data"
cmds = [
"cd /root/",
"touch testFile.txt",
"chmod 600 testFile.txt",
"echo %s >> testFile.txt" % sampleText
]
for c in cmds:
ssh.execute(c)
#Stop virtual machine
self.virtual_machine.stop(self.api_client)
list_volume = Volume.list(
self.api_client,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall=True)
if isinstance(list_volume, list):
self.volume = list_volume[0]
else:
raise Exception(
"Exception: Unable to find root volume for VM: %s" %
self.virtual_machine.id)
self.services["template"]["ostype"] = self.services["ostype"]
#Create templates for Edit, Delete & update permissions testcases
customTemplate = Template.create(
self.userapiclient,
self.services["template"],
self.volume.id,
account=self.account.name,
domainid=self.account.domainid
)
self.cleanup.append(customTemplate)
# Delete the VM - No longer needed
self.virtual_machine.delete(self.apiclient)
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=customTemplate.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
mode=self.services["mode"]
)
ssh = virtual_machine.get_ssh_client()
response = ssh.execute("cat /root/testFile.txt")
res = str(response[0])
self.assertEqual(res, sampleText, "The data %s does not match\
with sample test %s" %
(res, sampleText))
return
def test_01_positive_test_1(self):
"""
positive test for volume life cycle
# 1. Deploy a vm [vm1] with shared storage and data disk
# 2. Deploy a vm [vm2]with shared storage without data disk
# 3.
# 4. Create a new volume and attache to vm2
# 5. Detach data disk from vm1 and download it
# Variance(1-9)
# 6. Upload volume by providing url of downloaded volume in step 5
# 7. Attach the volume to a different vm - vm2
# 8. Try to delete an attached volume
# 9. Create template from root volume of VM1
# 10. Create new VM using the template created in step 9
# 11. Delete the template
# 12. Detach the disk from VM2 and re-attach the disk to VM1
# 13.
# 14.
# 15.Migrate volume(detached) and then attach to a vm and live-migrate
# 16.Upload volume of size smaller than storage.max.volume.upload.size(leaving the negative case)
# 17.NA
# 18.
# 19.NA
# 20.Detach data disks from VM2 and delete volume
"""
# 1. Deploy a vm [vm1] with shared storage and data disk
self.virtual_machine_1 = VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
zoneid=self.zone.id,
diskofferingid=self.disk_offering_1.id,
mode=self.testdata["mode"]
)
verify_vm(self, self.virtual_machine_1.id)
# List data volume for vm1
list_volume = Volume.list(self.userapiclient,
virtualmachineid=self.virtual_machine_1.id,
type='DATADISK'
)
self.assertEqual(validateList(list_volume)[0], PASS, "Check List volume response for vm id %s" % self.virtual_machine_1.id)
list_data_volume_for_vm1 = list_volume[0]
self.assertEqual(len(list_volume), 1, "There is no data disk attached to vm id:%s" % self.virtual_machine_1.id)
self.assertEqual(list_data_volume_for_vm1.virtualmachineid, str(self.virtual_machine_1.id), "Check if volume state (attached) is reflected")
# 2. Deploy a vm [vm2]with shared storage without data disk
self.virtual_machine_2 = VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
zoneid=self.zone.id,
mode=self.testdata["mode"]
)
verify_vm(self, self.virtual_machine_2.id)
#4. Create a new volume and attache to vm2
self.volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_1.id,
zoneid=self.zone.id
)
list_data_volume = Volume.list(self.userapiclient,
id=self.volume.id
)
self.assertEqual(validateList(list_data_volume)[0], PASS, "Check List volume response for volume %s" % self.volume.id)
self.assertEqual(list_data_volume[0].id, self.volume.id, "check list volume response for volume id: %s" % self.volume.id)
self.debug("volume id %s got created successfully" % list_data_volume[0].id)
# Attach volume to vm2
self.virtual_machine_2.attach_volume(self.userapiclient,
self.volume
)
verify_attach_volume(self, self.virtual_machine_2.id, self.volume.id)
#Variance
if self.zone.localstorageenabled:
# V1.Create vm3 with local storage offering
self.virtual_machine_local_3=VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_2.id,
zoneid=self.zone.id,
mode=self.testdata["mode"]
)
verify_vm(self, self.virtual_machine_local_3.id)
# V2.create two data disk on local storage
self.local_volumes = []
for i in range(2):
local_volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_local.id,
zoneid=self.zone.id
)
list_local_data_volume = Volume.list(self.userapiclient,
id=local_volume.id
)
self.assertEqual(validateList(list_local_data_volume)[0], PASS, "Check List volume response for volume %s" % local_volume.id)
self.assertEqual(list_local_data_volume[0].id, local_volume.id, "check list volume response for volume id: %s" % local_volume.id)
self.debug("volume id %s got created successfully" % list_local_data_volume[0].id)
self.local_volumes.append(local_volume)
# V3.Attach local disk to vm1
self.virtual_machine_1.attach_volume(self.userapiclient,
self.local_volumes[0]
)
verify_attach_volume(self, self.virtual_machine_1.id, self.local_volumes[0].id)
if self.list_storage:
# V4.create vm4 with zone wide storage
self.virtual_machine_zone_4 = VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.tagged_so.id,
zoneid=self.zone.id,
mode=self.testdata["mode"]
)
verify_vm(self, self.virtual_machine_zone_4.id)
# V5.Create two data disk on zone wide storage
self.zone_volumes = []
for i in range(2):
zone_volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_tagged.id,
zoneid=self.zone.id
)
list_zone_data_volume = Volume.list(self.userapiclient,
id=zone_volume.id
)
self.assertEqual(validateList(list_zone_data_volume)[0], PASS, "Check List volume response for volume %s" % zone_volume.id)
self.assertEqual(list_zone_data_volume[0].id, zone_volume.id, "check list volume response for volume id: %s" % zone_volume.id)
self.debug("volume id:%s got created successfully" % list_zone_data_volume[0].id)
self.zone_volumes.append(zone_volume)
# V6.Attach data disk running on ZWPS to VM1 (root disk on shared)
self.virtual_machine_1.attach_volume(self.userapiclient,
self.zone_volumes[0]
)
verify_attach_volume(self, self.virtual_machine_1.id, self.zone_volumes[0].id)
# V7. Create a cluster wide volume and attach to vm running on zone wide storage
self.cluster_volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_1.id,
zoneid=self.zone.id
)
list_cluster_volume = Volume.list(self.userapiclient,
id=self.cluster_volume.id
)
self.assertEqual(validateList(list_cluster_volume)[0], PASS, "Check List volume response for volume %s" % self.cluster_volume.id)
self.assertEqual(list_cluster_volume[0].id, str(self.cluster_volume.id), "volume does not exist %s" % self.cluster_volume.id)
self.debug("volume id %s got created successfuly" % list_cluster_volume[0].id)
self.virtual_machine_zone_4.attach_volume(self.userapiclient,
self.cluster_volume
)
verify_attach_volume(self, self.virtual_machine_zone_4.id, self.cluster_volume.id)
if self.list_storage and self.zone.localstorageenabled:
#V8.Attach zone wide volume to vm running on local storage
self.virtual_machine_local_3.attach_volume(self.userapiclient,
self.zone_volumes[1]
)
verify_attach_volume(self, self.virtual_machine_local_3.id, self.zone_volumes[1].id)
# V9.Attach local volume to a vm running on zone wide storage
self.virtual_machine_zone_4.attach_volume(self.userapiclient,
self.local_volumes[1]
)
verify_attach_volume(self, self.virtual_machine_zone_4.id, self.local_volumes[1].id)
# 5. Detach data disk from vm1 and download it
self.virtual_machine_1.detach_volume(self.userapiclient,
volume=list_data_volume_for_vm1
)
verify_detach_volume(self, self.virtual_machine_1.id, list_data_volume_for_vm1.id)
# download detached volume
self.extract_volume = Volume.extract(self.userapiclient,
volume_id=list_data_volume_for_vm1.id,
zoneid=self.zone.id,
mode='HTTP_DOWNLOAD'
)
self.debug("extracted url is%s :" % self.extract_volume.url)
try:
formatted_url = urllib.unquote_plus(self.extract_volume.url)
self.debug("Attempting to download volume at url %s" % formatted_url)
response = urllib.urlopen(formatted_url)
self.debug("response from volume url %s" % response.getcode())
fd, path = tempfile.mkstemp()
self.debug("Saving volume %s to path %s" % (list_data_volume_for_vm1.id, path))
os.close(fd)
with open(path, 'wb') as fd:
fd.write(response.read())
self.debug("Saved volume successfully")
except Exception:
self.fail("Extract Volume Failed with invalid URL %s (vol id: %s)" % (self.extract_volume, list_data_volume_for_vm1.id))
#Need to get format for downloaded volume ,for now using default format VHD
if "OVA" in self.extract_volume.url.upper():
self.testdata["upload_volume"]["format"] = "OVA"
if "QCOW2" in self.extract_volume.url.upper():
self.testdata["upload_volume"]["format"] = "QCOW2"
# 6. Upload volume by providing url of downloaded volume in step 5
self.upload_response = Volume.upload(self.userapiclient,
zoneid=self.zone.id,
url=self.extract_volume.url,
services=self.testdata["upload_volume"]
)
self.upload_response.wait_for_upload(self.userapiclient
)
self.debug("uploaded volume id is %s" % self.upload_response.id)
# 7. Attach the volume to a different vm - vm2
self.virtual_machine_2.attach_volume(self.userapiclient,
volume=self.upload_response
)
verify_attach_volume(self, self.virtual_machine_2.id, self.upload_response.id)
# 8. Try to delete an attached volume
try:
self.volume.delete(self.userapiclient
)
self.fail("Volume got deleted in attached state %s " % self.volume.id)
except Exception as e:
self.debug("Attached volume deletion failed because %s" % e)
#9. Create template from root volume of VM1(stop VM->create template -> start vm)
self.virtual_machine_1.stop(self.userapiclient
)
self.list_root_disk_for_vm1 = Volume.list(self.userapiclient,
virtualmachineid=self.virtual_machine_1.id,
type='ROOT'
)
self.assertEqual(validateList(self.list_root_disk_for_vm1)[0], PASS, "Check List volume response for vm %s" % self.virtual_machine_1.id)
self.assertEqual(len(self.list_root_disk_for_vm1), 1, "list root disk for vm1 is empty : %s" % self.virtual_machine_1.id)
self.template_from_vm1_root_disk = Template.create(self.userapiclient,
self.testdata["template"],
self.list_root_disk_for_vm1[0].id,
account=self.account.name,
domainid=self.account.domainid
)
list_template = Template.list(self.userapiclient,
templatefilter=self.testdata["templatefilter"],
id=self.template_from_vm1_root_disk.id
)
self.assertEqual(validateList(list_template)[0], PASS, "Check List template response for template id %s" % self.template_from_vm1_root_disk.id)
self.assertEqual(len(list_template), 1, "list template response is empty for template id : %s" % list_template[0].id)
self.assertEqual(list_template[0].id, self.template_from_vm1_root_disk.id, "list template id is not same as created template")
self.debug("Template id:%s got created successfully" % self.template_from_vm1_root_disk.id)
self.virtual_machine_1.start(self.userapiclient
)
# 10. Deploy a vm using template ,created from vm1's root disk
self.virtual_machine_3 = VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template_from_vm1_root_disk.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_1.id,
zoneid=self.zone.id,
mode=self.testdata["mode"]
)
verify_vm(self, self.virtual_machine_3.id)
# 11.delete the template created from root disk of vm1
try:
self.template_from_vm1_root_disk.delete(self.userapiclient
)
self.debug("Template id: %s got deleted successfuly" % self.template_from_vm1_root_disk.id)
except Exception as e:
raise Exception("Template deletion failed with error %s" % e)
list_template = Template.list(self.userapiclient,
templatefilter=self.testdata["templatefilter"],
id=self.template_from_vm1_root_disk.id
)
self.assertEqual(list_template, None, "Template is not deleted, id %s:" % self.template_from_vm1_root_disk.id)
self.debug("Template id%s got deleted successfully" % self.template_from_vm1_root_disk.id)
# List vm and check the state of vm
verify_vm(self, self.virtual_machine_3.id)
#12.Detach the disk from VM2 and re-attach the disk to VM1
self.virtual_machine_2.detach_volume(self.userapiclient,
volume=self.upload_response
)
verify_detach_volume(self, self.virtual_machine_2.id, self.upload_response.id)
self.virtual_machine_1.attach_volume(self.userapiclient,
volume=self.upload_response
)
verify_attach_volume(self, self.virtual_machine_1.id, self.upload_response.id)
# 15.Migrate volume(detached) and then attach to a vm and live-migrate
self.migrate_volume = Volume.create(self.userapiclient,
services=self.testdata["volume"],
diskofferingid=self.disk_offering_1.id,
zoneid=self.zone.id
)
list_volume = Volume.list(self.apiclient,
id=self.migrate_volume.id
)
self.assertEqual(validateList(list_volume)[0], PASS, "Check List volume response for volume %s" % self.migrate_volume.id)
self.assertEqual(list_volume[0].id, str(self.migrate_volume.id), "volume does not exist %s" % self.migrate_volume.id)
self.debug("volume id %s got created successfuly" % list_volume[0].id)
self.virtual_machine_1.attach_volume(self.userapiclient,
self.migrate_volume
)
verify_attach_volume(self, self.virtual_machine_1.id, self.migrate_volume.id)
self.virtual_machine_1.detach_volume(self.userapiclient,
volume=self.migrate_volume
)
verify_detach_volume(self, self.virtual_machine_1.id, self.migrate_volume.id)
list_volume = Volume.list(self.apiclient,
id=self.migrate_volume.id
)
self.assertEqual(validateList(list_volume)[0], PASS, "Check List volume response for volume %s" % self.migrate_volume.id)
self.assertEqual(list_volume[0].id, str(self.migrate_volume.id), "volume does not exist %s" % self.migrate_volume.id)
self.debug("volume id %s got created successfuly" % list_volume[0].id)
list_pool = StoragePool.list(self.apiclient,
id=list_volume[0].storageid
)
self.assertEqual(validateList(list_pool)[0], PASS, "Check List pool response for storage id %s" % list_volume[0].storageid)
self.assertGreater(len(list_pool), 0, "Check the list list storagepoolresponse for vm id: %s" % list_volume[0].storageid)
list_pools = StoragePool.list(self.apiclient,
scope=list_pool[0].scope
)
self.assertEqual(validateList(list_pools)[0], PASS, "Check List pool response for scope %s" % list_pool[0].scope)
self.assertGreater(len(list_pools), 0, "Check the list vm response for scope :%s" % list_volume[0].scope)
storagepoolid = None
for i in range(len(list_pools)):
if list_volume[0].storageid != list_pools[i].id:
storagepoolid = list_pools[i].id
break
else:
self.debug("No pool available for volume migration ")
if storagepoolid is not None:
try:
volume_migrate = Volume.migrate(self.apiclient,
storageid=storagepoolid,
volumeid=self.migrate_volume.id
)
except Exception as e:
raise Exception("Volume migration failed with error %s" % e)
self.virtual_machine_2.attach_volume(self.userapiclient,
self.migrate_volume
)
verify_attach_volume(self, self.virtual_machine_2.id, self.migrate_volume.id)
pool_for_migration = StoragePool.listForMigration(self.apiclient,
id=self.migrate_volume.id
)
self.assertEqual(validateList(pool_for_migration)[0], PASS, "Check list pool For Migration response for volume %s" % self.migrate_volume.id)
self.assertGreater(len(pool_for_migration), 0, "Check the listForMigration response for volume :%s" % self.migrate_volume.id)
try:
volume_migrate = Volume.migrate(self.apiclient,
storageid=pool_for_migration[0].id,
volumeid=self.migrate_volume.id,
livemigrate=True
)
except Exception as e:
raise Exception("Volume migration failed with error %s" % e)
else:
try:
self.migrate_volume.delete(self.userapiclient
)
self.debug("volume id:%s got deleted successfully " % self.migrate_volume.id)
except Exception as e:
raise Exception("Volume deletion failed with error %s" % e)
# 16.Upload volume of size smaller than storage.max.volume.upload.size(leaving the negative case)
self.testdata["upload_volume"]["format"] = "VHD"
volume_upload = Volume.upload(self.userapiclient,
self.testdata["upload_volume"],
zoneid=self.zone.id
)
volume_upload.wait_for_upload(self.userapiclient
)
self.debug("volume id :%s got uploaded successfully is " % volume_upload.id)
# 20.Detach data disk from vm 2 and delete the volume
self.virtual_machine_2.detach_volume(self.userapiclient,
volume=self.volume
)
verify_detach_volume(self, self.virtual_machine_2.id, self.volume.id)
try:
self.volume.delete(self.userapiclient
)
self.debug("volume id:%s got deleted successfully " % self.volume.id)
except Exception as e:
raise Exception("Volume deletion failed with error %s" % e)
def test_01_createVM_snapshotTemplate(self):
"""Test create VM, Snapshot and Template
"""
# Validate the following
# 1. Deploy VM using default template, small service offering
# and small data disk offering.
# 2. Perform snapshot on the root disk of this VM.
# 3. Create a template from snapshot.
# 4. Create a instance from above created template.
# 5. listSnapshots should list the snapshot that was created.
# 6. verify that secondary storage NFS share contains the reqd
# volume under /secondary/snapshots/$accountid/
# $volumeid/$snapshot_uuid
# 7. verify backup_snap_id was non null in the `snapshots` table
# 8. listTemplates() should return the newly created Template,
# and check for template state as READY"
# 9. listVirtualMachines() command should return the deployed VM.
# State of this VM should be Running.
# Create Virtual Machine
userapiclient = self.testClient.getUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
self.virtual_machine = VirtualMachine.create(
userapiclient,
self.services["server"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
self.debug("Created VM with ID: %s" % self.virtual_machine.id)
# Get the Root disk of VM
volumes = list_volumes(userapiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall=True)
volume = volumes[0]
# Create a snapshot from the ROOTDISK
snapshot = Snapshot.create(userapiclient, volume.id)
self.debug("Snapshot created: ID - %s" % snapshot.id)
self.cleanup.append(snapshot)
snapshots = list_snapshots(userapiclient, id=snapshot.id)
self.assertEqual(isinstance(snapshots, list), True,
"Check list response returns a valid list")
self.assertNotEqual(snapshots, None,
"Check if result exists in list snapshots call")
self.assertEqual(snapshots[0].id, snapshot.id,
"Check snapshot id in list resources call")
self.debug(
"select backup_snap_id, account_id, volume_id from snapshots where uuid = '%s';"
% snapshot.id)
snapshot_uuid = snapshot.id
# Generate template from the snapshot
template = Template.create_from_snapshot(userapiclient, snapshot,
self.services["templates"])
self.debug("Created template from snapshot: %s" % template.id)
self.cleanup.append(template)
templates = list_templates(
userapiclient,
templatefilter=self.services["templates"]["templatefilter"],
id=template.id)
self.assertNotEqual(templates, None,
"Check if result exists in list item call")
self.assertEqual(templates[0].isready, True,
"Check new template state in list templates call")
# Deploy new virtual machine using template
new_virtual_machine = VirtualMachine.create(
userapiclient,
self.services["server"],
templateid=template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
self.debug("Created VM with ID: %s from template: %s" %
(new_virtual_machine.id, template.id))
self.cleanup.append(new_virtual_machine)
# Newly deployed VM should be 'Running'
virtual_machines = list_virtual_machines(
userapiclient,
id=new_virtual_machine.id,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(virtual_machines, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(virtual_machines), 0,
"Check list virtual machines response")
for virtual_machine in virtual_machines:
self.assertEqual(virtual_machine.state, 'Running',
"Check list VM response for Running state")
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot_uuid))
return
