本文整理汇总了Python中marvin.lib.base.Iso类的典型用法代码示例。如果您正苦于以下问题：Python Iso类的具体用法？Python Iso怎么用？Python Iso使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了Iso类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: test_03_register_iso
def test_03_register_iso(self, value):
"""Test register iso
Steps and validations:
1. Create a root domain/child domain admin account
2. Register a test iso in the account
3. Wait till the iso is downloaded and is in ready state
3. Verify that secondary storage resource count of the account equals the
iso size
4. Delete the iso
5. Verify that the secondary storage count of the account equals 0
"""
response = self.setupAccount(value)
self.assertEqual(response[0], PASS, response[1])
self.services["iso"]["zoneid"] = self.zone.id
try:
iso = Iso.create(
self.apiclient,
self.services["iso"],
account=self.account.name,
domainid=self.account.domainid
)
except Exception as e:
self.fail("Failed to create Iso: %s" % e)
timeout = 600
isoList = None
while timeout >= 0:
isoList = Iso.list(self.apiclient,
isofilter="self",
id=iso.id)
self.assertEqual(validateList(isoList)[0],PASS,\
"iso list validation failed")
if isoList[0].isready:
break
time.sleep(60)
timeout -= 60
self.assertNotEqual(timeout, 0,\
"template not downloaded completely")
isoSize = (isoList[0].size / (1024**3))
expectedCount = isoSize
response = matchResourceCount(self.apiclient, expectedCount,
resourceType=RESOURCE_SECONDARY_STORAGE,
accountid=self.account.id)
self.assertEqual(response[0], PASS, response[1])
try:
iso.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete Iso")
expectedCount = 0
response = matchResourceCount(self.apiclient, expectedCount,
resourceType=RESOURCE_SECONDARY_STORAGE,
accountid=self.account.id)
self.assertEqual(response[0], PASS, response[1])
return示例2: test_02_deploy_ha_vm_from_iso
def test_02_deploy_ha_vm_from_iso(self):
"""Test Deploy HA enabled Virtual Machine from ISO
"""
# Validate the following:
# 1. deployHA enabled Vm using ISO with the startvm parameter=true
# 2. listVM command should return the deployed VM. State of this VM
# should be "Running".
self.iso = Iso.create(
self.apiclient, self.services["iso"], account=self.account.name, domainid=self.account.domainid
)
try:
# Download the ISO
self.iso.download(self.apiclient)
except Exception as e:
raise Exception("Exception while downloading ISO %s: %s" % (self.iso.id, e))
self.debug("Registered ISO: %s" % self.iso.name)
self.debug("Deploying instance in the account: %s" % self.account.name)
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
templateid=self.iso.id,
serviceofferingid=self.service_offering.id,
diskofferingid=self.disk_offering.id,
startvm=True,
)
response = self.virtual_machine.getState(self.apiclient, VirtualMachine.RUNNING)
self.assertEqual(response[0], PASS, response[1])
return示例3: test_06_pt_startvm_false_attach_iso
def test_06_pt_startvm_false_attach_iso(self):
""" Positive test for stopped VM test path - T5
# 1. Deploy VM in the network with specifying startvm parameter
# as False
# 2. List VMs and verify that VM is in stopped state
# 3. Register an ISO and attach it to the VM
# 4. Verify that ISO is attached to the VM
"""
# 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,
networkids=[self.networkid, ] if self.networkid else None,
zoneid=self.zone.id,
startvm=False,
mode=self.zone.networktype
)
self.cleanup.append(virtual_machine)
response = virtual_machine.getState(
self.apiclient,
VirtualMachine.STOPPED)
self.assertEqual(response[0], PASS, response[1])
iso = Iso.create(
self.userapiclient,
self.testdata["iso"],
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id
)
iso.download(self.userapiclient)
virtual_machine.attach_iso(self.userapiclient, iso)
vms = VirtualMachine.list(
self.userapiclient,
id=virtual_machine.id,
listall=True
)
self.assertEqual(
validateList(vms)[0],
PASS,
"List vms should return a valid list"
)
vm = vms[0]
self.assertEqual(
vm.isoid,
iso.id,
"The ISO status should be reflected in list Vm call"
)
return示例4: test_01_create_iso
def test_01_create_iso(self):
"""Test create public & private ISO
"""
# Validate the following:
# 1. database (vm_template table) should be
# updated with newly created ISO
# 2. UI should show the newly added ISO
# 3. listIsos API should show the newly added ISO
iso = Iso.create(
self.apiclient,
self.services["iso2"],
account=self.account.name,
domainid=self.account.domainid
)
self.debug("ISO created with ID: %s" % iso.id)
try:
iso.download(self.apiclient)
except Exception as e:
self.fail("Exception while downloading ISO %s: %s"
% (iso.id, e))
list_iso_response = list_isos(
self.apiclient,
id=iso.id
)
self.assertEqual(
isinstance(list_iso_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_iso_response),
0,
"Check template available in List ISOs"
)
iso_response = list_iso_response[0]
self.assertEqual(
iso_response.displaytext,
self.services["iso2"]["displaytext"],
"Check display text of newly created ISO"
)
self.assertEqual(
iso_response.zoneid,
self.services["iso2"]["zoneid"],
"Check zone ID of newly created ISO"
)
return示例5: test_deploy_vm_from_iso
def test_deploy_vm_from_iso(self):
"""Test Deploy Virtual Machine from ISO
"""
# Validate the following:
# 1. deploy VM using ISO
# 2. listVM command should return the deployed VM. State of this VM
# should be "Running".
self.hypervisor = self.testClient.getHypervisorInfo()
if self.hypervisor.lower() in ['lxc']:
self.skipTest(
"vm deploy from ISO feature is not supported on %s" %
self.hypervisor.lower())
self.iso = Iso.create(
self.apiclient,
self.testdata["configurableData"]["bootableIso"],
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id
)
try:
# Download the ISO
self.iso.download(self.apiclient)
except Exception as e:
raise Exception("Exception while downloading ISO %s: %s"
% (self.iso.id, e))
self.debug("Registered ISO: %s" % self.iso.name)
self.debug("Deploying instance in the account: %s" %
self.account.name)
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
templateid=self.iso.id,
serviceofferingid=self.service_offering.id,
diskofferingid=self.disk_offering.id,
hypervisor=self.hypervisor
)
response = self.virtual_machine.getState(
self.apiclient,
VirtualMachine.RUNNING)
self.assertEqual(response[0], PASS, response[1])
return示例6: test_07_deploy_startvm_attach_iso
def test_07_deploy_startvm_attach_iso(self):
"""Test Deploy Virtual Machine with startVM=false and attach ISO
"""
# Validate the following:
# 1. deploy Vm with the startvm=false. Attach volume to the instance
# 2. listVM command should return the deployed VM.State of this VM
# should be "Stopped".
# 3. Attach ISO to the instance. Attach ISO should be successful
self.debug("Deploying instance in the account: %s" % self.account.name)
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
startvm=False,
diskofferingid=self.disk_offering.id,
)
response = self.virtual_machine.getState(self.apiclient, VirtualMachine.STOPPED)
self.assertEqual(response[0], PASS, response[1])
self.debug("Registering a ISO in account: %s" % self.account.name)
iso = Iso.create(
self.apiclient, self.services["iso"], account=self.account.name, domainid=self.account.domainid
)
self.debug("Successfully created ISO with ID: %s" % iso.id)
try:
iso.download(self.apiclient)
except Exception as e:
self.fail("Exception while downloading ISO %s: %s" % (iso.id, e))
self.debug("Attach ISO with ID: %s to VM ID: %s" % (iso.id, self.virtual_machine.id))
try:
self.virtual_machine.attach_iso(self.apiclient, iso)
except Exception as e:
self.fail("Attach ISO failed!")
vms = VirtualMachine.list(self.apiclient, id=self.virtual_machine.id, listall=True)
self.assertEqual(isinstance(vms, list), True, "List vms should return a valid list")
vm = vms[0]
self.assertEqual(vm.isoid, iso.id, "The ISO status should be reflected in list Vm call")
return示例7: setUpClass
def setUpClass(cls):
testClient = super(TestISO, 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["domainid"] = cls.domain.id
cls.services["iso1"]["zoneid"] = cls.zone.id
cls.services["iso2"]["zoneid"] = cls.zone.id
cls.services["sourcezoneid"] = cls.zone.id
# 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.")
# Create an account, ISOs etc.
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
domainid=cls.domain.id
)
# Finding the OsTypeId from Ostype
ostypes = list_os_types(
cls.apiclient,
description=cls.services["ostype"]
)
if not isinstance(ostypes, list):
raise unittest.SkipTest("OSTypeId for given description not found")
cls.services["iso1"]["ostypeid"] = ostypes[0].id
cls.services["iso2"]["ostypeid"] = ostypes[0].id
cls.services["ostypeid"] = ostypes[0].id
cls.iso_1 = Iso.create(
cls.apiclient,
cls.services["iso1"],
account=cls.account.name,
domainid=cls.account.domainid
)
try:
cls.iso_1.download(cls.apiclient)
except Exception as e:
raise Exception("Exception while downloading ISO %s: %s"
% (cls.iso_1.id, e))
cls.iso_2 = Iso.create(
cls.apiclient,
cls.services["iso2"],
account=cls.account.name,
domainid=cls.account.domainid
)
try:
cls.iso_2.download(cls.apiclient)
except Exception as e:
raise Exception("Exception while downloading ISO %s: %s"
% (cls.iso_2.id, e))
cls._cleanup = [cls.account]
return示例8: test_04_copy_iso
def test_04_copy_iso(self):
"""
@Desc: Test to copy ISO from one zone to another
@steps:
Step1: Listing Zones available for a user
Step2: Verifying if the zones listed are greater than 1.
If Yes continuing.
If not halting the test.
Step3: Listing all the ISO's for a user in zone1
Step4: Verifying that no ISO's are listed
Step5: Listing all the ISO's for a user in zone2
Step6: Verifying that no ISO's are listed
Step7: Creating an ISO in zone 1
Step8: Listing all the ISO's again for a user in zone1
Step9: Verifying that list size is 1
Step10: Listing all the ISO's for a user in zone2
Step11: Verifying that no ISO's are listed
Step12: Copying the ISO created in step7 from zone1 to zone2
Step13: Listing all the ISO's for a user in zone2
Step14: Verifying that list size is 1
Step15: Listing all the ISO's for a user in zone1
Step16: Verifying that list size is 1
"""
# Listing Zones available for a user
zones_list = Zone.list(
self.userapiclient,
available=True
)
status = validateList(zones_list)
self.assertEquals(
PASS,
status[0],
"Failed to list Zones"
)
if not len(zones_list) > 1:
self.skipTest("Enough zones doesnot exists to copy iso")
else:
# Listing all the ISO's for a User in Zone 1
list_isos_zone1 = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"],
zoneid=zones_list[0].id
)
# Verifying that no ISO's are listed
self.assertIsNone(
list_isos_zone1,
"ISO's listed for newly created User in Zone1"
)
# Listing all the ISO's for a User in Zone 2
list_isos_zone2 = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"],
zoneid=zones_list[1].id
)
# Verifying that no ISO's are listed
self.assertIsNone(
list_isos_zone2,
"ISO's listed for newly created User in Zone2"
)
self.services["iso"]["zoneid"] = zones_list[0].id
# Creating an ISO in Zone 1
iso_created = Iso.create(
self.userapiclient,
self.services["iso"]
)
self.assertIsNotNone(
iso_created,
"ISO creation failed"
)
self.cleanup.append(iso_created)
# Listing all the ISO's for a User in Zone 1
list_isos_zone1 = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"],
zoneid=zones_list[0].id
)
status = validateList(list_isos_zone1)
self.assertEquals(
PASS,
status[0],
"ISO creation failed in Zone1"
)
# Verifying that list size is 1
self.assertEquals(
1,
len(list_isos_zone1),
"Failed to create a Template"
)
# Listing all the ISO's for a User in Zone 2
list_isos_zone2 = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"],
zoneid=zones_list[1].id
)
# Verifying that no ISO's are listed
self.assertIsNone(
#.........这里部分代码省略.........
示例9: test_03_edit_iso_details
def test_03_edit_iso_details(self):
"""
@Desc: Test to Edit ISO name, displaytext, OSType
@steps:
Step1: Listing all the ISO's for a user
Step2: Verifying that no ISO's are listed
Step3: Creating an ISO
Step4: Listing all the ISO's again for a user
Step5: Verifying that list size is 1
Step6: Verifying if the ISO is in ready state.
If yes the continuing
If not waiting and checking for template to be ready till timeout
Step7: Editing the ISO's name, displaytext
Step8: Verifying that ISO name and displaytext are edited
Step9: Editing the ISO name, displaytext, ostypeid
Step10: Verifying that ISO name, displaytext and ostypeid are edited
"""
# Listing all the ISO's for a User
list_iso_before = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"]
)
# Verifying that no ISOs are listed
self.assertIsNone(
list_iso_before,
"ISOs listed for newly created User"
)
self.services["iso"]["zoneid"] = self.zone.id
# Creating an ISO's
iso_created = Iso.create(
self.userapiclient,
self.services["iso"]
)
self.assertIsNotNone(
iso_created,
"ISO creation failed"
)
self.cleanup.append(iso_created)
# Listing all the ISO's for a User
list_iso_after = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"]
)
status = validateList(list_iso_after)
self.assertEquals(
PASS,
status[0],
"ISO's creation failed"
)
# Verifying that list size is 1
self.assertEquals(
1,
len(list_iso_after),
"Failed to create an ISO's"
)
# Verifying the state of the ISO to be ready. If not waiting for state to become ready
iso_ready = False
count = 0
while iso_ready is False:
list_iso = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"],
id=iso_created.id
)
status = validateList(list_iso)
self.assertEquals(
PASS,
status[0],
"Failed to list ISO by Id"
)
if list_iso[0].isready is True:
iso_ready = True
elif (str(list_iso[0].status) == "Error"):
self.fail("Created ISO is in Errored state")
break
elif count > 10:
self.fail("Timed out before ISO came into ready state")
break
else:
time.sleep(self.services["sleep"])
count = count + 1
# Editing the ISO name, displaytext
edited_iso = Iso.update(
iso_created,
self.userapiclient,
name="NewISOName",
displaytext="NewISODisplayText"
)
self.assertIsNotNone(
edited_iso,
"Editing ISO failed"
)
# Verifying the details of edited template
expected_dict = {
"id":iso_created.id,
"name":"NewISOName",
#.........这里部分代码省略.........
示例10: test_02_download_iso
def test_02_download_iso(self):
"""
@Desc: Test to Download ISO
@steps:
Step1: Listing all the ISO's for a user
Step2: Verifying that no ISO's are listed
Step3: Creating an ISO
Step4: Listing all the ISO's again for a user
Step5: Verifying that list size is 1
Step6: Verifying if the ISO is in ready state.
If yes the continuing
If not waiting and checking for template to be ready till timeout
Step7: Downloading the ISO (Extract)
Step8: Verifying the details of downloaded ISO
"""
# Listing all the ISO's for a User
list_iso_before = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"]
)
# Verifying that no ISOs are listed
self.assertIsNone(
list_iso_before,
"ISOs listed for newly created User"
)
self.services["iso"]["zoneid"] = self.zone.id
self.services["iso"]["isextractable"] = True
# Creating an ISO's
iso_created = Iso.create(
self.userapiclient,
self.services["iso"]
)
self.assertIsNotNone(
iso_created,
"ISO creation failed"
)
self.cleanup.append(iso_created)
# Listing all the ISO's for a User
list_iso_after = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"]
)
status = validateList(list_iso_after)
self.assertEquals(
PASS,
status[0],
"ISO's creation failed"
)
# Verifying that list size is 1
self.assertEquals(
1,
len(list_iso_after),
"Failed to create an ISO's"
)
# Verifying the state of the ISO to be ready. If not waiting for state to become ready
iso_ready = False
count = 0
while iso_ready is False:
list_iso = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"],
id=iso_created.id
)
status = validateList(list_iso)
self.assertEquals(
PASS,
status[0],
"Failed to list ISO by Id"
)
if list_iso[0].isready is True:
iso_ready = True
elif (str(list_iso[0].status) == "Error"):
self.fail("Created ISO is in Errored state")
break
elif count > 10:
self.fail("Timed out before ISO came into ready state")
break
else:
time.sleep(self.services["sleep"])
count = count + 1
# Downloading the ISO
download_iso = Iso.extract(
self.userapiclient,
iso_created.id,
mode="HTTP_DOWNLOAD",
zoneid=self.zone.id
)
self.assertIsNotNone(
download_iso,
"Download ISO failed"
)
# Verifying the details of downloaded ISO
self.assertEquals(
"DOWNLOAD_URL_CREATED",
download_iso.state,
"Download URL not created for ISO"
#.........这里部分代码省略.........
示例11: test_01_list_isos_pagination
def test_01_list_isos_pagination(self):
"""
@Desc: Test to List ISO's pagination
@steps:
Step1: Listing all the ISO's for a user
Step2: Verifying that no ISO's are listed
Step3: Creating (page size + 1) number of ISO's
Step4: Listing all the ISO's again for a user
Step5: Verifying that list size is (page size + 1)
Step6: Listing all the ISO's in page1
Step7: Verifying that list size is (page size)
Step8: Listing all the ISO's in page2
Step9: Verifying that list size is 1
Step10: Listing the ISO's by Id
Step11: Verifying if the ISO is downloaded and ready.
If yes the continuing
If not waiting and checking for iso to be ready till timeout
Step12: Deleting the ISO present in page 2
Step13: Listing all the ISO's in page2
Step14: Verifying that no ISO's are listed
"""
# Listing all the ISO's for a User
list_iso_before = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"]
)
# Verifying that no ISOs are listed
self.assertIsNone(
list_iso_before,
"ISOs listed for newly created User"
)
self.services["iso"]["zoneid"] = self.zone.id
# Creating pagesize + 1 number of ISO's
for i in range(0, (self.services["pagesize"] + 1)):
iso_created = Iso.create(
self.userapiclient,
self.services["iso"]
)
self.assertIsNotNone(
iso_created,
"ISO creation failed"
)
if(i < self.services["pagesize"]):
self.cleanup.append(iso_created)
# Listing all the ISO's for a User
list_iso_after = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"]
)
status = validateList(list_iso_after)
self.assertEquals(
PASS,
status[0],
"ISO's creation failed"
)
# Verifying that list size is pagesize + 1
self.assertEquals(
self.services["pagesize"] + 1,
len(list_iso_after),
"Failed to create pagesize + 1 number of ISO's"
)
# Listing all the ISO's in page 1
list_iso_page1 = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"],
page=1,
pagesize=self.services["pagesize"]
)
status = validateList(list_iso_page1)
self.assertEquals(
PASS,
status[0],
"Failed to list ISO's in page 1"
)
# Verifying the list size to be equal to pagesize
self.assertEquals(
self.services["pagesize"],
len(list_iso_page1),
"Size of ISO's in page 1 is not matching"
)
# Listing all the Templates in page 2
list_iso_page2 = Iso.list(
self.userapiclient,
listall=self.services["listall"],
isofilter=self.services["templatefilter"],
page=2,
pagesize=self.services["pagesize"]
)
status = validateList(list_iso_page2)
self.assertEquals(
PASS,
status[0],
"Failed to list ISo's in page 2"
)
# Verifying the list size to be equal to 1
self.assertEquals(
#.........这里部分代码省略.........
示例12: test_01_disable_enable_pod
def test_01_disable_enable_pod(self):
"""disable enable Pod
1. Disable pod and verify following things:
For admin user:
-- Should be able to create new vm, snapshot,
volume,template,iso in the same pod
For Non-admin user:
-- Should not be able to create new vm, snapshot,
volume,template,iso in the same pod
2. Enable the above disabled pod and verify that:
-All users should be able to create new vm, snapshot,
volume,template,iso in the same pod
3. Try to delete the pod and it should fail with error message:
- "The pod is not deletable because there are servers
running in this pod"
"""
# Step 1
vm_user = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
vm_root = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.admin_account.name,
domainid=self.admin_account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
cmd = updatePod.updatePodCmd()
cmd.id = self.pod.id
cmd.allocationstate = DISABLED
self.apiclient.updatePod(cmd)
podList = Pod.list(self.apiclient, id=self.pod.id)
self.assertEqual(podList[0].allocationstate, DISABLED, "Check if the pod is in disabled state")
self.assertEqual(vm_user.state.lower(), "running", "Verify that the user vm is running")
self.assertEqual(vm_root.state.lower(), "running", "Verify that the admin vm is running")
VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.admin_account.name,
domainid=self.admin_account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
root_volume = list_volumes(self.apiclient, virtualmachineid=vm_root.id, type="ROOT", listall=True)
self.assertEqual(validateList(root_volume)[0], PASS, "list snapshot is empty for volume id %s" % vm_root.id)
if self.snapshotSupported:
Snapshot.create(self.apiclient, root_volume[0].id)
snapshots = list_snapshots(self.apiclient, volumeid=root_volume[0].id, listall=True)
self.assertEqual(
validateList(snapshots)[0], PASS, "list snapshot is empty for volume id %s" % root_volume[0].id
)
Template.create_from_snapshot(self.apiclient, snapshots[0], self.testdata["privatetemplate"])
builtin_info = get_builtin_template_info(self.apiclient, self.zone.id)
self.testdata["privatetemplate"]["url"] = builtin_info[0]
self.testdata["privatetemplate"]["hypervisor"] = builtin_info[1]
self.testdata["privatetemplate"]["format"] = builtin_info[2]
Template.register(self.apiclient, self.testdata["privatetemplate"], zoneid=self.zone.id)
Volume.create(
self.apiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.admin_account.name,
domainid=self.admin_account.domainid,
diskofferingid=self.disk_offering.id,
)
Iso.create(
self.apiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.admin_account.name,
domainid=self.admin_account.domainid,
)
with self.assertRaises(Exception):
VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
#.........这里部分代码省略.........
示例13: test_01_disable_enable_zone
#.........这里部分代码省略.........
self.testdata["privatetemplate"]["hypervisor"] = builtin_info[1]
self.testdata["privatetemplate"]["format"] = builtin_info[2]
template_regis = Template.register(
self.apiclient,
self.testdata["privatetemplate"],
zoneid=self.zone.id)
self.assertNotEqual(
template_regis,
None,
"Check if template gets created"
)
self.assertNotEqual(
template_from_snapshot,
None,
"Check if template gets created"
)
data_volume = Volume.create(
self.apiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id
)
self.assertNotEqual(
data_volume,
None,
"Check if volume gets created"
)
ISO = Iso.create(
self.apiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertNotEqual(
ISO,
None,
"Check if volume gets created"
)
# non-admin user should fail to create vm, snap, temp etc
with self.assertRaises(Exception):
VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id
)
root_volume = list_volumes(
self.userapiclient,
virtualmachineid=vm_user.id,
type='ROOT',
listall=True
)
with self.assertRaises(Exception):
snap = Snapshot.create(示例14: test_01_disable_enable_cluster
#.........这里部分代码省略.........
root_volume = list_volumes(self.apiclient, virtualmachineid=vm_root.id, type="ROOT", listall=True)
self.assertEqual(
validateList(root_volume)[0], PASS, "list root volume response is empty for volume id %s" % vm_root.id
)
if self.snapshotSupported:
Snapshot.create(self.apiclient, root_volume[0].id)
snapshots = list_snapshots(self.apiclient, volumeid=root_volume[0].id, listall=True)
self.assertEqual(
validateList(snapshots)[0], PASS, "list snapshot is empty for volume id %s" % root_volume[0].id
)
Template.create_from_snapshot(self.apiclient, snapshots[0], self.testdata["privatetemplate"])
builtin_info = get_builtin_template_info(self.apiclient, self.zone.id)
self.testdata["privatetemplate"]["url"] = builtin_info[0]
self.testdata["privatetemplate"]["hypervisor"] = builtin_info[1]
self.testdata["privatetemplate"]["format"] = builtin_info[2]
Template.register(self.apiclient, self.testdata["privatetemplate"], zoneid=self.zone.id)
Volume.create(
self.apiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.admin_account.name,
domainid=self.admin_account.domainid,
diskofferingid=self.disk_offering.id,
)
Iso.create(
self.apiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.admin_account.name,
domainid=self.admin_account.domainid,
)
# non-admin user should fail to create vm, snap, temp etc
with self.assertRaises(Exception):
VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype,
)
root_volume = list_volumes(self.userapiclient, virtualmachineid=vm_user.id, type="ROOT", listall=True)
self.assertEqual(
validateList(root_volume)[0], PASS, "list root volume response is empty for volume id %s" % vm_user.id
)
if self.snapshotSupported:
Snapshot.create(self.userapiclient, root_volume[0].id)
Template.register(self.userapiclient, self.testdata["privatetemplate"], zoneid=self.zone.id)
Volume.create(示例15: test_10_attachAndDetach_iso
def test_10_attachAndDetach_iso(self):
"""Test for attach and detach ISO to virtual machine"""
# Validate the following
# 1. Create ISO
# 2. Attach ISO to VM
# 3. Log in to the VM.
# 4. The device should be available for use
# 5. Detach ISO
# 6. Check the device is properly detached by logging into VM
iso = Iso.create(
self.apiclient,
self.services["iso1"],
account=self.account.name,
domainid=self.account.domainid
)
self.debug("Successfully created ISO with ID: %s" % iso.id)
try:
iso.download(self.apiclient)
except Exception as e:
self.fail("Exception while downloading ISO %s: %s"\
% (iso.id, e))
self.debug("Attach ISO with ID: %s to VM ID: %s" % (
iso.id,
self.virtual_machine.id
))
#Attach ISO to virtual machine
cmd = attachIso.attachIsoCmd()
cmd.id = iso.id
cmd.virtualmachineid = self.virtual_machine.id
self.apiclient.attachIso(cmd)
try:
ssh_client = self.virtual_machine.get_ssh_client()
except Exception as e:
self.fail("SSH failed for virtual machine: %s - %s" %
(self.virtual_machine.ipaddress, e))
mount_dir = "/mnt/tmp"
cmds = "mkdir -p %s" % mount_dir
self.assert_(ssh_client.execute(cmds) == [], "mkdir failed within guest")
for diskdevice in self.services["diskdevice"]:
res = ssh_client.execute("mount -rt iso9660 {} {}".format(diskdevice, mount_dir))
if res == []:
self.services["mount"] = diskdevice
break
else:
self.fail("No mount points matched. Mount was unsuccessful")
c = "mount |grep %s|head -1" % self.services["mount"]
res = ssh_client.execute(c)
size = ssh_client.execute("du %s | tail -1" % self.services["mount"])
self.debug("Found a mount point at %s with size %s" % (res, size))
# Get ISO size
iso_response = Iso.list(
self.apiclient,
id=iso.id
)
self.assertEqual(
isinstance(iso_response, list),
True,
"Check list response returns a valid list"
)
try:
#Unmount ISO
command = "umount %s" % mount_dir
ssh_client.execute(command)
except Exception as e:
self.fail("SSH failed for virtual machine: %s - %s" %
(self.virtual_machine.ipaddress, e))
#Detach from VM
cmd = detachIso.detachIsoCmd()
cmd.virtualmachineid = self.virtual_machine.id
self.apiclient.detachIso(cmd)
try:
res = ssh_client.execute(c)
except Exception as e:
self.fail("SSH failed for virtual machine: %s - %s" %
(self.virtual_machine.ipaddress, e))
# Check if ISO is properly detached from VM (using fdisk)
result = self.services["mount"] in str(res)
self.assertEqual(
result,
False,
"Check if ISO is detached from virtual machine"
)
return