def _attach_pci_device(self, vmid, dev_info):
self._validate_pci_passthrough_env()
dom = VMModel.get_vm(vmid, self.conn)
# Due to libvirt limitation, we don't support live assigne device to
# vfio driver.
driver = ('vfio' if DOM_STATE_MAP[dom.info()[0]] == "shutoff"
and self.caps.kernel_vfio else 'kvm')
# on powerkvm systems it must be vfio driver.
distro, _, _ = platform.linux_distribution()
if distro == 'IBM_PowerKVM':
driver = 'vfio'
# Attach all PCI devices in the same IOMMU group
dev_model = DeviceModel(conn=self.conn)
devs_model = DevicesModel(conn=self.conn)
affected_names = devs_model.get_list(
_passthrough_affected_by=dev_info['name'])
passthrough_names = devs_model.get_list(_cap='pci',
_passthrough='true')
group_names = list(set(affected_names) & set(passthrough_names))
pci_infos = [dev_model.lookup(dev_name) for dev_name in group_names]
pci_infos.append(dev_info)
# all devices in the group that is going to be attached to the vm
# must be detached from the host first
with RollbackContext() as rollback:
for pci_info in pci_infos:
try:
dev = self.conn.get().nodeDeviceLookupByName(
pci_info['name'])
dev.dettach()
except Exception:
raise OperationFailed('KCHVMHDEV0005E',
{'name': pci_info['name']})
else:
rollback.prependDefer(dev.reAttach)
rollback.commitAll()
device_flags = get_vm_config_flag(dom, mode='all')
with RollbackContext() as rollback:
for pci_info in pci_infos:
pci_info['detach_driver'] = driver
xmlstr = self._get_pci_device_xml(pci_info)
try:
dom.attachDeviceFlags(xmlstr, device_flags)
except libvirt.libvirtError:
wok_log.error(
'Failed to attach host device %s to VM %s: \n%s',
pci_info['name'], vmid, xmlstr)
raise
rollback.prependDefer(dom.detachDeviceFlags, xmlstr,
device_flags)
rollback.commitAll()
return dev_info['name']
def create(self, params):
params = self._validate_create_params(params)
username = params['name']
passwd = params['password']
profile = params['profile']
groupname = params['group']
no_login = params['no_login']
with RollbackContext() as rollback:
adm = libuser.admin()
if groupname:
group_obj = adm.lookupGroupByName(groupname)
if group_obj:
group_id = group_obj.get('pw_gid')[0]
else:
group_id = create_group(groupname)
rollback.prependDefer(delete_group, groupname)
else:
group_id = create_group(username)
rollback.prependDefer(delete_group, username)
create_user(username, passwd, group_id, no_login=no_login)
rollback.prependDefer(delete_user, username)
if profile == 'virtuser':
self._add_user_to_kvm_group(username)
if profile == 'admin':
self._add_user_to_sudoers(username)
rollback.commitAll()
return username
def test_debugreport_download(self):
req = json.dumps({'name': 'test_rest_report1'})
with RollbackContext() as rollback:
resp = request('/plugins/gingerbase/debugreports', req, 'POST')
self.assertEquals(202, resp.status)
task = json.loads(resp.read())
# make sure the debugreport doesn't exist until the
# the task is finished
wait_task(self._task_lookup, task['id'], 20)
rollback.prependDefer(self._report_delete, 'test_rest_report1')
resp = request(
'/plugins/gingerbase/debugreports/test_rest_report1'
)
debugreport = json.loads(resp.read())
self.assertEquals('test_rest_report1', debugreport['name'])
self.assertEquals(200, resp.status)
resp = request(
'/plugins/gingerbase/debugreports/test_rest_report1/content'
)
self.assertEquals(200, resp.status)
resp = request(
'/plugins/gingerbase/debugreports/test_rest_report1'
)
debugre = json.loads(resp.read())
resp = request('/' + debugre['uri'])
self.assertEquals(200, resp.status)
def test_vm_migrate_fails_different_remote_arch(self,
mock_get_remote_conn):
class MockRemoteConnObj(object):
def getType(self):
return 'QEMU'
def getInfo(self):
return ['another_arch', 'QEMU']
def close(self):
pass
mock_get_remote_conn.return_value = MockRemoteConnObj()
with RollbackContext() as rollback:
self.create_vm_test()
rollback.prependDefer(rollback_wrapper, self.inst.vm_delete,
'test_vm_migrate')
self.assertRaises(
OperationFailed,
self.inst.vm_migrate,
'test_vm_migrate',
KIMCHI_LIVE_MIGRATION_TEST,
)
def test_vm_storage_provisioning(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
params = {
'name': 'test',
'disks': [{
'size': 1
}],
'cdrom': UBUNTU_ISO
}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {
'name': 'test-vm-1',
'template': '/plugins/kimchi/templates/test'
}
task = inst.vms_create(params)
inst.task_wait(task['id'])
rollback.prependDefer(inst.vm_delete, 'test-vm-1')
vm_info = inst.vm_lookup(params['name'])
disk_path = '%s/%s-0.img' % (
inst.storagepool_lookup('default')['path'], vm_info['uuid'])
self.assertTrue(os.access(disk_path, os.F_OK))
self.assertFalse(os.access(disk_path, os.F_OK))
def test_deep_scan(self):
inst = model.Model(None, objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
deep_path = os.path.join(TMP_DIR, 'deep-scan')
subdir_path = os.path.join(deep_path, 'isos')
if not os.path.exists(subdir_path):
os.makedirs(subdir_path)
ubuntu_iso = os.path.join(deep_path, 'ubuntu12.04.iso')
sles_iso = os.path.join(subdir_path, 'sles10.iso')
iso_gen.construct_fake_iso(ubuntu_iso, True, '12.04', 'ubuntu')
iso_gen.construct_fake_iso(sles_iso, True, '10', 'sles')
args = {
'name': 'kimchi-scanning-pool',
'path': deep_path,
'type': 'kimchi-iso'
}
inst.storagepools_create(args)
rollback.prependDefer(shutil.rmtree, deep_path)
rollback.prependDefer(shutil.rmtree, args['path'])
rollback.prependDefer(inst.storagepool_deactivate, args['name'])
time.sleep(1)
volumes = inst.storagevolumes_get_list(args['name'])
self.assertEquals(len(volumes), 2)
def _configure_interface(cb, params):
"""
method to configure and persist network device.
Rollback is performed if it fails to persist.
:param interface: network device id
:return: None
"""
osa_portno = params.get('osa_portno')
interface = params.get('interface')
cb('') # reset messages
try:
with RollbackContext() as rollback:
if not _is_interface_online(interface):
configured_port = _bring_online(interface, osa_portno)
rollback.prependDefer(_bring_offline, interface)
_create_ifcfg_file(interface)
_persist_interface(interface, configured_port)
rollback.commitAll()
if osa_portno and osa_portno != configured_port:
cb(
'Successfully configured network device "%s" on OSA port 0 '
'since port "%s" was not available.' % (interface, osa_portno),
True)
else:
cb('Successfully configured network device %s' % interface, True)
except Exception as e:
cb(e.message, False)
def test_create_user(self):
users_model = UsersModel()
user_model = UserModel()
user = '******'
passwd = 'fakepass'
group = 'unit_test_fake_group'
profile = 'unit_test_fake_profile'
common_users = users_model.get_list()
params = {'name': user, 'password': passwd,
'group': group, 'profile': profile}
with RollbackContext() as rollback:
users_model.create(params)
rollback.prependDefer(user_model.delete, user)
new_users = users_model.get_list()
self.assertEqual(len(new_users), len(common_users) + 1)
enc_passwd = spwd.getspnam(user)[1]
invalid_passwd = [None, "NP", "!", "!!", "", "LK", "*"]
self.assertNotIn(enc_passwd, invalid_passwd)
self.assertEqual(crypt.crypt(passwd, enc_passwd), enc_passwd)
def has_mem_hotplug_support(conn):
'''
A memory device can be hot-plugged or hot-unplugged since libvirt
version 1.2.14.
'''
# Libvirt < 1.2.14 does not support memory devices, so firstly, check
# its version, then try to attach a device. These steps avoid errors
# with Libvirt 'test' driver for KVM
version = 1000000 * 1 + 1000 * 2 + 14
if libvirt.getVersion() < version:
return False
with RollbackContext() as rollback:
FeatureTests.disable_libvirt_error_logging()
rollback.prependDefer(FeatureTests.enable_libvirt_error_logging)
conn_type = conn.getType().lower()
domain_type = 'test' if conn_type == 'test' else 'kvm'
arch = 'i686' if conn_type == 'test' else platform.machine()
arch = 'ppc64' if arch == 'ppc64le' else arch
dom = conn.defineXML(MAXMEM_VM_XML % {
'name': FEATURETEST_VM_NAME,
'domain': domain_type,
'arch': arch
})
rollback.prependDefer(dom.undefine)
try:
dom.attachDeviceFlags(DEV_MEM_XML,
libvirt.VIR_DOMAIN_MEM_CONFIG)
return True
except libvirt.libvirtError:
return False
def test_set_plugin_state(self, mock_update_cherrypy, mock_config_file):
mock_update_cherrypy.return_value = True
with RollbackContext() as rollback:
config_file_name = self._create_fake_config_file()
rollback.prependDefer(os.remove, config_file_name)
mock_config_file.return_value = config_file_name
set_plugin_state('pluginA', False)
with open(config_file_name, 'r') as f:
updated_conf = f.read()
self.assertEqual(
updated_conf,
self._get_config_file_template(enable=False)
)
set_plugin_state('pluginA', True)
with open(config_file_name, 'r') as f:
updated_conf = f.read()
self.assertEqual(
updated_conf,
self._get_config_file_template(enable=True)
)
def test_vm_livemigrate_persistent(self):
inst = model.Model(libvirt_uri='qemu:///system',
objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
self.create_vm_test()
rollback.prependDefer(utils.rollback_wrapper, self.inst.vm_delete,
u'test_vm_migrate')
# removing cdrom because it is not shared storage and will make
# the migration fail
dev_list = self.inst.vmstorages_get_list('test_vm_migrate')
self.inst.vmstorage_delete('test_vm_migrate', dev_list[0])
try:
self.inst.vm_start('test_vm_migrate')
except Exception, e:
self.fail('Failed to start the vm, reason: %s' % e.message)
try:
task = inst.vm_migrate('test_vm_migrate',
KIMCHI_LIVE_MIGRATION_TEST)
inst.task_wait(task['id'])
self.assertIn('test_vm_migrate', self.get_remote_vm_list())
remote_conn = self.get_remote_conn()
rollback.prependDefer(remote_conn.close)
remote_vm = remote_conn.lookupByName('test_vm_migrate')
self.assertTrue(remote_vm.isPersistent())
remote_vm.destroy()
remote_vm.undefine()
except Exception, e:
self.fail('Migration test failed: %s' % e.message)
def test_use_test_host(self):
inst = model.Model('test:///default',
objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
params = {
'name': 'test',
'disks': [],
'cdrom': UBUNTU_ISO,
'storagepool': '/plugins/kimchi/storagepools/default-pool',
'domain': 'test',
'arch': 'i686'
}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {'name': 'kimchi-vm',
'template': '/plugins/kimchi/templates/test'}
task = inst.vms_create(params)
inst.task_wait(task['id'])
rollback.prependDefer(inst.vm_delete, 'kimchi-vm')
vms = inst.vms_get_list()
self.assertTrue('kimchi-vm' in vms)
def test_vm_coldmigrate(self):
with RollbackContext() as rollback:
self.create_vm_test()
rollback.prependDefer(rollback_wrapper, self.inst.vm_delete,
u'test_vm_migrate')
# removing cdrom because it is not shared storage and will make
# the migration fail
dev_list = self.inst.vmstorages_get_list('test_vm_migrate')
self.inst.vmstorage_delete('test_vm_migrate', dev_list[0])
try:
task = self.inst.vm_migrate('test_vm_migrate',
KIMCHI_LIVE_MIGRATION_TEST)
self.inst.task_wait(task['id'])
self.assertIn('test_vm_migrate', self.get_remote_vm_list())
remote_conn = self.get_remote_conn()
rollback.prependDefer(remote_conn.close)
remote_vm = remote_conn.lookupByName('test_vm_migrate')
self.assertTrue(remote_vm.isPersistent())
state = remote_vm.info()[0]
self.assertEqual(state, libvirt.VIR_DOMAIN_SHUTOFF)
remote_vm.undefine()
except Exception, e:
self.fail('Migration test failed: %s' % e.message)
def probe_user(cls):
with cls.lock:
if cls.user:
return cls.user
arch = 'ppc64' if platform.machine(
) == 'ppc64le' else platform.machine()
xml = cls.SIMPLE_VM_XML % {'name': KVMUSERTEST_VM_NAME, 'arch': arch}
with RollbackContext() as rollback:
with cls.lock:
conn = libvirt.open(None)
rollback.prependDefer(conn.close)
f = libvirt.VIR_DOMAIN_START_AUTODESTROY
dom = conn.createXML(xml, flags=f)
rollback.prependDefer(dom.destroy)
filename = get_libvirt_path(
) + '/qemu/%s.pid' % KVMUSERTEST_VM_NAME
with open(filename) as f:
pidStr = f.read()
p = psutil.Process(int(pidStr))
# bug fix #357
# in psutil 2.0 and above versions, username will be a method,
# not a string
if callable(p.username):
cls.user = p.username()
else:
cls.user = p.username
return cls.user
def test_empty_repo_file(self):
with RollbackContext() as rollback:
repos = get_yum_repositories()
tmp_file_name = _create_empty_repo_file()
rollback.prependDefer(os.remove, tmp_file_name)
repos_after = get_yum_repositories()
self.assertEqual(len(repos_after), len(repos))
def prepare(self, conn):
mnt_point = tempfile.mkdtemp(dir='/tmp')
export_path = "%s:%s" % (self.poolArgs['source']['host'],
self.poolArgs['source']['path'])
mount_cmd = [
"mount", "-o", 'soft,timeo=100,retrans=3,retry=0', export_path,
mnt_point
]
umount_cmd = ["umount", "-f", export_path]
mounted = False
# Due to an NFS bug (See Red Hat BZ 1023059), NFSv4 exports may take
# 10-15 seconds to mount the first time.
cmd_timeout = 15
with RollbackContext() as rollback:
rollback.prependDefer(os.rmdir, mnt_point)
try:
run_command(mount_cmd, cmd_timeout)
rollback.prependDefer(run_command, umount_cmd, cmd_timeout)
except TimeoutExpired:
raise InvalidParameter("KCHPOOL0012E", {'path': export_path})
with open("/proc/mounts", "rb") as f:
rawMounts = f.read()
output_items = ['dev_path', 'mnt_point', 'type']
mounts = parse_cmd_output(rawMounts, output_items)
for item in mounts:
if 'dev_path' in item and item['dev_path'] == export_path:
mounted = True
if not mounted:
raise InvalidParameter("KCHPOOL0013E", {'path': export_path})
def test_vm_memory_hotplug(self):
config.set("authentication", "method", "pam")
inst = model.Model(None, objstore_loc=self.tmp_store)
orig_params = {'name': 'test', 'memory': 1024, 'cdrom': UBUNTU_ISO}
inst.templates_create(orig_params)
with RollbackContext() as rollback:
params = {'name': 'kimchi-vm1',
'template': '/plugins/kimchi/templates/test'}
task1 = inst.vms_create(params)
inst.task_wait(task1['id'])
rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
'kimchi-vm1')
# Start vm
inst.vm_start('kimchi-vm1')
rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff,
'kimchi-vm1')
# Hotplug memory, only available in Libvirt >= 1.2.14
params = {'memory': 2048}
if inst.capabilities_lookup()['mem_hotplug_support']:
inst.vm_update('kimchi-vm1', params)
rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
'kimchi-vm1')
self.assertEquals(params['memory'],
inst.vm_lookup('kimchi-vm1')['memory'])
else:
self.assertRaises(InvalidOperation, inst.vm_update,
'kimchi-vm1', params)
def test_get_networks(self):
networks = json.loads(self.request('/plugins/kimchi/networks').read())
self.assertIn('default', [net['name'] for net in networks])
with RollbackContext() as rollback:
# Now add a couple of Networks to the mock model
for i in xrange(5):
name = 'network-%i' % i
req = json.dumps({
'name': name,
'connection': 'nat',
'subnet': '127.0.10%i.0/24' % i
})
resp = self.request('/plugins/kimchi/networks', req, 'POST')
rollback.prependDefer(model.network_delete, name)
self.assertEquals(201, resp.status)
network = json.loads(resp.read())
self.assertEquals([], network["vms"])
nets = json.loads(self.request('/plugins/kimchi/networks').read())
self.assertEquals(len(networks) + 5, len(nets))
network = json.loads(
self.request('/plugins/kimchi/networks/network-1').read())
keys = [
u'name', u'connection', u'interfaces', u'subnet', u'dhcp',
u'vms', u'in_use', u'autostart', u'state', u'persistent'
]
self.assertEquals(sorted(keys), sorted(network.keys()))
def test_vm_graphics(self):
inst = model.Model(objstore_loc=self.tmp_store)
params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO}
inst.templates_create(params)
with RollbackContext() as rollback:
params = {'name': 'kimchi-vnc',
'template': '/plugins/kimchi/templates/test'}
task1 = inst.vms_create(params)
inst.task_wait(task1['id'])
rollback.prependDefer(inst.vm_delete, 'kimchi-vnc')
info = inst.vm_lookup('kimchi-vnc')
self.assertEquals('vnc', info['graphics']['type'])
self.assertEquals('127.0.0.1', info['graphics']['listen'])
graphics = {'type': 'spice', 'listen': '127.0.0.1'}
params = {'name': 'kimchi-spice',
'template': '/plugins/kimchi/templates/test',
'graphics': graphics}
task2 = inst.vms_create(params)
inst.task_wait(task2['id'])
rollback.prependDefer(inst.vm_delete, 'kimchi-spice')
info = inst.vm_lookup('kimchi-spice')
self.assertEquals('spice', info['graphics']['type'])
self.assertEquals('127.0.0.1', info['graphics']['listen'])
inst.template_delete('test')
def test_mount_existing_fs_fails(self):
fs = filesystem.FileSystemsModel()
fsd = filesystem.FileSystemModel()
create_file(self)
fstype = 'local'
blkdev = '/testfile'
mntpt = '/test'
persistent = False
with RollbackContext() as rollback:
fs.create({
'type': fstype,
'blk_dev': blkdev,
'mount_point': mntpt,
'persistent': persistent
})
rollback.prependDefer(fsd.delete, mntpt)
with self.assertRaises(InvalidParameter):
fs.create({
'type': fstype,
'blk_dev': blkdev,
'mount_point': mntpt,
'persistent': persistent
})
delete_file(self)
def create(self, vmid, params):
dev_name = params['name']
dev_info = self.dev_model.lookup(dev_name)
if dev_info['device_type'] == 'pci':
taskid = AsyncTask(
u'/plugins/kimchi/vms/%s/hostdevs/'
% VMModel.get_vm(vmid, self.conn).name(),
self._attach_pci_device,
{'vmid': vmid, 'dev_info': dev_info, 'lock': threading.RLock()},
).id
return self.task.lookup(taskid)
with RollbackContext() as rollback:
try:
dev = self.conn.get().nodeDeviceLookupByName(dev_name)
dev.dettach()
except Exception:
raise OperationFailed('KCHVMHDEV0005E', {'name': dev_name})
else:
rollback.prependDefer(dev.reAttach)
rollback.commitAll()
taskid = AsyncTask(
u'/plugins/kimchi/vms/%s/hostdevs/'
% VMModel.get_vm(vmid, self.conn).name(),
'_attach_%s_device' % dev_info['device_type'],
{'vmid': vmid, 'dev_info': dev_info, 'lock': threading.RLock()},
).id
return self.task.lookup(taskid)
def test_mount_local_fs(self):
fs = filesystem.FileSystemsModel()
fsd = filesystem.FileSystemModel()
create_file(self)
fstype = 'local'
blkdev = '/testfile'
mntpt = '/test'
persistent = False
fs_list = fs.get_list()
with RollbackContext() as rollback:
fs.create({
'type': fstype,
'blk_dev': blkdev,
'mount_point': mntpt,
'persistent': persistent
})
rollback.prependDefer(fsd.delete, mntpt)
new_fs_list = fs.get_list()
self.assertEqual(len(new_fs_list), len(fs_list) + 1)
delete_file(self)
def test_vm_livemigrate_persistent_API(self):
patch_auth()
inst = model.Model(libvirt_uri='qemu:///system',
objstore_loc=self.tmp_store)
host = '127.0.0.1'
port = get_free_port('http')
ssl_port = get_free_port('https')
cherrypy_port = get_free_port('cherrypy_port')
with RollbackContext() as rollback:
test_server = run_server(host,
port,
ssl_port,
test_mode=True,
cherrypy_port=cherrypy_port,
model=inst)
rollback.prependDefer(test_server.stop)
self.request = partial(request, host, ssl_port)
self.create_vm_test()
rollback.prependDefer(rollback_wrapper, self.inst.vm_delete,
u'test_vm_migrate')
# removing cdrom because it is not shared storage and will make
# the migration fail
dev_list = self.inst.vmstorages_get_list('test_vm_migrate')
self.inst.vmstorage_delete('test_vm_migrate', dev_list[0])
try:
self.inst.vm_start('test_vm_migrate')
except Exception, e:
self.fail('Failed to start the vm, reason: %s' % e.message)
migrate_url = "/plugins/kimchi/vms/%s/migrate" % 'test_vm_migrate'
req = json.dumps({
'remote_host': KIMCHI_LIVE_MIGRATION_TEST,
'user': '******'
})
resp = self.request(migrate_url, req, 'POST')
self.assertEquals(202, resp.status)
task = json.loads(resp.read())
wait_task(self._task_lookup, task['id'])
task = json.loads(
self.request('/plugins/kimchi/tasks/%s' % task['id'],
'{}').read())
self.assertEquals('finished', task['status'])
try:
remote_conn = self.get_remote_conn()
rollback.prependDefer(remote_conn.close)
remote_vm = remote_conn.lookupByName('test_vm_migrate')
self.assertTrue(remote_vm.isPersistent())
remote_vm.destroy()
remote_vm.undefine()
except Exception, e:
self.fail('Migration test failed: %s' % e.message)
def test_delete_running_vm(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
params = {'name': u'test', 'disks': [], 'cdrom': UBUNTU_ISO}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {
'name': u'kīмсhī-∨м',
'template': u'/plugins/kimchi/templates/test'
}
task = inst.vms_create(params)
inst.task_wait(task['id'])
rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
u'kīмсhī-∨м')
inst.vm_start(u'kīмсhī-∨м')
self.assertEquals(inst.vm_lookup(u'kīмсhī-∨м')['state'], 'running')
rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff,
u'kīмсhī-∨м')
inst.vm_delete(u'kīмсhī-∨м')
vms = inst.vms_get_list()
self.assertFalse(u'kīмсhī-∨м' in vms)
def create(self, vmid, params):
dev_name = params['name']
self._passthrough_device_validate(dev_name)
dev_info = DeviceModel(conn=self.conn).lookup(dev_name)
if dev_info['device_type'] == 'pci':
taskid = add_task(
u'/plugins/kimchi/vms/%s/hostdevs/' %
VMModel.get_vm(vmid, self.conn).name(),
self._attach_pci_device, self.objstore, {
'vmid': vmid,
'dev_info': dev_info
})
return self.task.lookup(taskid)
with RollbackContext() as rollback:
try:
dev = self.conn.get().nodeDeviceLookupByName(dev_name)
dev.dettach()
except Exception:
raise OperationFailed('KCHVMHDEV0005E', {'name': dev_name})
else:
rollback.prependDefer(dev.reAttach)
rollback.commitAll()
taskid = add_task(
u'/plugins/kimchi/vms/%s/hostdevs/' %
VMModel.get_vm(vmid, self.conn).name(),
'_attach_%s_device' % dev_info['device_type'], self.objstore, {
'vmid': vmid,
'dev_info': dev_info
})
return self.task.lookup(taskid)
def test_template_creates_user_defined_vol_format_instead_default(self):
inst = model.Model(objstore_loc=self.tmp_store)
default_vol = 'vmdk'
user_vol = 'raw'
with RollbackContext() as rollback:
self._create_template_conf_with_disk_format(default_vol)
rollback.prependDefer(self._restore_template_conf_file)
params = {'name': 'test',
'disks': [{'size': 1, 'format': user_vol}],
'cdrom': UBUNTU_ISO}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {'name': 'test-vm-1',
'template': '/plugins/kimchi/templates/test'}
task = inst.vms_create(params)
inst.task_wait(task['id'])
rollback.prependDefer(inst.vm_delete, 'test-vm-1')
created_disk_format = self._get_disk_format_from_vm(
'test-vm-1', inst.conn
)
self.assertEqual(created_disk_format, user_vol)
def test_vm_migrate_fails_if_not_passwordless_login(self):
with RollbackContext() as rollback:
self.create_vm_test()
rollback.prependDefer(rollback_wrapper, self.inst.vm_delete,
u'test_vm_migrate')
self.assertRaises(OperationFailed, self.inst.vm_migrate,
'test_vm_migrate', 'this_is_a_fake_remote_host')
def test_vm_migrate_fails_if_remotehost_unreachable(self):
with RollbackContext() as rollback:
self.create_vm_test()
rollback.prependDefer(rollback_wrapper, self.inst.vm_delete,
u'test_vm_migrate')
self.assertRaises(OperationFailed, self.inst.vm_migrate,
'test_vm_migrate',
'test.vm.migrate.host.unreachable')
def test_create_existing_user_fails(self):
user = '******'
passwd = 'fakepass'
with RollbackContext() as rollback:
users.create_user(user, passwd)
rollback.prependDefer(users.delete_user, user)
with self.assertRaises(OperationFailed):
users.create_user(user, passwd)
def test_create_group(self):
groupname = 'unit_test_fake_group'
groups = users.get_groups()
with RollbackContext() as rollback:
users.create_group(groupname, 9999)
rollback.prependDefer(users.delete_group, groupname)
new_groups = users.get_groups()
self.assertEqual(len(new_groups), len(groups) + 1)
