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_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_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_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_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 create_template(self, vm):
self.debug("Creating guest VM template")
list_volume = Volume.list(self.api_client, virtualmachineid=vm.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 with ID - %s" % vm.id)
self.pw_enabled_template = Template.create(
self.api_client,
self.test_data["template"],
self.volume.id,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertEqual(self.pw_enabled_template.passwordenabled, True, "template is not passwordenabled")
self.cleanup.append(self.pw_enabled_template)
self.debug("Created guest VM template")
def create_template(self, vm):
self.debug("Creating template")
list_volume = Volume.list(self.apiclient,
virtualmachineid=vm.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 with ID - %s" % vm.id)
self.pw_enabled_template = Template.create(
self.apiclient,
self.test_data["template"],
self.volume.id,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(self.pw_enabled_template.passwordenabled, True, "template is not passwordenabled")
self.cleanup.append(self.pw_enabled_template)
self.debug("Created template")
def create_template(self, vm):
self.debug("CREATE TEMPLATE")
list_volume = Volume.list(self.apiclient,
virtualmachineid=vm.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" % vm.id)
self.test_data["template_pr"]["ostype"] = self.test_data["ostype_pr"]
self.pw_enabled_template = Template.create(
self.apiclient,
self.test_data["template_pr"],
self.volume.id,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(self.pw_enabled_template.passwordenabled, True, "template is not passwordenabled")
self.cleanup.append(self.pw_enabled_template)
def test_04_public_template_use_in_project(self):
"""Test Templates creation in projects
"""
# 1. Create a project
# 2. Verify Public templates can be used without any restriction
# 3. Verify that template created in project can be used in project
# without any restrictions
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.apiclient, self.services["template"], volumeid=volume.id, projectid=self.project.id
)
self.cleanup.append(template_1)
# Verify Template state
self.assertEqual(template_1.isready, True, "Check Template is in ready state or not")
except Exception as e:
self.fail("Exception occured: %s" % e)
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 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_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 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
#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
cls._cleanup = []
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)
services["displaytext"] = "Debian"
services["name"] = "deb"
if options.upload_tmpl is not None:
services["hypervisor"] = "KVM"
services["format"] = "QCOW2"
services["url"] = options.upload_tmpl
if options.upload_iso is not None:
services["url"] = options.upload_iso
services["ostype"] = "Debian GNU/Linux 7(64-bit)"
services["zoneid"] = zone.id
tmp_dict = {}
if options.upload_tmpl is not None:
my_templ = Template(tmp_dict)
if my_templ.register(apiClient, services) == FAILED:
print "Uploading template failed"
tc_run_logger.debug(
"\n=== Uploading template failed ===")
exit(1)
if options.upload_iso is not None:
my_templ = Iso(tmp_dict)
if my_templ.create(apiClient, services) == FAILED:
print "Uploading template failed"
tc_run_logger.debug(
"\n=== Uploading template failed ===")
exit(1)
else:
print "Zone is not ready"
else:
print "No zones"
exit(0)
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):
cls.testClient = super(TestVMPasswordEnabled, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
domain = get_domain(cls.api_client)
zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.services['mode'] = zone.networktype
template = get_template(
cls.api_client,
zone.id,
cls.services["ostype"]
)
# Set Zones and disk offerings
cls.services["small"]["zoneid"] = zone.id
cls.services["small"]["template"] = template.id
# Create VMs, NAT Rules etc
cls.account = Account.create(
cls.api_client,
cls.services["account"],
domainid=domain.id
)
cls.small_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offerings"]["small"]
)
cls.virtual_machine = VirtualMachine.create(
cls.api_client,
cls.services["small"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.small_offering.id,
mode=cls.services["mode"]
)
networkid = cls.virtual_machine.nic[0].networkid
cls.hypervisor = cls.testClient.getHypervisorInfo()
# create egress rule to allow wget of my cloud-set-guest-password
# script
if zone.networktype.lower() == 'advanced':
EgressFireWallRule.create(
cls.api_client,
networkid=networkid,
protocol=cls.services["egress"]["protocol"],
startport=cls.services["egress"]["startport"],
endport=cls.services["egress"]["endport"],
cidrlist=cls.services["egress"]["cidrlist"])
cls.virtual_machine.password = cls.services["small"]["password"]
ssh = cls.virtual_machine.get_ssh_client()
# below steps are required to get the new password from VR
# (reset password)
# http://cloudstack.org/dl/cloud-set-guest-password
# Copy this file to /etc/init.d
# chmod +x /etc/init.d/cloud-set-guest-password
# chkconfig --add cloud-set-guest-password
cmds = [
"cd /etc/init.d;wget http://people.apache.org/~tsp/cloud-set-guest-password",
"chmod +x /etc/init.d/cloud-set-guest-password",
"chkconfig --add cloud-set-guest-password",
]
for c in cmds:
ssh.execute(c)
# Adding delay of 120 sec to avoid data loss due to timing issue
time.sleep(120)
# Stop virtual machine
cls.virtual_machine.stop(cls.api_client)
# Poll listVM to ensure VM is stopped properly
timeout = cls.services["timeout"]
while True:
time.sleep(cls.services["sleep"])
# Ensure that VM is in stopped state
list_vm_response = list_virtual_machines(
cls.api_client,
id=cls.virtual_machine.id
)
if isinstance(list_vm_response, list):
vm = list_vm_response[0]
if vm.state == 'Stopped':
break
if timeout == 0:
raise Exception(
"Failed to stop VM (ID: %s) " %
vm.id)
timeout = timeout - 1
list_volume = list_volumes(
cls.api_client,
virtualmachineid=cls.virtual_machine.id,
type='ROOT',
listall=True
)
if isinstance(list_volume, list):
cls.volume = list_volume[0]
else:
raise Exception(
"Exception: Unable to find root volume for VM: %s" %
cls.virtual_machine.id)
cls.services["template"]["ostype"] = cls.services["ostype"]
cls.services["template"]["ispublic"] = True
# Create templates for Edit, Delete & update permissions testcases
cls.pw_enabled_template = Template.create(
cls.api_client,
cls.services["template"],
cls.volume.id,
)
# Delete the VM - No longer needed
cls.virtual_machine.delete(cls.api_client, expunge=True)
cls.services["small"]["template"] = cls.pw_enabled_template.id
cls.vm = VirtualMachine.create(
cls.api_client,
cls.services["small"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.small_offering.id,
mode=cls.services["mode"]
)
cls._cleanup = [
cls.small_offering,
cls.pw_enabled_template,
cls.account
]
def test_08_pt_startvm_false_password_enabled_template(self):
""" Positive test for stopped VM test path - T10
# 1 Create a password enabled template
# 2. Deploy a new VM with password enabled template
# 3. Verify that VM is in stopped state
# 4. Start the VM, verify that it is in running state
# 5. Verify that new password is generated for the VM
"""
vm_for_template = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.defaultTemplateId,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype,
networkids=[self.networkid, ] if self.networkid else None)
vm_for_template.password = self.testdata["virtual_machine"]["password"]
ssh = vm_for_template.get_ssh_client()
# below steps are required to get the new password from
# VR(reset password)
# http://cloudstack.org/dl/cloud-set-guest-password
# Copy this file to /etc/init.d
# chmod +x /etc/init.d/cloud-set-guest-password
# chkconfig --add cloud-set-guest-password
# similar steps to get SSH key from web so as to make it ssh enabled
cmds = [
"cd /etc/init.d;wget http://people.apache.org/~tsp/\
cloud-set-guest-password",
"chmod +x /etc/init.d/cloud-set-guest-password",
"chkconfig --add cloud-set-guest-password"]
for c in cmds:
ssh.execute(c)
# Stop virtual machine
vm_for_template.stop(self.userapiclient)
list_volume = Volume.list(
self.userapiclient,
virtualmachineid=vm_for_template.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" %
vm_for_template.id)
self.testdata["template"]["ostype"] = self.testdata["ostype"]
# Create templates for Edit, Delete & update permissions testcases
pw_ssh_enabled_template = Template.create(
self.userapiclient,
self.testdata["template"],
self.volume.id,
account=self.account.name,
domainid=self.account.domainid
)
self.cleanup.append(pw_ssh_enabled_template)
# Delete the VM - No longer needed
vm_for_template.delete(self.apiclient)
# Create VM in account
virtual_machine = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.defaultTemplateId,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
startvm=False,
mode=self.zone.networktype,
networkids=[self.networkid, ] if self.networkid else None
)
self.cleanup.append(virtual_machine)
response = virtual_machine.getState(
self.apiclient,
VirtualMachine.STOPPED)
self.assertEqual(response[0], PASS, response[1])
virtual_machine.start(self.userapiclient)
vms = virtual_machine.list(
self.userapiclient,
id=virtual_machine.id,
listall=True)
self.assertEqual(
validateList(vms)[0],
PASS,
"vms list validation failed"
)
self.assertNotEqual(
str(vms[0].password),
str(virtual_machine.password),
"New password should be generated for the VM"
)
return
def test_02_template_permissions(self):
"""
@Desc: Test to create Public Template by registering or by snapshot and volume when
Global parameter 'allow.public.user.template' is set to False
@steps:
1.Set Global parameter 'allow.public.user.template' as False. Restart Management server
2. Create a domain
3. Create a domain admin and a domain user
4. Create a vm as domain user
5. take snapshot of root disk as user vm
6. try to create public template from snapshot . It should fail
7. stop the VM
8. take the public template from volume. it should fail
9. register a public template as a domain user . it should fail
10. create a VM as domain admin
11. create a snapshot of root disk as domain admin
12 create a public template of the snapshot .it should fail
13. Register a public template as domain admin. it should fail
14 Stop the vm as domain admin
15. Create a template from volume as domain admin . it should fail
"""
self.updateConfigurAndRestart("allow.public.user.templates", "false")
user_account = Account.create(
self.apiclient,
self.testdata["account2"],
admin=False,
domainid=self.domain.id
)
admin_user = self.account.user[0]
self.admin_api_client = self.testClient.getUserApiClient(
admin_user.username,
self.domain.name)
user = user_account.user[0]
self.user_api_client = self.testClient.getUserApiClient(
user.username,
self.domain.name)
self.testdata["templates"]["ispublic"] = True
# Register new public template as domain user
# Exception should be raised for registering public template
try:
template = Template.register(
self.user_api_client,
self.testdata["templates"],
zoneid=self.zone.id,
account=user_account.name,
domainid=user_account.domainid,
hypervisor=self.hypervisor
)
self.updateConfigurAndRestart("allow.public.user.templates", "true")
self.fail("Template creation passed for user")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
# Register new public template as domain admin
# Exception should be raised for registering public template
try:
template = Template.register(
self.admin_api_client,
self.testdata["templates"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
hypervisor=self.hypervisor
)
self.updateConfigurAndRestart("allow.public.user.templates", "true")
self.fail("Template creation passed for domain admin")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
user_vm_created = VirtualMachine.create(
self.user_api_client,
self.testdata["virtual_machine"],
accountid=user_account.name,
domainid=user_account.domainid,
serviceofferingid=self.service_offering.id,
)
self.assertIsNotNone(user_vm_created,
"VM creation failed"
)
# Get the Root disk of VM
volume = list_volumes(
self.user_api_client,
virtualmachineid=user_vm_created.id,
type='ROOT',
listall=True
)
snapshot_created = Snapshot.create(
self.user_api_client,
volume[0].id,
account=user_account.name,
domainid=user_account.domainid
)
self.assertIsNotNone(
snapshot_created,
"Snapshot creation failed"
)
self.debug("Creating a template from snapshot: %s" % snapshot_created.id)
#
# Generate public template from the snapshot
self.testdata["template"]["ispublic"] = True
try:
user_template = Template.create_from_snapshot(
self.user_api_client,
snapshot_created,
self.testdata["template"]
)
self.updateConfigurAndRestart("allow.public.user.templates", "true")
self.fail("Template creation passed from snapshot for domain user")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
VirtualMachine.stop(user_vm_created, self.user_api_client)
list_stopped_vms_after = VirtualMachine.list(
self.user_api_client,
listall=self.testdata["listall"],
domainid=user_account.domainid,
state="Stopped")
status = validateList(list_stopped_vms_after)
self.assertEquals(
PASS,
status[0],
"Stopped VM is not in Stopped state"
)
try:
user_template = Template.create(
self.user_api_client, self.testdata["template"],
volume[0].id
)
self.updateConfigurAndRestart("allow.public.user.templates", "true")
self.fail("Template creation passed from volume for domain user")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
admin_vm_created = VirtualMachine.create(
self.admin_api_client,
self.testdata["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
)
self.assertIsNotNone(
admin_vm_created,
"VM creation failed"
)
# Get the Root disk of VM
volume = list_volumes(
self.admin_api_client,
virtualmachineid=admin_vm_created.id,
type='ROOT',
listall=True
)
snapshot_created = Snapshot.create(
self.admin_api_client,
volume[0].id,
account=self.account.name,
domainid=self.account.domainid
)
self.assertIsNotNone(
snapshot_created,
"Snapshot creation failed"
)
self.debug("Creating a template from snapshot: %s" % snapshot_created.id)
#
# Generate public template from the snapshot
try:
admin_template = Template.create_from_snapshot(
self.admin_api_client,
snapshot_created,
self.testdata["template"]
)
self.updateConfigurAndRestart("allow.public.user.templates", "true")
self.fail("Template creation passed from snapshot for domain admin")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
VirtualMachine.stop(admin_vm_created, self.admin_api_client)
list_stopped_vms_after = VirtualMachine.list(
self.admin_api_client,
listall=self.testdata["listall"],
domainid=self.account.domainid,
state="Stopped")
status = validateList(list_stopped_vms_after)
self.assertEquals(
PASS,
status[0],
"Stopped VM is not in Stopped state"
)
try:
admin_template = Template.create(
self.admin_api_client, self.testdata["template"],
volume[0].id
)
self.updateConfigurAndRestart("allow.public.user.templates", "true")
self.fail("Template creation passed from volume for domain admin")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
self.updateConfigurAndRestart("allow.public.user.templates", "true")
return
def test_02_create__template_new_resized_rootvolume_size(self):
"""Test create Template resized root volume
# Validate the following
# 1. Deploy a VM without any disk offering (only root disk)
# 2. Perform(resize) of the root volume
# 3. Stop the vm
# 4. Create a template from resized root volume
"""
result = self.setupAccounts()
self.assertEqual(result[0], PASS, result[1])
apiclient = self.testClient.getUserApiClient(
UserName=self.parentd_admin.name,
DomainName=self.parentd_admin.domain)
self.assertNotEqual(
apiclient, FAILED, "Failed to get api client\
of account: %s" % self.parentd_admin.name)
# deploy a vm
try:
if self.updateclone:
self.virtual_machine = VirtualMachine.create(
apiclient,
self.services["virtual_machine"],
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.services_offering_vmware.id,
mode=self.zone.networktype)
else:
self.virtual_machine = VirtualMachine.create(
apiclient,
self.services["virtual_machine"],
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype)
# listVirtual macine
list_vms = VirtualMachine.list(apiclient,
id=self.virtual_machine.id)
self.debug("Verify listVirtualMachines response"
" for virtual machine: %s" % self.virtual_machine.id)
res = validateList(list_vms)
self.assertNotEqual(res[2], INVALID_INPUT, "Invalid list response")
self.cleanup.append(self.virtual_machine)
vm = list_vms[0]
self.assertEqual(vm.id, self.virtual_machine.id,
"Virtual Machine ids do not match")
self.assertEqual(vm.name, self.virtual_machine.name,
"Virtual Machine names do not match")
self.assertEqual(vm.state,
"Running",
msg="VM is not in Running state")
# get root vol from created vm, verify it is correct size
list_volume_response = Volume.list(
apiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall='True')
res = validateList(list_volume_response)
self.assertNotEqual(
res[2], INVALID_INPUT,
"listVolumes returned invalid object in response")
rootvolume = list_volume_response[0]
newsize = (rootvolume.size >> 30) + 2
result = self.chk_volume_resize(apiclient, vm)
if result:
try:
# create a template from stopped VM instances root volume
if vm.state == "Running":
self.virtual_machine.stop(apiclient)
template_from_root = Template.create(
apiclient,
self.services["template"],
volumeid=rootvolume.id,
account=self.parentd_admin.name,
domainid=self.parent_domain.id)
list_template_response = Template.list(
apiclient,
id=template_from_root.id,
templatefilter="all")
res = validateList(list_template_response)
self.assertNotEqual(
res[2], INVALID_INPUT,
"Check if template exists in ListTemplates")
# Deploy new virtual machine using template
self.virtual_machine2 = VirtualMachine.create(
apiclient,
self.services["virtual_machine"],
templateid=template_from_root.id,
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.service_offering.id,
)
vm_response = VirtualMachine.list(
apiclient,
id=self.virtual_machine2.id,
account=self.parentd_admin.name,
domainid=self.parent_domain.id)
res = validateList(vm_response)
self.assertNotEqual(
res[2], INVALID_INPUT,
"Check for list VM response return valid list")
self.cleanup.append(self.virtual_machine2)
self.cleanup.reverse()
vm2 = vm_response[0]
self.assertEqual(
vm2.state, 'Running',
"Check the state of VM created from Template")
list_volume_response = Volume.list(apiclient,
virtualmachineid=vm2.id,
type='ROOT',
listall='True')
self.assertEqual(
list_volume_response[0].size,
(newsize * 1024 * 1024 * 1024),
"Check for root volume size not matched with template size"
)
except Exception as e:
raise Exception("Exception while resizing the "
"root volume: %s" % e)
else:
self.debug(" volume resize failed for root volume")
except Exception as e:
raise Exception("Exception while performing"
" template creation from "
"resized_root_volume : %s" % e)
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
)
self.debug("Deploying VM for account: %s" % self.account.name)
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,
virtualmachineid=virtual_machine_1.id,
projectid=self.project.id,
type='ROOT'
)
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,
projectid=self.project.id
)
self.cleanup.append(template_1)
# Verify Template state
self.assertEqual(
template_1.isready,
True,
"Check Template is in ready state or not"
)
# Exception should be raised for second template
with self.assertRaises(Exception):
Template.create(
self.userapiclient,
self.services["template"],
volumeid=volume.id,
projectid=self.project.id
)
return
def test_02_create__template_new_resized_rootvolume_size(self):
"""Test create Template resized root volume
# Validate the following
# 1. Deploy a VM without any disk offering (only root disk)
# 2. Perform(resize) of the root volume
# 3. Stop the vm
# 4. Create a template from resized root volume
"""
result = self.setupAccounts()
self.assertEqual(result[0], PASS, result[1])
apiclient = self.testClient.getUserApiClient(
UserName=self.parentd_admin.name,
DomainName=self.parentd_admin.domain)
self.assertNotEqual(apiclient, FAILED, "Failed to get api client\
of account: %s" % self.parentd_admin.name)
# deploy a vm
try:
if self.updateclone:
self.virtual_machine = VirtualMachine.create(
apiclient, self.services["virtual_machine"],
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.services_offering_vmware.id,
mode=self.zone.networktype
)
else:
self.virtual_machine = VirtualMachine.create(
apiclient, self.services["virtual_machine"],
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype
)
# listVirtual macine
list_vms = VirtualMachine.list(apiclient,
id=self.virtual_machine.id)
self.debug("Verify listVirtualMachines response"
" for virtual machine: %s" % self.virtual_machine.id
)
res = validateList(list_vms)
self.assertNotEqual(res[2], INVALID_INPUT, "Invalid list response")
self.cleanup.append(self.virtual_machine)
vm = list_vms[0]
self.assertEqual(
vm.id,
self.virtual_machine.id,
"Virtual Machine ids do not match"
)
self.assertEqual(
vm.name,
self.virtual_machine.name,
"Virtual Machine names do not match"
)
self.assertEqual(
vm.state,
"Running",
msg="VM is not in Running state"
)
# get root vol from created vm, verify it is correct size
list_volume_response = Volume.list(
apiclient,
virtualmachineid=
self.virtual_machine.id,
type='ROOT',
listall='True'
)
res = validateList(list_volume_response)
self.assertNotEqual(res[2], INVALID_INPUT, "listVolumes returned invalid object in response")
rootvolume = list_volume_response[0]
newsize = (rootvolume.size >> 30) + 2
result = self.chk_volume_resize(apiclient, vm)
if result:
try:
# create a template from stopped VM instances root volume
if vm.state == "Running":
self.virtual_machine.stop(apiclient)
template_from_root = Template.create(
apiclient,
self.services["template"],
volumeid=rootvolume.id,
account=self.parentd_admin.name,
domainid=self.parent_domain.id)
list_template_response = Template.list(
apiclient,
id=template_from_root.id,
templatefilter="all")
res = validateList(list_template_response)
self.assertNotEqual(res[2], INVALID_INPUT, "Check if template exists in ListTemplates")
# Deploy new virtual machine using template
self.virtual_machine2 = VirtualMachine.create(
apiclient,
self.services["virtual_machine"],
templateid=template_from_root.id,
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.service_offering.id,
)
vm_response = VirtualMachine.list(
apiclient,
id=self.virtual_machine2.id,
account=self.parentd_admin.name,
domainid=self.parent_domain.id
)
res = validateList(vm_response)
self.assertNotEqual(res[2], INVALID_INPUT, "Check for list VM response return valid list")
self.cleanup.append(self.virtual_machine2)
self.cleanup.reverse()
vm2 = vm_response[0]
self.assertEqual(
vm2.state,
'Running',
"Check the state of VM created from Template"
)
list_volume_response = Volume.list(
apiclient,
virtualmachineid=vm2.id,
type='ROOT',
listall='True'
)
self.assertEqual(
list_volume_response[0].size,
(newsize * 1024 * 1024 * 1024),
"Check for root volume size not matched with template size"
)
except Exception as e:
raise Exception("Exception while resizing the "
"root volume: %s" % e)
else:
self.debug(" volume resize failed for root volume")
except Exception as e:
raise Exception("Exception while performing"
" template creation from "
"resized_root_volume : %s" % e)
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.testClient = super(TestVMPasswordEnabled, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
domain = get_domain(cls.api_client)
zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.services['mode'] = zone.networktype
template = get_template(cls.api_client, zone.id,
cls.services["ostype"])
# Set Zones and disk offerings
cls.services["small"]["zoneid"] = zone.id
cls.services["small"]["template"] = template.id
# Create VMs, NAT Rules etc
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=domain.id)
cls.small_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offerings"]["small"])
cls.virtual_machine = VirtualMachine.create(
cls.api_client,
cls.services["small"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.small_offering.id,
mode=cls.services["mode"])
networkid = cls.virtual_machine.nic[0].networkid
cls.hypervisor = cls.testClient.getHypervisorInfo()
if cls.hypervisor.lower() in ['lxc']:
raise unittest.SkipTest(
"template creation is not supported on %s" % cls.hypervisor)
# create egress rule to allow wget of my cloud-set-guest-password
# script
if zone.networktype.lower() == 'advanced':
EgressFireWallRule.create(
cls.api_client,
networkid=networkid,
protocol=cls.services["egress"]["protocol"],
startport=cls.services["egress"]["startport"],
endport=cls.services["egress"]["endport"],
cidrlist=cls.services["egress"]["cidrlist"])
cls.virtual_machine.password = cls.services["small"]["password"]
ssh = cls.virtual_machine.get_ssh_client()
# below steps are required to get the new password from VR
# (reset password)
# http://cloudstack.org/dl/cloud-set-guest-password
# Copy this file to /etc/init.d
# chmod +x /etc/init.d/cloud-set-guest-password
# chkconfig --add cloud-set-guest-password
cmds = [
"cd /etc/init.d;wget http://people.apache.org/~tsp/cloud-set-guest-password",
"chmod +x /etc/init.d/cloud-set-guest-password",
"chkconfig --add cloud-set-guest-password",
]
for c in cmds:
ssh.execute(c)
# Adding delay of 120 sec to avoid data loss due to timing issue
time.sleep(120)
# Stop virtual machine
cls.virtual_machine.stop(cls.api_client)
# Poll listVM to ensure VM is stopped properly
timeout = cls.services["timeout"]
while True:
time.sleep(cls.services["sleep"])
# Ensure that VM is in stopped state
list_vm_response = list_virtual_machines(cls.api_client,
id=cls.virtual_machine.id)
if isinstance(list_vm_response, list):
vm = list_vm_response[0]
if vm.state == 'Stopped':
break
if timeout == 0:
raise Exception("Failed to stop VM (ID: %s) " % vm.id)
timeout = timeout - 1
list_volume = list_volumes(cls.api_client,
virtualmachineid=cls.virtual_machine.id,
type='ROOT',
listall=True)
if isinstance(list_volume, list):
cls.volume = list_volume[0]
else:
raise Exception(
"Exception: Unable to find root volume for VM: %s" %
cls.virtual_machine.id)
cls.services["template"]["ostype"] = cls.services["ostype"]
cls.services["template"]["ispublic"] = True
# Create templates for Edit, Delete & update permissions testcases
cls.pw_enabled_template = Template.create(
cls.api_client,
cls.services["template"],
cls.volume.id,
)
# Delete the VM - No longer needed
cls.virtual_machine.delete(cls.api_client, expunge=True)
cls.services["small"]["template"] = cls.pw_enabled_template.id
cls.vm = VirtualMachine.create(cls.api_client,
cls.services["small"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.small_offering.id,
mode=cls.services["mode"])
cls._cleanup = [
cls.small_offering, cls.pw_enabled_template, cls.account
]
def test_02_template_permissions(self):
"""
@Desc: Test to create Public Template by registering or by snapshot and volume when
Global parameter 'allow.public.user.template' is set to False
@steps:
1.Set Global parameter 'allow.public.user.template' as False. Restart Management server
2. Create a domain
3. Create a domain admin and a domain user
4. Create a vm as domain user
5. take snapshot of root disk as user vm
6. try to create public template from snapshot . It should fail
7. stop the VM
8. take the public template from volume. it should fail
9. register a public template as a domain user . it should fail
10. create a VM as domain admin
11. create a snapshot of root disk as domain admin
12 create a public template of the snapshot .it should fail
13. Register a public template as domain admin. it should fail
14 Stop the vm as domain admin
15. Create a template from volume as domain admin . it should fail
"""
self.updateConfigurAndRestart("allow.public.user.templates", "false")
user_account = Account.create(self.apiclient,
self.testdata["account2"],
admin=False,
domainid=self.domain.id)
admin_user = self.account.user[0]
self.admin_api_client = self.testClient.getUserApiClient(
admin_user.username, self.domain.name)
user = user_account.user[0]
self.user_api_client = self.testClient.getUserApiClient(
user.username, self.domain.name)
self.testdata["templates"]["ispublic"] = True
# Register new public template as domain user
# Exception should be raised for registering public template
try:
template = Template.register(self.user_api_client,
self.testdata["templates"],
zoneid=self.zone.id,
account=user_account.name,
domainid=user_account.domainid,
hypervisor=self.hypervisor)
self.updateConfigurAndRestart("allow.public.user.templates",
"true")
self.fail("Template creation passed for user")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
# Register new public template as domain admin
# Exception should be raised for registering public template
try:
template = Template.register(self.admin_api_client,
self.testdata["templates"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
hypervisor=self.hypervisor)
self.updateConfigurAndRestart("allow.public.user.templates",
"true")
self.fail("Template creation passed for domain admin")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
if self.hypervisor.lower() in ['hyperv', 'lxc']:
self.updateConfigurAndRestart("allow.public.user.templates",
"true")
return
else:
user_vm_created = VirtualMachine.create(
self.user_api_client,
self.testdata["virtual_machine"],
accountid=user_account.name,
domainid=user_account.domainid,
serviceofferingid=self.service_offering.id,
)
self.assertIsNotNone(user_vm_created, "VM creation failed")
# Get the Root disk of VM
volume = list_volumes(self.user_api_client,
virtualmachineid=user_vm_created.id,
type='ROOT',
listall=True)
snapshot_created = Snapshot.create(self.user_api_client,
volume[0].id,
account=user_account.name,
domainid=user_account.domainid)
self.assertIsNotNone(snapshot_created, "Snapshot creation failed")
self.debug("Creating a template from snapshot: %s" %
snapshot_created.id)
#
# Generate public template from the snapshot
self.testdata["template"]["ispublic"] = True
try:
user_template = Template.create_from_snapshot(
self.user_api_client, snapshot_created,
self.testdata["template"])
self.updateConfigurAndRestart("allow.public.user.templates",
"true")
self.fail(
"Template creation passed from snapshot for domain user")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
VirtualMachine.stop(user_vm_created, self.user_api_client)
list_stopped_vms_after = VirtualMachine.list(
self.user_api_client,
listall=self.testdata["listall"],
domainid=user_account.domainid,
state="Stopped")
status = validateList(list_stopped_vms_after)
self.assertEqual(PASS, status[0],
"Stopped VM is not in Stopped state")
try:
user_template = Template.create(self.user_api_client,
self.testdata["template"],
volume[0].id)
self.updateConfigurAndRestart("allow.public.user.templates",
"true")
self.fail(
"Template creation passed from volume for domain user")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
admin_vm_created = VirtualMachine.create(
self.admin_api_client,
self.testdata["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
)
self.assertIsNotNone(admin_vm_created, "VM creation failed")
# Get the Root disk of VM
volume = list_volumes(self.admin_api_client,
virtualmachineid=admin_vm_created.id,
type='ROOT',
listall=True)
snapshot_created = Snapshot.create(self.admin_api_client,
volume[0].id,
account=self.account.name,
domainid=self.account.domainid)
self.assertIsNotNone(snapshot_created, "Snapshot creation failed")
self.debug("Creating a template from snapshot: %s" %
snapshot_created.id)
#
# Generate public template from the snapshot
try:
admin_template = Template.create_from_snapshot(
self.admin_api_client, snapshot_created,
self.testdata["template"])
self.updateConfigurAndRestart("allow.public.user.templates",
"true")
self.fail(
"Template creation passed from snapshot for domain admin")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
VirtualMachine.stop(admin_vm_created, self.admin_api_client)
list_stopped_vms_after = VirtualMachine.list(
self.admin_api_client,
listall=self.testdata["listall"],
domainid=self.account.domainid,
state="Stopped")
status = validateList(list_stopped_vms_after)
self.assertEqual(PASS, status[0],
"Stopped VM is not in Stopped state")
try:
admin_template = Template.create(self.admin_api_client,
self.testdata["template"],
volume[0].id)
self.updateConfigurAndRestart("allow.public.user.templates",
"true")
self.fail(
"Template creation passed from volume for domain admin")
except CloudstackAPIException as e:
self.assertRaises("Exception Raised : %s" % e)
self.updateConfigurAndRestart("allow.public.user.templates",
"true")
return
def test_19_template_tag(self):
""" Test creation, listing and deletion tag on templates
"""
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_09_copy_delete_template(self):
cmd = listZones.listZonesCmd()
zones = self.apiclient.listZones(cmd)
if not isinstance(zones, list):
raise Exception("Failed to find zones.")
if len(zones) < 2:
self.skipTest(
"Skipping test due to there are less than two zones.")
return
self.sourceZone = zones[0]
self.destZone = zones[1]
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")
#Copy template from zone1 to zone2
copytemplate = Template.copy(cls.apiclient,
zoneid=cls.sourceZone.id,
destzoneid=cls.destZone.id)
cls._cleanup.append(cls.copytemplate)
list_template_response = Template.list(
self.apiclient,
templatefilter=self.services["template"]["templatefilter"],
id=self.template.id,
zoneid=self.destZone.id)
self.assertEqual(list_template_response, None,
"Check template available in List Templates")
self.deltemplate = list_template_response[0]
self.debug("Deleting template: %s" % self.deltemplate)
# Delete the template
self.deltemplate.delete(self.apiclient)
self.debug("Delete template: %s successful" % self.deltemplate)
copytemplate = Template.copy(self.apiclient,
zoneid=self.sourceZone.id,
destzoneid=self.destZone.id)
removed = cls.dbclient.execute(
"select removed from template_zone_ref where zone_id='%s' and template_id='%s';"
% self.destZone.id, self.template.id)
self.assertEqual(removed, NULL, "Removed state is not correct.")
return
def test_08_pt_startvm_false_password_enabled_template(self):
""" Positive test for stopped VM test path - T10
# 1 Create a password enabled template
# 2. Deploy a new VM with password enabled template
# 3. Verify that VM is in stopped state
# 4. Start the VM, verify that it is in running state
# 5. Verify that new password is generated for the VM
"""
vm_for_template = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.defaultTemplateId,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype,
networkids=[
self.networkid,
] if self.networkid else None)
vm_for_template.password = self.testdata["virtual_machine"]["password"]
ssh = vm_for_template.get_ssh_client()
# below steps are required to get the new password from
# VR(reset password)
# http://cloudstack.org/dl/cloud-set-guest-password
# Copy this file to /etc/init.d
# chmod +x /etc/init.d/cloud-set-guest-password
# chkconfig --add cloud-set-guest-password
# similar steps to get SSH key from web so as to make it ssh enabled
cmds = [
"cd /etc/init.d;wget http://people.apache.org/~tsp/\
cloud-set-guest-password",
"chmod +x /etc/init.d/cloud-set-guest-password",
"chkconfig --add cloud-set-guest-password"
]
for c in cmds:
ssh.execute(c)
# Stop virtual machine
vm_for_template.stop(self.userapiclient)
list_volume = Volume.list(self.userapiclient,
virtualmachineid=vm_for_template.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" %
vm_for_template.id)
self.testdata["template"]["ostype"] = self.testdata["ostype"]
# Create templates for Edit, Delete & update permissions testcases
pw_ssh_enabled_template = Template.create(
self.userapiclient,
self.testdata["template"],
self.volume.id,
account=self.account.name,
domainid=self.account.domainid)
self.cleanup.append(pw_ssh_enabled_template)
# Delete the VM - No longer needed
vm_for_template.delete(self.apiclient)
# Create VM in account
virtual_machine = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.defaultTemplateId,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
startvm=False,
mode=self.zone.networktype,
networkids=[
self.networkid,
] if self.networkid else None)
self.cleanup.append(virtual_machine)
response = virtual_machine.getState(self.apiclient,
VirtualMachine.STOPPED)
self.assertEqual(response[0], PASS, response[1])
virtual_machine.start(self.userapiclient)
vms = virtual_machine.list(self.userapiclient,
id=virtual_machine.id,
listall=True)
self.assertEqual(
validateList(vms)[0], PASS, "vms list validation failed")
self.assertNotEqual(str(vms[0].password),
str(virtual_machine.password),
"New password should be generated for the VM")
return
if zone.allocationstate == 'Enabled':
services = {}
services["displaytext"] = "Debian"
services["name"] = "deb"
if options.upload_tmpl is not None:
services["hypervisor"] = "KVM"
services["format"] = "QCOW2"
services["url"] = options.upload_tmpl
if options.upload_iso is not None:
services["url"] = options.upload_iso
services["ostype"] = "Debian GNU/Linux 7(64-bit)"
services["zoneid"] = zone.id
tmp_dict = {}
if options.upload_tmpl is not None:
my_templ = Template(tmp_dict)
if my_templ.register(apiClient, services) == FAILED:
print "Uploading template failed"
tc_run_logger.debug("\n=== Uploading template failed ===");
exit(1)
if options.upload_iso is not None:
my_templ = Iso(tmp_dict)
if my_templ.create(apiClient, services) == FAILED:
print "Uploading template failed"
tc_run_logger.debug("\n=== Uploading template failed ===");
exit(1)
else:
print "Zone is not ready"
else:
print "No zones"
exit(0)
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 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"]["tiny"]
)
#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 setUpClass(cls):
testClient = super(TestListIdsParams, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = testClient.getParsedTestDataConfig()
cls.hypervisor = testClient.getHypervisorInfo()
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.disk_offering = DiskOffering.create(cls.apiclient,
cls.services["disk_offering"])
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"])
template = get_test_template(cls.apiclient, cls.zone.id,
cls.hypervisor)
if template == FAILED:
assert False, "get_test_template() failed to return template"
cls.services["template"]["ostypeid"] = template.ostypeid
cls.services["template_2"]["ostypeid"] = template.ostypeid
cls.services["ostypeid"] = template.ostypeid
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["mode"] = cls.zone.networktype
#Create 3 VMs
cls.virtual_machine_1 = 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"])
cls.virtual_machine_2 = 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"])
cls.virtual_machine_3 = 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"])
# Take 3 VM1 Snapshots
# PLEASE UNCOMMENT ONCE VM SNAPSHOT DELAY BUG AFTER VM CREATION IS FIXED
# cls.vmsnapshot_1 = VmSnapshot.create(
# cls.apiclient,
# cls.virtual_machine_1.id
# )
# cls.vmsnapshot_2 = VmSnapshot.create(
# cls.apiclient,
# cls.virtual_machine_1.id
# )
# cls.vmsnapshot_3 = VmSnapshot.create(
# cls.apiclient,
# cls.virtual_machine_1.id
# )
#Stop VMs
cls.virtual_machine_1.stop(cls.apiclient)
cls.virtual_machine_2.stop(cls.apiclient)
cls.virtual_machine_3.stop(cls.apiclient)
#Get ROOT volumes of 3 VMs
vm1RootVolumeResponse = Volume.list(
cls.apiclient,
virtualmachineid=cls.virtual_machine_1.id,
type='ROOT',
listall=True)
vm2RootVolumeResponse = Volume.list(
cls.apiclient,
virtualmachineid=cls.virtual_machine_2.id,
type='ROOT',
listall=True)
vm3RootVolumeResponse = Volume.list(
cls.apiclient,
virtualmachineid=cls.virtual_machine_3.id,
type='ROOT',
listall=True)
cls.vm1_root_volume = vm1RootVolumeResponse[0]
cls.vm2_root_volume = vm2RootVolumeResponse[0]
cls.vm3_root_volume = vm3RootVolumeResponse[0]
#Take 3 snapshots of VM2's ROOT volume
cls.snapshot_1 = Snapshot.create(cls.apiclient,
cls.vm2_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid)
cls.snapshot_2 = Snapshot.create(cls.apiclient,
cls.vm2_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid)
cls.snapshot_3 = Snapshot.create(cls.apiclient,
cls.vm2_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid)
#Create 3 templates
cls.template_1 = Template.create(cls.apiclient,
cls.services["template"],
cls.vm3_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid)
cls.template_2 = Template.create(cls.apiclient,
cls.services["template_2"],
cls.vm3_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid)
cls.template_3 = Template.create(cls.apiclient,
cls.services["template_2"],
cls.vm3_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid)
cls._cleanup = [
cls.snapshot_3, cls.snapshot_2, cls.snapshot_1, cls.account,
cls.disk_offering, cls.service_offering
]
def test_09_copy_delete_template(self):
cmd = listZones.listZonesCmd()
zones = self.apiclient.listZones(cmd)
if not isinstance(zones, list):
raise Exception("Failed to find zones.")
if len(zones) < 2:
self.skipTest(
"Skipping test due to there are less than two zones.")
return
self.sourceZone = zones[0]
self.destZone = zones[1]
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"
)
#Copy template from zone1 to zone2
copytemplate = Template.copy(
cls.apiclient,
zoneid=cls.sourceZone.id,
destzoneid = cls.destZone.id
)
cls._cleanup.append(cls.copytemplate)
list_template_response = Template.list(
self.apiclient,
templatefilter=self.services["template"]["templatefilter"],
id=self.template.id,
zoneid=self.destZone.id
)
self.assertEqual(
list_template_response,
None,
"Check template available in List Templates"
)
self.deltemplate = list_template_response[0]
self.debug("Deleting template: %s" % self.deltemplate)
# Delete the template
self.deltemplate.delete(self.apiclient)
self.debug("Delete template: %s successful" % self.deltemplate)
copytemplate = Template.copy(
self.apiclient,
zoneid=self.sourceZone.id,
destzoneid = self.destZone.id
)
removed = cls.dbclient.execute("select removed from template_zone_ref where zone_id='%s' and template_id='%s';" % self.destZone.id, self.template.id)
self.assertEqual(
removed,
NULL,
"Removed state is not correct."
)
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 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 setUpClass(cls):
testClient = super(TestTemplates, 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, cls.testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
#populate second zone id for iso copy
cmd = listZones.listZonesCmd()
cls.zones = cls.apiclient.listZones(cmd)
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
print "Before:", cls.services
cls.account = Account.create(cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id)
print "After:", cls.services
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 setUpClass(cls):
testClient = super(TestListIdsParams, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.services = testClient.getParsedTestDataConfig()
cls.hypervisor = testClient.getHypervisorInfo()
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
cls.disk_offering = DiskOffering.create(
cls.apiclient,
cls.services["disk_offering"]
)
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"]
)
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["template"]["ostypeid"] = template.ostypeid
cls.services["template_2"]["ostypeid"] = template.ostypeid
cls.services["ostypeid"] = template.ostypeid
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["mode"] = cls.zone.networktype
#Create 3 VMs
cls.virtual_machine_1 = 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"]
)
cls.virtual_machine_2 = 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"]
)
cls.virtual_machine_3 = 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"]
)
#Take 3 VM1 Snapshots
#PLEASE UNCOMMENT ONCE VM SNAPSHOT DELAY BUG AFTER VM CREATION IS FIXED
"""cls.vmsnapshot_1 = VmSnapshot.create(
cls.apiclient,
cls.virtual_machine_1.id
)
cls.vmsnapshot_2 = VmSnapshot.create(
cls.apiclient,
cls.virtual_machine_1.id
)
cls.vmsnapshot_3 = VmSnapshot.create(
cls.apiclient,
cls.virtual_machine_1.id
)"""
#Stop VMs
cls.virtual_machine_1.stop(cls.apiclient)
cls.virtual_machine_2.stop(cls.apiclient)
cls.virtual_machine_3.stop(cls.apiclient)
#Get ROOT volumes of 3 VMs
vm1RootVolumeResponse = Volume.list(
cls.apiclient,
virtualmachineid=cls.virtual_machine_1.id,
type='ROOT',
listall=True
)
vm2RootVolumeResponse = Volume.list(
cls.apiclient,
virtualmachineid=cls.virtual_machine_2.id,
type='ROOT',
listall=True
)
vm3RootVolumeResponse = Volume.list(
cls.apiclient,
virtualmachineid=cls.virtual_machine_3.id,
type='ROOT',
listall=True
)
cls.vm1_root_volume = vm1RootVolumeResponse[0]
cls.vm2_root_volume = vm2RootVolumeResponse[0]
cls.vm3_root_volume = vm3RootVolumeResponse[0]
#Take 3 snapshots of VM2's ROOT volume
cls.snapshot_1 = Snapshot.create(
cls.apiclient,
cls.vm2_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid
)
cls.snapshot_2 = Snapshot.create(
cls.apiclient,
cls.vm2_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid
)
cls.snapshot_3 = Snapshot.create(
cls.apiclient,
cls.vm2_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid
)
#Create 3 templates
cls.template_1 = Template.create(
cls.apiclient,
cls.services["template"],
cls.vm3_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid
)
cls.template_2 = Template.create(
cls.apiclient,
cls.services["template_2"],
cls.vm3_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid
)
cls.template_3 = Template.create(
cls.apiclient,
cls.services["template_2"],
cls.vm3_root_volume.id,
account=cls.account.name,
domainid=cls.account.domainid
)
cls._cleanup = [
cls.snapshot_1,
cls.snapshot_2,
cls.snapshot_3,
cls.account,
cls.disk_offering,
cls.service_offering
]
