def test_template_integrity(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
net_name = 'test-network'
net_args = {
'name': net_name,
'connection': 'nat',
'subnet': '127.0.100.0/24'
}
inst.networks_create(net_args)
path = '/tmp/kimchi-iso/'
if not os.path.exists(path):
os.makedirs(path)
iso = path + 'ubuntu12.04.iso'
iso_gen.construct_fake_iso(iso, True, '12.04', 'ubuntu')
params = {
'name': 'test',
'memory': 1024,
'cpus': 1,
'networks': ['test-network'],
'cdrom': iso
}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
inst.network_delete(net_name)
shutil.rmtree(path)
info = inst.template_lookup('test')
self.assertEquals(info['invalid']['cdrom'], [iso])
self.assertEquals(info['invalid']['networks'], [net_name])
def test_vm_graphics(self):
inst = model.Model(objstore_loc=self.tmp_store)
params = {'name': 'test', 'disks': []}
inst.templates_create(params)
with RollbackContext() as rollback:
params = {'name': 'kimchi-vnc', 'template': '/templates/test'}
inst.vms_create(params)
rollback.prependDefer(inst.vm_delete, 'kimchi-vnc')
info = inst.vm_lookup('kimchi-vnc')
self.assertEquals('vnc', info['graphics']['type'])
self.assertEquals('0.0.0.0', info['graphics']['listen'])
graphics = {'type': 'spice', 'listen': '127.0.0.1'}
params = {
'name': 'kimchi-spice',
'template': '/templates/test',
'graphics': graphics
}
inst.vms_create(params)
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_repository_disable_enable(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
system_host_repos = len(inst.repositories_get_list())
repo = {
'repo_id': 'fedora-fake',
'repo_name': 'Fedora 19 FAKE',
'baseurl': 'http://www.fedora.org'
}
inst.repositories_create(repo)
host_repos = inst.repositories_get_list()
self.assertEquals(system_host_repos + 1, len(host_repos))
repo_info = inst.repository_lookup(repo.get('repo_id'))
self.assertEquals(True, repo_info.get('enabled'))
inst.repository_disable(repo.get('repo_id'))
repo_info = inst.repository_lookup(repo.get('repo_id'))
self.assertEquals(False, repo_info.get('enabled'))
inst.repository_enable(repo.get('repo_id'))
repo_info = inst.repository_lookup(repo.get('repo_id'))
self.assertEquals(True, repo_info.get('enabled'))
# remove files creates
inst.repository_delete(repo['repo_id'])
def test_network(self):
inst = model.Model('qemu:///system', self.tmp_store)
with RollbackContext() as rollback:
# Regression test:
# Kimchi fails creating new network #318
name = 'test-network-no-subnet'
networks = inst.networks_get_list()
num = len(networks) + 1
args = {'name': name, 'connection': 'nat', 'subnet': ''}
inst.networks_create(args)
rollback.prependDefer(inst.network_delete, name)
networks = inst.networks_get_list()
self.assertEquals(num, len(networks))
networkinfo = inst.network_lookup(name)
self.assertNotEqual(args['subnet'], networkinfo['subnet'])
self.assertEqual(args['connection'], networkinfo['connection'])
self.assertEquals('inactive', networkinfo['state'])
self.assertEquals([], networkinfo['vms'])
self.assertTrue(networkinfo['autostart'])
inst.network_activate(name)
rollback.prependDefer(inst.network_deactivate, name)
networkinfo = inst.network_lookup(name)
self.assertEquals('active', networkinfo['state'])
# test network creation with subnet passed
name = 'test-network-subnet'
networks = inst.networks_get_list()
num = len(networks) + 1
args = {
'name': name,
'connection': 'nat',
'subnet': '127.0.100.0/24'
}
inst.networks_create(args)
rollback.prependDefer(inst.network_delete, name)
networks = inst.networks_get_list()
self.assertEquals(num, len(networks))
networkinfo = inst.network_lookup(name)
self.assertEqual(args['subnet'], networkinfo['subnet'])
self.assertEqual(args['connection'], networkinfo['connection'])
self.assertEquals('inactive', networkinfo['state'])
self.assertEquals([], networkinfo['vms'])
self.assertTrue(networkinfo['autostart'])
inst.network_activate(name)
rollback.prependDefer(inst.network_deactivate, name)
networkinfo = inst.network_lookup(name)
self.assertEquals('active', networkinfo['state'])
networks = inst.networks_get_list()
self.assertEquals((num - 2), len(networks))
def test_deep_scan(self):
inst = model.Model(None, objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
path = '/tmp/kimchi-images/tmpdir'
if not os.path.exists(path):
os.makedirs(path)
iso_gen.construct_fake_iso(
'/tmp/kimchi-images/tmpdir/'
'ubuntu12.04.iso', True, '12.04', 'ubuntu')
iso_gen.construct_fake_iso('/tmp/kimchi-images/sles10.iso', True,
'10', 'sles')
args = {
'name': 'kimchi-scanning-pool',
'path': '/tmp/kimchi-images',
'type': 'kimchi-iso'
}
inst.storagepools_create(args)
rollback.prependDefer(shutil.rmtree, '/tmp/kimchi-images')
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_vm_info(self):
inst = model.Model('test:///default', self.tmp_store)
vms = inst.vms_get_list()
self.assertEquals(1, len(vms))
self.assertEquals('test', vms[0])
keys = set(
('name', 'state', 'stats', 'uuid', 'memory', 'cpus', 'screenshot',
'icon', 'graphics', 'users', 'groups', 'access', 'persistent'))
stats_keys = set(
('cpu_utilization', 'net_throughput', 'net_throughput_peak',
'io_throughput', 'io_throughput_peak'))
info = inst.vm_lookup('test')
self.assertEquals(keys, set(info.keys()))
self.assertEquals('running', info['state'])
self.assertEquals('test', info['name'])
self.assertEquals(2048, info['memory'])
self.assertEquals(2, info['cpus'])
self.assertEquals(None, info['icon'])
self.assertEquals(stats_keys, set(info['stats'].keys()))
self.assertRaises(NotFoundError, inst.vm_lookup, 'nosuchvm')
self.assertEquals([], info['users'])
self.assertEquals([], info['groups'])
self.assertTrue(info['persistent'])
def test_get_hostinfo(self):
inst = model.Model('qemu:///system', objstore_loc=self.tmp_store)
info = inst.host_lookup()
distro, version, codename = platform.linux_distribution()
self.assertIn('cpu', info)
self.assertEquals(distro, info['os_distro'])
self.assertEquals(version, info['os_version'])
self.assertEquals(unicode(codename, "utf-8"), info['os_codename'])
self.assertEquals(psutil.TOTAL_PHYMEM, info['memory'])
def test_get_distros(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
distros = inst.distros_get_list()
for d in distros:
distro = inst.distro_lookup(d)
self.assertIn('name', distro)
self.assertIn('os_distro', distro)
self.assertIn('os_version', distro)
self.assertIn('path', distro)
def test_storagevolume(self):
inst = model.Model('qemu:///system', self.tmp_store)
with RollbackContext() as rollback:
path = '/tmp/kimchi-images'
pool = 'test-pool'
vol = 'test-volume.img'
if not os.path.exists(path):
os.mkdir(path)
args = {'name': pool, 'path': path, 'type': 'dir'}
inst.storagepools_create(args)
rollback.prependDefer(inst.storagepool_delete, pool)
self.assertRaises(InvalidOperation, inst.storagevolumes_get_list,
pool)
poolinfo = inst.storagepool_lookup(pool)
self.assertEquals(0, poolinfo['nr_volumes'])
# Activate the pool before adding any volume
inst.storagepool_activate(pool)
rollback.prependDefer(inst.storagepool_deactivate, pool)
vols = inst.storagevolumes_get_list(pool)
num = len(vols) + 2
params = {
'name': vol,
'capacity': 1024,
'allocation': 512,
'format': 'raw'
}
inst.storagevolumes_create(pool, params)
rollback.prependDefer(inst.storagevolume_delete, pool, vol)
fd, path = tempfile.mkstemp(dir=path)
name = os.path.basename(path)
rollback.prependDefer(inst.storagevolume_delete, pool, name)
vols = inst.storagevolumes_get_list(pool)
self.assertIn(name, vols)
self.assertEquals(num, len(vols))
inst.storagevolume_wipe(pool, vol)
volinfo = inst.storagevolume_lookup(pool, vol)
self.assertEquals(0, volinfo['allocation'])
volinfo = inst.storagevolume_lookup(pool, vol)
# Define the size = capacity + 16M
capacity = volinfo['capacity'] >> 20
size = capacity + 16
inst.storagevolume_resize(pool, vol, size)
volinfo = inst.storagevolume_lookup(pool, vol)
self.assertEquals((1024 + 16) << 20, volinfo['capacity'])
poolinfo = inst.storagepool_lookup(pool)
self.assertEquals(len(vols), poolinfo['nr_volumes'])
def test_get_interfaces(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
expected_ifaces = netinfo.all_favored_interfaces()
ifaces = inst.interfaces_get_list()
self.assertEquals(len(expected_ifaces), len(ifaces))
for name in expected_ifaces:
iface = inst.interface_lookup(name)
self.assertEquals(iface['name'], name)
self.assertIn('type', iface)
self.assertIn('status', iface)
self.assertIn('ipaddr', iface)
self.assertIn('netmask', iface)
def test_async_tasks(self):
class task_except(Exception):
pass
def quick_op(cb, message):
cb(message, True)
def long_op(cb, params):
time.sleep(params.get('delay', 3))
cb(params.get('message', ''), params.get('result', False))
def abnormal_op(cb, params):
try:
raise task_except
except:
cb("Exception raised", False)
def continuous_ops(cb, params):
cb("step 1 OK")
time.sleep(2)
cb("step 2 OK")
time.sleep(2)
cb("step 3 OK", params.get('result', True))
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
taskid = add_task('', quick_op, inst.objstore, 'Hello')
inst.task_wait(taskid)
self.assertEquals(1, taskid)
self.assertEquals('finished', inst.task_lookup(taskid)['status'])
self.assertEquals('Hello', inst.task_lookup(taskid)['message'])
taskid = add_task('', long_op, inst.objstore, {
'delay': 3,
'result': False,
'message': 'It was not meant to be'
})
self.assertEquals(2, taskid)
self.assertEquals('running', inst.task_lookup(taskid)['status'])
self.assertEquals('OK', inst.task_lookup(taskid)['message'])
inst.task_wait(taskid)
self.assertEquals('failed', inst.task_lookup(taskid)['status'])
self.assertEquals('It was not meant to be',
inst.task_lookup(taskid)['message'])
taskid = add_task('', abnormal_op, inst.objstore, {})
inst.task_wait(taskid)
self.assertEquals('Exception raised',
inst.task_lookup(taskid)['message'])
self.assertEquals('failed', inst.task_lookup(taskid)['status'])
taskid = add_task('', continuous_ops, inst.objstore, {'result': True})
self.assertEquals('running', inst.task_lookup(taskid)['status'])
inst.task_wait(taskid, timeout=10)
self.assertEquals('finished', inst.task_lookup(taskid)['status'])
def test_template_clone(self):
inst = model.Model('qemu:///system', objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
orig_params = {'name': 'test-template', 'memory': 1024, 'cpus': 1}
inst.templates_create(orig_params)
orig_temp = inst.template_lookup(orig_params['name'])
ident = inst.template_clone('test-template')
clone_temp = inst.template_lookup(ident)
clone_temp['name'] = orig_temp['name']
for key in clone_temp.keys():
self.assertEquals(clone_temp[key], orig_temp[key])
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('/')[-1]
rollback.prependDefer(inst.vm_delete, clone1_name)
clone2_name = task2['target_uri'].split('/')[-1]
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_vm_list_sorted(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
params = {'name': 'test', 'disks': []}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {'name': 'kimchi-vm', 'template': '/templates/test'}
inst.vms_create(params)
rollback.prependDefer(inst.vm_delete, 'kimchi-vm')
vms = inst.vms_get_list()
self.assertEquals(vms, sorted(vms, key=unicode.lower))
def test_multithreaded_connection(self):
def worker():
for i in xrange(100):
ret = inst.vms_get_list()
self.assertEquals('test', ret[0])
inst = model.Model('test:///default', self.tmp_store)
threads = []
for i in xrange(100):
t = threading.Thread(target=worker)
t.setDaemon(True)
t.start()
threads.append(t)
for t in threads:
t.join()
def test_vm_storage_provisioning(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
params = {'name': 'test', 'disks': [{'size': 1}]}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {'name': 'test-vm-1', 'template': '/templates/test'}
inst.vms_create(params)
rollback.prependDefer(inst.vm_delete, 'test-vm-1')
vm_info = inst.vm_lookup(params['name'])
disk_path = '/var/lib/libvirt/images/%s-0.img' % vm_info['uuid']
self.assertTrue(os.access(disk_path, os.F_OK))
self.assertFalse(os.access(disk_path, os.F_OK))
def test_debug_reports(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
if not inst.capabilities_lookup()['system_report_tool']:
raise unittest.SkipTest("Without debug report tool")
try:
timeout = int(os.environ['TEST_REPORT_TIMEOUT'])
except (ValueError, KeyError):
timeout = 120
namePrefix = 'unitTestReport'
# sosreport always deletes unsual letters like '-' and '_' in the
# generated report file name.
uuidstr = str(uuid.uuid4()).translate(None, "-_")
reportName = namePrefix + uuidstr
try:
inst.debugreport_delete(namePrefix + '*')
except NotFoundError:
pass
with RollbackContext() as rollback:
report_list = inst.debugreports_get_list()
self.assertFalse(reportName in report_list)
try:
tmp_name = reportName + "_1"
task = inst.debugreports_create({'name': reportName})
rollback.prependDefer(inst.debugreport_delete, tmp_name)
taskid = task['id']
inst.task_wait(taskid, timeout)
self.assertEquals(
'finished',
inst.task_lookup(taskid)['status'],
"It is not necessary an error. "
"You may need to increase the "
"timeout number by "
"TEST_REPORT_TIMEOUT=200 "
"./run_tests.sh test_model")
report_list = inst.debugreports_get_list()
self.assertTrue(reportName in report_list)
name = inst.debugreport_update(reportName, {'name': tmp_name})
self.assertEquals(name, tmp_name)
report_list = inst.debugreports_get_list()
self.assertTrue(tmp_name in report_list)
except OperationFailed, e:
if 'debugreport tool not found' not in e.message:
raise e
def test_repository_disable_enable(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
yum_repo = {
'repo_id': 'fedora-fake',
'baseurl': 'http://www.fedora.org'
}
deb_repo = {
'baseurl': 'http://archive.ubuntu.com/ubuntu/',
'config': {
'dist': 'quantal'
}
}
repo_type = inst.capabilities_lookup()['repo_mngt_tool']
if repo_type == 'yum':
repo = yum_repo
elif repo_type == 'deb':
repo = deb_repo
else:
# repository management tool was not recognized by Kimchi
# skip test case
return
system_host_repos = len(inst.repositories_get_list())
repo_id = inst.repositories_create(repo)
host_repos = inst.repositories_get_list()
self.assertEquals(system_host_repos + 1, len(host_repos))
repo_info = inst.repository_lookup(repo_id)
self.assertEquals(True, repo_info['enabled'])
inst.repository_disable(repo_id)
repo_info = inst.repository_lookup(repo_id)
self.assertEquals(False, repo_info['enabled'])
inst.repository_enable(repo_id)
repo_info = inst.repository_lookup(repo_id)
self.assertEquals(True, repo_info['enabled'])
# remove files creates
inst.repository_delete(repo_id)
def test_vm_ifaces(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
params = {'name': 'test', 'disks': []}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {'name': 'kimchi-ifaces', 'template': '/templates/test'}
inst.vms_create(params)
rollback.prependDefer(inst.vm_delete, 'kimchi-ifaces')
# Create a network
net_name = 'test-network'
net_args = {
'name': net_name,
'connection': 'nat',
'subnet': '127.0.100.0/24'
}
inst.networks_create(net_args)
rollback.prependDefer(inst.network_delete, net_name)
ifaces = inst.vmifaces_get_list('kimchi-ifaces')
self.assertEquals(1, len(ifaces))
iface = inst.vmiface_lookup('kimchi-ifaces', ifaces[0])
self.assertEquals(17, len(iface['mac']))
self.assertEquals("default", iface['network'])
self.assertIn("model", iface)
# attach network interface to vm
iface_args = {
"type": "network",
"network": "test-network",
"model": "virtio"
}
mac = inst.vmifaces_create('kimchi-ifaces', iface_args)
self.assertEquals(17, len(mac))
# detach network interface from vm
rollback.prependDefer(inst.vmiface_delete, 'kimchi-ifaces', mac)
iface = inst.vmiface_lookup('kimchi-ifaces', mac)
self.assertEquals("network", iface["type"])
self.assertEquals("test-network", iface['network'])
self.assertEquals("virtio", iface["model"])
def test_template_update(self):
inst = model.Model('qemu:///system', objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
net_name = 'test-network'
net_args = {
'name': net_name,
'connection': 'nat',
'subnet': '127.0.100.0/24'
}
inst.networks_create(net_args)
rollback.prependDefer(inst.network_delete, net_name)
orig_params = {'name': 'test', 'memory': 1024, 'cpus': 1}
inst.templates_create(orig_params)
params = {'name': 'new-test'}
self.assertEquals('new-test', inst.template_update('test', params))
self.assertRaises(NotFoundError, inst.template_delete, 'test')
params = {'name': 'new-test', 'memory': 512, 'cpus': 2}
inst.template_update('new-test', params)
rollback.prependDefer(inst.template_delete, 'new-test')
info = inst.template_lookup('new-test')
for key in params.keys():
self.assertEquals(params[key], info[key])
self.assertEquals("default", info["networks"][0])
params = {
'name': 'new-test',
'memory': 1024,
'cpus': 1,
'networks': ['default', 'test-network']
}
inst.template_update('new-test', params)
info = inst.template_lookup('new-test')
for key in params.keys():
self.assertEquals(params[key], info[key])
# test update with non-existent network
params = {'networks': ["no-exist"]}
self.assertRaises(InvalidParameter, inst.template_update,
'new-test', params)
def test_repository_create(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
system_host_repos = len(inst.repositories_get_list())
test_repos = [{
'repo_id': 'fedora-fake',
'baseurl': 'http://www.fedora.org'
}, {
'repo_id': 'fedora-updates-fake',
'baseurl': 'http://www.fedora.org/updates',
'is_mirror': True,
'gpgkey': 'file:///tmp/KEY-fedora-updates-fake-19'
}]
for repo in test_repos:
inst.repositories_create(repo)
host_repos = inst.repositories_get_list()
self.assertEquals(system_host_repos + len(test_repos), len(host_repos))
for repo in test_repos:
repo_info = inst.repository_lookup(repo.get('repo_id'))
self.assertEquals(repo.get('repo_id'), repo_info.get('repo_id'))
self.assertEquals(repo.get('baseurl', []),
repo_info.get('baseurl'))
self.assertEquals(repo.get('is_mirror', False),
repo_info.get('is_mirror'))
self.assertEquals(True, repo_info.get('enabled'))
if 'gpgkey' in repo.keys():
gpgcheck = True
else:
gpgcheck = False
self.assertEquals(gpgcheck, repo_info.get('gpgcheck'))
self.assertRaises(NotFoundError, inst.repository_lookup, 'google')
# remove files created
for repo in test_repos:
inst.repository_delete(repo['repo_id'])
self.assertRaises(NotFoundError, inst.repository_lookup,
repo['repo_id'])
def test_delete_running_vm(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
params = {'name': u'test', 'disks': []}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {'name': u'kīмсhī-∨м', 'template': u'/templates/test'}
inst.vms_create(params)
rollback.prependDefer(self._rollback_wrapper, inst.vm_delete,
u'kīмсhī-∨м')
inst.vm_start(u'kīмсhī-∨м')
rollback.prependDefer(self._rollback_wrapper, inst.vm_stop,
u'kīмсhī-∨м')
inst.vm_delete(u'kīмсhī-∨м')
vms = inst.vms_get_list()
self.assertFalse(u'kīмсhī-∨м' in vms)
def test_template_storage_customise(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
path = '/tmp/kimchi-images'
pool = 'test-pool'
if not os.path.exists(path):
os.mkdir(path)
params = {'name': 'test', 'disks': [{'size': 1}]}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {'storagepool': '/storagepools/test-pool'}
self.assertRaises(InvalidParameter, inst.template_update, 'test',
params)
args = {'name': pool, 'path': path, 'type': 'dir'}
inst.storagepools_create(args)
rollback.prependDefer(inst.storagepool_delete, pool)
inst.template_update('test', params)
params = {'name': 'test-vm-1', 'template': '/templates/test'}
self.assertRaises(InvalidParameter, inst.vms_create, params)
inst.storagepool_activate(pool)
rollback.prependDefer(inst.storagepool_deactivate, pool)
inst.vms_create(params)
rollback.prependDefer(inst.vm_delete, 'test-vm-1')
vm_info = inst.vm_lookup(params['name'])
disk_path = '/tmp/kimchi-images/%s-0.img' % vm_info['uuid']
self.assertTrue(os.access(disk_path, os.F_OK))
# reset template to default storage pool
# so we can remove the storage pool created 'test-pool'
params = {'storagepool': '/storagepools/default'}
inst.template_update('test', params)
def test_template_create(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
# Test non-exist path raises InvalidParameter
params = {'name': 'test', 'cdrom': '/non-exsitent.iso'}
self.assertRaises(InvalidParameter, inst.templates_create, params)
# Test non-iso path raises InvalidParameter
params['cdrom'] = os.path.abspath(__file__)
self.assertRaises(InvalidParameter, inst.templates_create, params)
with RollbackContext() as rollback:
net_name = 'test-network'
net_args = {
'name': net_name,
'connection': 'nat',
'subnet': '127.0.100.0/24'
}
inst.networks_create(net_args)
rollback.prependDefer(inst.network_delete, net_name)
params = {'name': 'test', 'memory': 1024, 'cpus': 1}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
info = inst.template_lookup('test')
for key in params.keys():
self.assertEquals(params[key], info[key])
self.assertEquals("default", info["networks"][0])
# create template with non-existent network
params['name'] = 'new-test'
params['networks'] = ["no-exist"]
self.assertRaises(InvalidParameter, inst.templates_create, params)
params['networks'] = ['default', 'test-network']
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, params['name'])
info = inst.template_lookup(params['name'])
for key in params.keys():
self.assertEquals(params[key], info[key])
def test_use_test_host(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
params = {
'name': 'test',
'disks': [],
'storagepool': '/storagepools/default-pool',
'domain': 'test',
'arch': 'i686'
}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {'name': 'kimchi-vm', 'template': '/templates/test'}
inst.vms_create(params)
rollback.prependDefer(inst.vm_delete, 'kimchi-vm')
vms = inst.vms_get_list()
self.assertTrue('kimchi-vm' in vms)
def test_vm_edit(self):
inst = model.Model('qemu:///system', objstore_loc=self.tmp_store)
orig_params = {'name': 'test', 'memory': '1024', 'cpus': '1'}
inst.templates_create(orig_params)
with RollbackContext() as rollback:
params_1 = {'name': 'kimchi-vm1', 'template': '/templates/test'}
params_2 = {'name': 'kimchi-vm2', 'template': '/templates/test'}
inst.vms_create(params_1)
inst.vms_create(params_2)
rollback.prependDefer(self._rollback_wrapper, inst.vm_delete,
'kimchi-vm1')
rollback.prependDefer(self._rollback_wrapper, inst.vm_delete,
'kimchi-vm2')
vms = inst.vms_get_list()
self.assertTrue('kimchi-vm1' in vms)
inst.vm_start('kimchi-vm1')
rollback.prependDefer(self._rollback_wrapper, inst.vm_stop,
'kimchi-vm1')
info = inst.vm_lookup('kimchi-vm1')
self.assertEquals('running', info['state'])
params = {'name': 'new-vm'}
self.assertRaises(InvalidParameter, inst.vm_update, 'kimchi-vm1',
params)
inst.vm_stop('kimchi-vm1')
params = {'name': u'пeω-∨м'}
self.assertRaises(OperationFailed, inst.vm_update, 'kimchi-vm1',
{'name': 'kimchi-vm2'})
inst.vm_update('kimchi-vm1', params)
self.assertEquals(info['uuid'], inst.vm_lookup(u'пeω-∨м')['uuid'])
rollback.prependDefer(self._rollback_wrapper, inst.vm_delete,
u'пeω-∨м')
def test_get_hoststats(self):
inst = model.Model('test:///default', objstore_loc=self.tmp_store)
time.sleep(1.5)
stats = inst.hoststats_lookup()
cpu_utilization = stats['cpu_utilization']
# cpu_utilization is set int 0, after first stats sample
# the cpu_utilization is float in range [0.0, 100.0]
self.assertIsInstance(cpu_utilization, float)
self.assertGreaterEqual(cpu_utilization, 0.0)
self.assertTrue(cpu_utilization <= 100.0)
memory_stats = stats['memory']
self.assertIn('total', memory_stats)
self.assertIn('free', memory_stats)
self.assertIn('cached', memory_stats)
self.assertIn('buffers', memory_stats)
self.assertIn('avail', memory_stats)
self.assertIn('disk_read_rate', stats)
self.assertIn('disk_write_rate', stats)
self.assertIn('net_recv_rate', stats)
self.assertIn('net_sent_rate', stats)
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': '/templates/test'}
inst.vms_create(params)
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_vm_lifecycle(self):
inst = model.Model(objstore_loc=self.tmp_store)
with RollbackContext() as rollback:
params = {'name': 'test', 'disks': []}
inst.templates_create(params)
rollback.prependDefer(inst.template_delete, 'test')
params = {'name': 'kimchi-vm', 'template': '/templates/test'}
inst.vms_create(params)
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_stop, 'kimchi-vm')
info = inst.vm_lookup('kimchi-vm')
self.assertEquals('running', info['state'])
vms = inst.vms_get_list()
self.assertFalse('kimchi-vm' in vms)
def _is_yum_distro():
inst = model.Model('test:///default')
repo_type = inst.capabilities_lookup()['repo_mngt_tool']
return repo_type == 'yum'
