mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
8442a4d9df
Steps to reproduce issue Deploy a VM Take snapshot of the root volume Delete the snapshot Before the garbage collector has run, shutdown the VM and assign the VM to other user. When garage collector executes NPE shows in the logs.
484 lines
27 KiB
Python
484 lines
27 KiB
Python
# Licensed to the Apache Software Foundation (ASF) under one
|
|
# or more contributor license agreements. See the NOTICE file
|
|
# distributed with this work for additional information
|
|
# regarding copyright ownership. The ASF licenses this file
|
|
# to you under the Apache License, Version 2.0 (the
|
|
# "License"); you may not use this file except in compliance
|
|
# with the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing,
|
|
# software distributed under the License is distributed on an
|
|
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
# KIND, either express or implied. See the License for the
|
|
# specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""
|
|
"""
|
|
#Import Local Modules
|
|
from nose.plugins.attrib import attr
|
|
from marvin.cloudstackTestCase import cloudstackTestCase
|
|
from marvin.lib.base import (Account,
|
|
Domain,
|
|
User,
|
|
Project,
|
|
Volume,
|
|
Snapshot,
|
|
DiskOffering,
|
|
ServiceOffering,
|
|
VirtualMachine)
|
|
from marvin.lib.common import (get_domain,
|
|
get_zone,
|
|
get_template,
|
|
list_volumes,
|
|
update_resource_limit,
|
|
list_networks,
|
|
list_snapshots,
|
|
list_virtual_machines)
|
|
from marvin.lib.utils import cleanup_resources
|
|
|
|
def log_test_exceptions(func):
|
|
def test_wrap_exception_log(self, *args, **kwargs):
|
|
try:
|
|
func(self, *args, **kwargs)
|
|
except Exception as e:
|
|
self.debug('Test %s Failed due to Exception=%s' % (func, e))
|
|
raise e
|
|
test_wrap_exception_log.__doc__ = func.__doc__
|
|
return test_wrap_exception_log
|
|
|
|
class Services:
|
|
"""Test service data for:Change the ownershop of
|
|
VM/network/datadisk/snapshot/template/ISO from one account to any other account.
|
|
"""
|
|
def __init__(self):
|
|
self.services = {"domain" : {"name": "Domain",},
|
|
"account" : {"email" : "test@test.com",
|
|
"firstname" : "Test",
|
|
"lastname" : "User",
|
|
"username" : "test",
|
|
# Random characters are appended in create account to
|
|
# ensure unique username generated each time
|
|
"password" : "password",},
|
|
"user" : {"email" : "user@test.com",
|
|
"firstname": "User",
|
|
"lastname" : "User",
|
|
"username" : "User",
|
|
# Random characters are appended for unique
|
|
# username
|
|
"password" : "fr3sca",},
|
|
"project" : {"name" : "Project",
|
|
"displaytext" : "Test project",},
|
|
"volume" : {"diskname" : "TestDiskServ",
|
|
"max" : 6,},
|
|
"disk_offering" : {"displaytext" : "Small",
|
|
"name" : "Small",
|
|
"disksize" : 1},
|
|
"virtual_machine" : {"displayname" : "testserver",
|
|
"username" : "root",# VM creds for SSH
|
|
"password" : "password",
|
|
"ssh_port" : 22,
|
|
"hypervisor" : 'XenServer',
|
|
"privateport" : 22,
|
|
"publicport" : 22,
|
|
"protocol" : 'TCP',},
|
|
"service_offering" : {"name" : "Tiny Instance",
|
|
"displaytext" : "Tiny Instance",
|
|
"cpunumber" : 1,
|
|
"cpuspeed" : 100,# in MHz
|
|
"memory" : 128},
|
|
#"storagetype" : "local"},
|
|
"sleep" : 60,
|
|
"ostype" : 'CentOS 5.3 (64-bit)',# CentOS 5.3 (64-bit)
|
|
}
|
|
|
|
class TestVMOwnership(cloudstackTestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls._cleanup = []
|
|
cls.testClient = super(TestVMOwnership, cls).getClsTestClient()
|
|
cls.api_client = cls.testClient.getApiClient()
|
|
cls.hypervisor = cls.testClient.getHypervisorInfo()
|
|
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
|
|
# Get and set template id for VM creation.
|
|
cls.template = get_template(cls.api_client,
|
|
cls.zone.id,
|
|
cls.services["ostype"])
|
|
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
|
|
cls.services["virtual_machine"]["template"] = cls.template.id
|
|
cls.hypervisor = cls.testClient.getHypervisorInfo()
|
|
|
|
def create_domain_account_user(parentDomain=None):
|
|
domain = Domain.create(cls.api_client,
|
|
cls.services["domain"],
|
|
parentdomainid=parentDomain.id if parentDomain else None)
|
|
cls._cleanup.append(domain)
|
|
# Create an Account associated with domain
|
|
account = Account.create(cls.api_client,
|
|
cls.services["account"],
|
|
domainid=domain.id)
|
|
cls._cleanup.append(account)
|
|
# Create an User, Project, Volume associated with account
|
|
user = User.create(cls.api_client,
|
|
cls.services["user"],
|
|
account=account.name,
|
|
domainid=account.domainid)
|
|
cls._cleanup.append(user)
|
|
project = Project.create(cls.api_client,
|
|
cls.services["project"],
|
|
account=account.name,
|
|
domainid=account.domainid)
|
|
cls._cleanup.append(project)
|
|
volume = Volume.create(cls.api_client,
|
|
cls.services["volume"],
|
|
zoneid=cls.zone.id,
|
|
account=account.name,
|
|
domainid=account.domainid,
|
|
diskofferingid=cls.disk_offering.id)
|
|
cls._cleanup.append(volume)
|
|
return {'domain':domain, 'account':account, 'user':user, 'project':project, 'volume':volume}
|
|
|
|
# Create disk offerings.
|
|
try:
|
|
cls.disk_offering = DiskOffering.create(cls.api_client,
|
|
cls.services["disk_offering"])
|
|
# Create service offerings.
|
|
cls.service_offering = ServiceOffering.create(cls.api_client,
|
|
cls.services["service_offering"])
|
|
# Cleanup
|
|
cls._cleanup.append(cls.service_offering)
|
|
# Create domain, account, user, project and volumes.
|
|
cls.domain_account_user1 = create_domain_account_user()
|
|
cls.domain_account_user2 = create_domain_account_user()
|
|
cls.sdomain_account_user1 = create_domain_account_user(cls.domain_account_user1['domain'])
|
|
cls.sdomain_account_user2 = create_domain_account_user(cls.domain_account_user2['domain'])
|
|
cls.ssdomain_account_user2 = create_domain_account_user(cls.sdomain_account_user2['domain'])
|
|
except Exception as e:
|
|
raise e
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
cleanup_resources(cls.api_client, reversed(cls._cleanup))
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.api_client#self.testClient.getApiClient()
|
|
#self.dbclient = self.testClient.getDbConnection()
|
|
self.cleanup = []
|
|
self.snapshot = None
|
|
return
|
|
|
|
def create_vm(self,
|
|
account,
|
|
domain,
|
|
isRunning=False,
|
|
project =None,
|
|
limit =None,
|
|
pfrule =False,
|
|
lbrule =None,
|
|
natrule =None,
|
|
volume =None,
|
|
snapshot =False):
|
|
#TODO: Implemnt pfrule/lbrule/natrule
|
|
self.debug("Deploying instance in the account: %s" % account.name)
|
|
self.virtual_machine = VirtualMachine.create(self.apiclient,
|
|
self.services["virtual_machine"],
|
|
accountid=account.name,
|
|
domainid=domain.id,
|
|
serviceofferingid=self.service_offering.id,
|
|
mode=self.zone.networktype if pfrule else 'basic',
|
|
projectid=project.id if project else None)
|
|
self.debug("Deployed instance in account: %s" % account.name)
|
|
list_virtual_machines(self.apiclient,
|
|
id=self.virtual_machine.id)
|
|
if snapshot:
|
|
volumes = list_volumes(self.apiclient,
|
|
virtualmachineid=self.virtual_machine.id,
|
|
type='ROOT',
|
|
listall=True)
|
|
self.snapshot = Snapshot.create(self.apiclient,
|
|
volumes[0].id,
|
|
account=account.name,
|
|
domainid=account.domainid)
|
|
if volume:
|
|
self.virtual_machine.attach_volume(self.apiclient,
|
|
volume)
|
|
if not isRunning:
|
|
self.virtual_machine.stop(self.apiclient)
|
|
self.cleanup.append(self.virtual_machine)
|
|
|
|
def check_vm_is_moved_in_account_domainid(self, account):
|
|
list_vm_response = list_virtual_machines(self.api_client,
|
|
id=self.virtual_machine.id,
|
|
account=account.name,
|
|
domainid=account.domainid)
|
|
self.debug('VM=%s moved to account=%s and domainid=%s' % (list_vm_response, account.name, account.domainid))
|
|
self.assertNotEqual(len(list_vm_response), 0, 'Unable to move VM to account=%s domainid=%s' % (account.name, account.domainid))
|
|
|
|
def tearDown(self):
|
|
try:
|
|
self.debug("Cleaning up the resources")
|
|
cleanup_resources(self.apiclient, reversed(self.cleanup))
|
|
self.debug("Cleanup complete!")
|
|
except Exception as e:
|
|
self.debug("Warning! Exception in tearDown: %s" % e)
|
|
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_01_move_across_different_domains(self):
|
|
"""Test as root, stop a VM from domain1 and attempt to move it to account in domain2
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in domain_1
|
|
# 2. stop VM in domain_1
|
|
# 3. assignVirtualMachine to domain_2
|
|
self.create_vm(self.domain_account_user1['account'], self.domain_account_user1['domain'])
|
|
self.virtual_machine.assign_virtual_machine(self.apiclient, self.domain_account_user2['account'].name ,self.domain_account_user2['domain'].id)
|
|
self.check_vm_is_moved_in_account_domainid(self.domain_account_user2['account'])
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_02_move_across_subdomains(self):
|
|
"""Test as root, stop a VM from subdomain1 and attempt to move it to subdomain2
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in subdomain_1
|
|
# 2. stop VM in subdomain_1
|
|
# 3. assignVirtualMachine to subdomain_2
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'])
|
|
self.virtual_machine.assign_virtual_machine(self.apiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
self.check_vm_is_moved_in_account_domainid(self.sdomain_account_user2['account'])
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_03_move_from_domain_to_subdomain(self):
|
|
"""Test as root stop a VM from domain1 and attempt to move it to subdomain1
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in domain_1
|
|
# 2. stop VM in domain_1
|
|
# 3. assignVirtualMachine to subdomain_1
|
|
self.create_vm(self.domain_account_user1['account'], self.domain_account_user1['domain'])
|
|
self.virtual_machine.assign_virtual_machine(self.apiclient, self.sdomain_account_user1['account'].name ,self.sdomain_account_user1['domain'].id)
|
|
self.check_vm_is_moved_in_account_domainid(self.sdomain_account_user1['account'])
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_04_move_from_domain_to_sub_of_subdomain(self):
|
|
"""Test as root, stop a VM from domain1 and attempt to move it to sub-subdomain1
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in domain_2
|
|
# 2. stop VM in domain_2
|
|
# 3. assignVirtualMachine to sub subdomain_2
|
|
self.create_vm(self.domain_account_user2['account'], self.domain_account_user2['domain'])
|
|
self.virtual_machine.assign_virtual_machine(self.apiclient, self.ssdomain_account_user2['account'].name ,self.ssdomain_account_user2['domain'].id)
|
|
self.check_vm_is_moved_in_account_domainid(self.ssdomain_account_user2['account'])
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_05_move_to_domain_from_sub_of_subdomain(self):
|
|
"""Test as root, stop a VM from sub-subdomain1 and attempt to move it to domain1
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain2
|
|
# 2. stop VM in sub subdomain2
|
|
# 3. assignVirtualMachine to sub domain2
|
|
self.create_vm(self.ssdomain_account_user2['account'], self.ssdomain_account_user2['domain'])
|
|
self.virtual_machine.assign_virtual_machine(self.apiclient, self.domain_account_user2['account'].name ,self.domain_account_user2['domain'].id)
|
|
self.check_vm_is_moved_in_account_domainid(self.domain_account_user2['account'])
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_06_move_to_domain_from_subdomain(self):
|
|
"""Test as root, stop a Vm from subdomain1 and attempt to move it to domain1
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1
|
|
# 2. stop VM in sub subdomain1
|
|
# 3. assignVirtualMachine to domain1
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'])
|
|
self.virtual_machine.assign_virtual_machine(self.apiclient, self.domain_account_user1['account'].name ,self.domain_account_user1['domain'].id)
|
|
self.check_vm_is_moved_in_account_domainid(self.domain_account_user1['account'])
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_07_move_across_subdomain(self):
|
|
"""Test as root, stop a VM from subdomain1 and attempt to move it to subdomain2
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1
|
|
# 2. stop VM in sub subdomain1
|
|
# 3. assignVirtualMachine to subdomain2
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'])
|
|
self.virtual_machine.assign_virtual_machine(self.apiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
self.check_vm_is_moved_in_account_domainid(self.sdomain_account_user2['account'])
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_08_move_across_subdomain_network_create(self):
|
|
"""Test as root, stop a VM from subdomain1 and attempt to move it to subdomain2, network should get craeted
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1
|
|
# 2. stop VM in sub subdomain1
|
|
# 3. assignVirtualMachine to subdomain2 network should get created
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'])
|
|
self.virtual_machine.assign_virtual_machine(self.apiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
self.check_vm_is_moved_in_account_domainid(self.sdomain_account_user2['account'])
|
|
networks = list_networks(self.apiclient,
|
|
account=self.sdomain_account_user2['account'].name,
|
|
domainid=self.sdomain_account_user2['domain'].id)
|
|
self.assertEqual(isinstance(networks, list),
|
|
True,
|
|
"Check for list networks response return valid data")
|
|
self.assertNotEqual(len(networks),
|
|
0,
|
|
"Check list networks response")
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_09_move_across_subdomain(self):
|
|
"""Test as domain admin, stop a VM from subdomain1 and attempt to move it to subdomain2
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1
|
|
# 2. stop VM in sub subdomain1
|
|
# 3. assignVirtualMachine to subdomain2
|
|
userapiclient = self.testClient.getUserApiClient(UserName=self.sdomain_account_user1['account'].name,
|
|
DomainName=self.sdomain_account_user1['domain'].name,
|
|
type=2)
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'])
|
|
self.assertRaises(Exception, self.virtual_machine.assign_virtual_machine, userapiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_10_move_across_subdomain_vm_running(self):
|
|
"""Test as domain admin, stop a VM from subdomain1 and attempt to move it to subdomain2
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1
|
|
# 3. assignVirtualMachine to subdomain2
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'],isRunning=True)
|
|
self.assertRaises(Exception, self.virtual_machine.assign_virtual_machine, self.apiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_11_move_across_subdomain_vm_pfrule(self):
|
|
"""Test as domain admin, stop a VM from subdomain1 and attempt to move it to subdomain2
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1 with PF rule set.
|
|
# 3. assignVirtualMachine to subdomain2
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'],pfrule=True)
|
|
self.assertRaises(Exception, self.virtual_machine.assign_virtual_machine, self.apiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_12_move_across_subdomain_vm_volumes(self):
|
|
"""Test as domain admin, stop a VM from subdomain1 and attempt to move it to subdomain2
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1 with volumes.
|
|
# 3. assignVirtualMachine to subdomain2
|
|
userapiclient = self.testClient.getUserApiClient(UserName=self.sdomain_account_user1['account'].name,
|
|
DomainName=self.sdomain_account_user1['domain'].name,
|
|
type=2)
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'],volume=self.sdomain_account_user1['volume'])
|
|
self.assertRaises(Exception, self.virtual_machine.assign_virtual_machine, userapiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
# Check all volumes attached to same VM
|
|
list_volume_response = list_volumes(self.apiclient,
|
|
virtualmachineid=self.virtual_machine.id,
|
|
type='DATADISK',
|
|
listall=True)
|
|
self.assertEqual(isinstance(list_volume_response, list),
|
|
True,
|
|
"Check list volumes response for valid list")
|
|
|
|
self.assertNotEqual(list_volume_response[0].domainid, self.sdomain_account_user2['domain'].id, "Volume ownership not changed.")
|
|
self.virtual_machine.detach_volume(self.apiclient,
|
|
self.sdomain_account_user1['volume'])
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_13_move_across_subdomain_vm_snapshot(self):
|
|
"""Test as domain admin, stop a VM from subdomain1 and attempt to move it to subdomain2
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1 with snapshot.
|
|
# 3. assign VM will fail with Exception as VM with snapshots cannot be assigned to other users.
|
|
if self.hypervisor.lower() in ['hyperv', 'lxc']:
|
|
self.skipTest("Snapshots feature is not supported on %s" % self.hypervisor)
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'], snapshot=True)
|
|
with self.assertRaises(Exception):
|
|
self.virtual_machine.assign_virtual_machine(self.apiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_14_move_across_subdomain_vm_project(self):
|
|
"""Test as domain admin, stop a VM from subdomain1 and attempt to move it to subdomain2
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1 with snapshot.
|
|
# 3. assignVirtualMachine to subdomain2
|
|
userapiclient = self.testClient.getUserApiClient(UserName=self.sdomain_account_user1['account'].name,
|
|
DomainName=self.sdomain_account_user1['domain'].name,
|
|
type=2)
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'], project=self.sdomain_account_user1['project'])
|
|
self.assertRaises(Exception, self.virtual_machine.assign_virtual_machine, userapiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_15_move_across_subdomain_account_limit(self):
|
|
"""Test as domain admin, stop a VM from subdomain1 and attempt to move it to subdomain2 when limit reached
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1 when account limit is reached.
|
|
# 3. assignVirtualMachine to subdomain2
|
|
if self.hypervisor.lower() in ['hyperv', 'lxc']:
|
|
self.skipTest("Snapshots feature is not supported on %s" % self.hypervisor)
|
|
update_resource_limit(self.apiclient,
|
|
0, # VM Instances
|
|
account=self.sdomain_account_user2['account'].name,
|
|
domainid=self.sdomain_account_user2['domain'].id,
|
|
max=0)
|
|
userapiclient = self.testClient.getUserApiClient(UserName=self.sdomain_account_user1['account'].name,
|
|
DomainName=self.sdomain_account_user1['domain'].name,
|
|
type=2)
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'], snapshot=True)
|
|
self.assertRaises(Exception, self.virtual_machine.assign_virtual_machine, userapiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
|
|
@attr(tags = ["advanced"])
|
|
@log_test_exceptions
|
|
def test_16_move_across_subdomain_volume_and_account_limit(self):
|
|
"""Test as domain admin, stop a VM from subdomain1 and attempt to move it to subdomain2 volumes are attached and limit reached
|
|
"""
|
|
# Validate the following:
|
|
# 1. deploy VM in sub subdomain1 when account limit is reached.
|
|
# 3. assignVirtualMachine to subdomain2
|
|
if self.hypervisor.lower() in ['hyperv', 'lxc']:
|
|
self.skipTest("Snapshots feature is not supported on %s" % self.hypervisor)
|
|
update_resource_limit(
|
|
self.apiclient,
|
|
0, # VM Instances
|
|
account=self.sdomain_account_user2['account'].name,
|
|
domainid=self.sdomain_account_user2['domain'].id,
|
|
max=0)
|
|
userapiclient = self.testClient.getUserApiClient(UserName=self.sdomain_account_user1['account'].name,
|
|
DomainName=self.sdomain_account_user1['domain'].name,
|
|
type=2)
|
|
self.create_vm(self.sdomain_account_user1['account'], self.sdomain_account_user1['domain'], snapshot=True, volume=self.sdomain_account_user1['volume'])
|
|
self.assertRaises(Exception, self.virtual_machine.assign_virtual_machine, userapiclient, self.sdomain_account_user2['account'].name ,self.sdomain_account_user2['domain'].id)
|
|
self.virtual_machine.detach_volume(self.apiclient,
|
|
self.sdomain_account_user1['volume'])
|