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'