def test_vm_clone(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
all_vm_names = inst.vms_get_list()
name = all_vm_names[0]
original_vm = inst.vm_lookup(name)
if original_vm['state'] == u'shutoff':
inst.vm_start(name)
# the VM 'test' should be running by now, so we can't clone it yet
self.assertRaises(InvalidParameter, inst.vm_clone, name)
with RollbackContext() as rollback:
inst.vm_poweroff(name)
rollback.prependDefer(inst.vm_start, name)
# create two simultaneous clones of the same VM
# and make sure both of them complete successfully
task1 = inst.vm_clone(name)
task2 = inst.vm_clone(name)
clone1_name = task1['target_uri'].split('/')[-2]
rollback.prependDefer(inst.vm_delete, clone1_name)
clone2_name = task2['target_uri'].split('/')[-2]
rollback.prependDefer(inst.vm_delete, clone2_name)
inst.task_wait(task1['id'])
task1 = inst.task_lookup(task1['id'])
self.assertEquals('finished', task1['status'])
inst.task_wait(task2['id'])
task2 = inst.task_lookup(task2['id'])
self.assertEquals('finished', task2['status'])
# update the original VM info because its state has changed
original_vm = inst.vm_lookup(name)
clone_vm = inst.vm_lookup(clone1_name)
self.assertNotEqual(original_vm['name'], clone_vm['name'])
self.assertTrue(
re.match(u'%s-clone-\d+' % original_vm['name'],
clone_vm['name']))
del original_vm['name']
del clone_vm['name']
self.assertNotEqual(original_vm['uuid'], clone_vm['uuid'])
del original_vm['uuid']
del clone_vm['uuid']
# compare all VM settings except the ones already compared
# (and removed) above (i.e. 'name' and 'uuid')
self.assertEquals(original_vm, clone_vm)
def test_config_plugins(self):
resp = self.request('/config/plugins')
self.assertEquals(200, resp.status)
plugins = json.loads(resp.read())
if len(plugins) == 0:
return
plugin_name = ''
plugin_state = ''
for p in plugins:
if p.get('name') == 'sample':
plugin_name = p.get('name').encode('utf-8')
plugin_state = p.get('enabled')
break
else:
return
with RollbackContext() as rollback:
rollback.prependDefer(set_plugin_state, plugin_name, plugin_state)
resp = self.request('/config/plugins/sample')
self.assertEquals(200, resp.status)
resp = self.request('/config/plugins/sample/enable', '{}', 'POST')
self.assertEquals(200, resp.status)
resp = self.request('/config/plugins')
self.assertEquals(200, resp.status)
plugins = json.loads(resp.read())
for p in plugins:
if p.get('name') == 'sample':
plugin_state = p.get('enabled')
break
self.assertTrue(plugin_state)
resp = self.request('/config/plugins/sample/disable', '{}', 'POST')
self.assertEquals(200, resp.status)
resp = self.request('/config/plugins')
self.assertEquals(200, resp.status)
plugins = json.loads(resp.read())
for p in plugins:
if p.get('name') == 'sample':
plugin_state = p.get('enabled')
break
self.assertFalse(plugin_state)
def test_image_based_template(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
vol = 'base-vol.img'
params = {'name': vol,
'capacity': 1073741824, # 1 GiB
'allocation': 1048576, # 1 MiB
'format': 'qcow2'}
task_id = inst.storagevolumes_create('default', params)['id']
rollback.prependDefer(inst.storagevolume_delete, 'default', vol)
inst.task_wait(task_id)
self.assertEquals('finished', inst.task_lookup(task_id)['status'])
vol_path = inst.storagevolume_lookup('default', vol)['path']
# Hack the model objstore to add a new template
# It is needed as the image file must be a bootable image when
# using model
# As it is difficult to create one on test runtime, inject a
# template with an empty image file to the objstore to test the
# feature
tmpl_name = "img-tmpl"
tmpl_info = {"cpus": 1, "cdrom": "",
"graphics": {"type": "vnc", "listen": "127.0.0.1"},
"networks": ["default"], "memory": 1024, "folder": [],
"icon": "images/icon-vm.png",
"os_distro": "unknown", "os_version": "unknown",
"disks": [{"base": vol_path, "size": 10}],
"storagepool": "/plugins/kimchi/storagepools/default"}
with inst.objstore as session:
session.store('template', tmpl_name, tmpl_info,
get_kimchi_version())
params = {'name': 'kimchi-vm',
'template': '/plugins/kimchi/templates/img-tmpl'}
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)
inst.vm_start('kimchi-vm')
rollback.prependDefer(inst.vm_poweroff, 'kimchi-vm')
info = inst.vm_lookup('kimchi-vm')
self.assertEquals('running', info['state'])
def test_vm_migrate_fails_if_remote_is_localhost(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', '127.0.0.1')
self.assertRaises(OperationFailed, self.inst.vm_migrate,
'test_vm_migrate', 'localhost')
hostname = socket.gethostname()
self.assertRaises(OperationFailed, self.inst.vm_migrate,
'test_vm_migrate', hostname)
def _device_offline(device):
"""
Bring device offline, if it is not offline.
On success, if device is dasd-eckd and if it is present in DASD_CONF then
remove it from DASD_CONF file.
And if failed to remove it, then bring the device in previous state.
:param device: device id
"""
with RollbackContext() as rollback:
if _is_online(device):
_bring_offline(device)
rollback.prependDefer(_bring_online, device)
if _is_dasdeckd_device(device):
if _is_dasdeckd_persisted(device):
_unpersist_dasdeckd_device(device)
rollback.commitAll()
def test_vm_livemigrate_transient(self):
inst = model.Model(libvirt_uri='qemu:///system',
objstore_loc=self.tmp_store)
self.create_vm_test()
with RollbackContext() as rollback:
try:
# 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])
self.inst.vm_start('test_vm_migrate')
# to make the VM transient, undefine it while it's running
vm = VMModel.get_vm(
'test_vm_migrate',
LibvirtConnection('qemu:///system')
)
vm.undefine()
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.assertFalse(remote_vm.isPersistent())
remote_vm.destroy()
except Exception, e:
# Clean up here instead of rollback because if the
# VM was turned transient and shut down it might
# not exist already - rollback in this case will cause
# a QEMU error
vm = VMModel.get_vm(
'test_vm_migrate',
LibvirtConnection('qemu:///system')
)
if vm.isPersistent():
vm.undefine()
vm.shutdown()
self.fail('Migration test failed: %s' % e.message)
def test_create_user(self):
user = '******'
passwd = 'fakepass'
common_users = users.get_users()
with RollbackContext() as rollback:
users.create_user(user, passwd)
rollback.prependDefer(users.delete_user, user)
new_users = users.get_users()
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 test_vm_list_sorted(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO}
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.assertEquals(vms, sorted(vms, key=unicode.lower))
def test_vm_livemigrate_persistent_API(self):
patch_auth()
with RollbackContext() as rollback:
test_server = run_server()
rollback.prependDefer(test_server.stop)
self.request = partial(request)
self.create_vm_test()
rollback.prependDefer(rollback_wrapper, self.inst.vm_delete,
'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 as 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.assertEqual(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.assertEqual('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 as e:
self.fail('Migration test failed: %s' % e.message)
def _attach_all_devices(self, pci_infos):
with RollbackContext() as rollback:
for pci_info in pci_infos:
try:
dev = self.conn.get().nodeDeviceLookupByName(
pci_info['name'])
dev.dettach()
except Exception:
msg = WokMessage('KCHVMHDEV0005E',
{'name': pci_info['name']})
self._cb(msg.get_text(), False)
raise OperationFailed('KCHVMHDEV0005E',
{'name': pci_info['name']})
else:
rollback.prependDefer(dev.reAttach)
rollback.commitAll()
def test_creating_existing_user_fails(self):
users_model = UsersModel()
user_model = UserModel()
user = '******'
passwd = 'fakepass'
group = 'unit_test_fake_group'
profile = 'unit_test_fake_profile'
params = {'name': user, 'password': passwd,
'group': group, 'profile': profile}
with RollbackContext() as rollback:
users_model.create(params)
rollback.prependDefer(user_model.delete, user)
with self.assertRaises(OperationFailed):
users_model.create(params)
def test_vm_migrate_fails_different_remote_hypervisor(
self, mock_get_remote_conn):
class MockRemoteConnObj(object):
def getType(self):
return 'another_hypervisor'
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,
u'test_vm_migrate')
self.assertRaises(OperationFailed, self.inst.vm_migrate,
'test_vm_migrate', KIMCHI_LIVE_MIGRATION_TEST)
def _attach_scsi_device(self, cb, params):
cb('Attaching SCSI device...')
self._cb = cb
vmid = params['vmid']
dev_info = params['dev_info']
lock = params['lock']
try:
self._passthrough_device_validate(dev_info['name'])
except InvalidParameter as e:
cb(str(e), False)
raise
with lock:
dom = VMModel.get_vm(vmid, self.conn)
with RollbackContext() as rollback:
xmlstr = self._get_scsi_device_xml(dev_info)
device_flags = get_vm_config_flag(dom, mode='all')
try:
cb('Attaching device to VM')
dom.attachDeviceFlags(xmlstr, device_flags)
except libvirt.libvirtError:
msg = WokMessage(
'KCHVMHDEV0007E', {
'device': dev_info['name'], 'vm': vmid}
)
cb(msg.get_text(), False)
wok_log.error(
'Failed to attach host device %s to VM %s: \n%s',
dev_info['name'],
vmid,
xmlstr,
)
raise
rollback.prependDefer(
dom.detachDeviceFlags, xmlstr, device_flags)
rollback.commitAll()
if DOM_STATE_MAP[dom.info()[0]] == 'shutoff':
cb('OK', True)
def _unconfigure_interface(cb, interface):
"""
method to un-configure/remove and unpersist network device.
Rollback is performed if it fails to unpersist.
:param interface: network device id
:return: None
"""
cb('') # reset messages
try:
with RollbackContext() as rollback:
if _is_interface_online(interface):
_bring_offline(interface)
rollback.prependDefer(_bring_online, interface)
_unpersist_interface(interface)
rollback.commitAll()
cb('Successfully un-configured network device %s' % interface, True)
except Exception as e:
cb(e.message, False)
def test_get_networks(self):
networks = json.loads(
self.request('/plugins/kimchi/networks').read().decode('utf-8'))
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 range(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.assertEqual(201, resp.status)
network = json.loads(resp.read().decode('utf-8'))
self.assertEqual([], network['vms'])
nets = json.loads(
self.request('/plugins/kimchi/networks').read().decode(
'utf-8'))
self.assertEqual(len(networks) + 5, len(nets))
network = json.loads(
self.request('/plugins/kimchi/networks/network-1').read().
decode('utf-8'))
keys = [
'name',
'connection',
'interfaces',
'subnet',
'dhcp',
'vms',
'in_use',
'autostart',
'state',
'persistent',
]
self.assertEqual(sorted(keys), sorted(network.keys()))
def test_create_debugreport(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'])
rollback.prependDefer(self._report_delete, 'test_rest_report2')
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)
req = json.dumps({'name': 'test_rest_report2'})
resp = request(
'/plugins/gingerbase/debugreports/test_rest_report1', req,
'PUT')
self.assertEquals(303, resp.status)
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 _configure_interface(cb, interface):
"""
method to configure and persist network device.
Rollback is performed if it fails to persist.
:param interface: network device id
:return: None
"""
cb('') # reset messages
try:
with RollbackContext() as rollback:
if not _is_interface_online(interface):
_bring_online(interface)
rollback.prependDefer(_bring_offline, interface)
_create_ifcfg_file(interface)
_persist_interface(interface)
rollback.commitAll()
cb('Successfully configured network device %s' % interface, True)
except Exception as e:
cb(e.__str__(), False)
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 create(self, vmid, params):
dev_name = params['name']
self._passthrough_device_validate(dev_name)
dev_info = DeviceModel(conn=self.conn).lookup(dev_name)
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)
attach_device = getattr(
self, '_attach_%s_device' % dev_info['device_type'])
info = attach_device(vmid, dev_info)
rollback.commitAll()
return info
def _attach_usb_device(self, cb, params):
cb('Attaching USB device...')
vmid = params['vmid']
dev_info = params['dev_info']
dom = VMModel.get_vm(vmid, self.conn)
with RollbackContext() as rollback:
cb('Reading source device XML')
xmlstr = self._get_usb_device_xml(dev_info)
device_flags = get_vm_config_flag(dom, mode='all')
try:
cb('Attaching device to VM')
dom.attachDeviceFlags(xmlstr, device_flags)
except libvirt.libvirtError:
wok_log.error('Failed to attach host device %s to VM %s: \n%s',
dev_info['name'], vmid, xmlstr)
raise
rollback.prependDefer(dom.detachDeviceFlags, xmlstr, device_flags)
rollback.commitAll()
cb('OK', True)
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_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(OperationFailed):
fs.create({'type': fstype, 'blk_dev': blkdev,
'mount_point': mntpt,
'persistent': persistent})
delete_file(self)
def test_template_uses_qcow2_format_if_no_user_or_default_defined(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
self._create_template_conf_with_disk_format(None)
rollback.prependDefer(self._restore_template_conf_file)
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')
created_disk_format = self._get_disk_format_from_vm(
'test-vm-1', inst.conn
)
self.assertEqual(created_disk_format, 'qcow2')
def test_vm_livemigrate_persistent_nonshared(self):
with RollbackContext() as rollback:
self.create_vm_test(non_shared_storage=True)
rollback.prependDefer(rollback_wrapper, self.inst.vm_delete,
u'test_vm_migrate')
# getting disk path info to clean it up later
storage_list = self.inst.vmstorages_get_list('test_vm_migrate')
disk_info = self.inst.vmstorage_lookup(
'test_vm_migrate',
storage_list[0]
)
disk_path = disk_info.get('path')
try:
self.inst.vm_start('test_vm_migrate')
except Exception, e:
self.fail('Failed to start the vm, reason: %s' % e.message)
try:
task = self.inst.vm_migrate('test_vm_migrate',
KIMCHI_LIVE_MIGRATION_TEST)
self.inst.task_wait(task['id'], 3600)
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()
self._erase_remote_file(disk_path)
self._erase_remote_file(UBUNTU_ISO)
except Exception, e:
self.fail('Migration test failed: %s' % e.message)
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 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', 'r') 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_debugreport_download(self):
req = json.dumps({'name': 'report1'})
with RollbackContext() as rollback:
resp = request(host, ssl_port, '/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, 'report1')
resp = request(host, ssl_port,
'/plugins/gingerbase/debugreports/report1')
debugreport = json.loads(resp.read())
self.assertEquals("report1", debugreport['name'])
self.assertEquals(200, resp.status)
resp = request(host, ssl_port,
'/plugins/gingerbase/debugreports/report1/content')
self.assertEquals(200, resp.status)
resp = request(host, ssl_port,
'/plugins/gingerbase/debugreports/report1')
debugre = json.loads(resp.read())
resp = request(host, ssl_port, '/' + debugre['uri'])
self.assertEquals(200, resp.status)
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 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)