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 __init__(self, wok_options): make_dirs = [ os.path.dirname(os.path.abspath(config.get_object_store())), os.path.abspath(config.get_distros_store()), os.path.abspath(config.get_screenshot_path()), os.path.abspath(config.get_virtviewerfiles_path()) ] for directory in make_dirs: if not os.path.isdir(directory): os.makedirs(directory) # When running on test mode, specify the objectstore location to # remove the file on server shutting down. That way, the system will # not suffer any change while running on test mode if wok_options.test and (wok_options.test is True or wok_options.test.lower() == 'true'): self.objectstore_loc = tempfile.mktemp() self.model = mockmodel.MockModel(self.objectstore_loc) def remove_objectstore(): if os.path.exists(self.objectstore_loc): os.unlink(self.objectstore_loc) cherrypy.engine.subscribe('exit', remove_objectstore) else: self.model = kimchiModel.Model() dev_env = wok_options.environment != 'production' super(Kimchi, self).__init__(self.model, dev_env) for ident, node in sub_nodes.items(): setattr(self, ident, node(self.model)) self.api_schema = json.load( open( os.path.join(os.path.dirname(os.path.abspath(__file__)), 'API.json'))) self.paths = config.kimchiPaths self.domain = 'kimchi' self.messages = messages self.extends = { "/plugins/gingerbase": { "host-dashboard.html": "/plugins/kimchi/js/kimchi.peers.js" } } self.depends = ['gingerbase'] # Some paths or URI's present in the objectstore have changed after # Kimchi 2.0.0 release. Check here if an upgrade in the schema and data # are necessary. if upgrade_objectstore_schema(config.get_object_store(), 'version'): upgrade_objectstore_data('icon', 'images', 'plugins/kimchi/') upgrade_objectstore_data('storagepool', '/storagepools', '/plugins/kimchi') upgrade_objectstore_template_disks(self.model.conn) # Upgrade memory data, if necessary upgrade_objectstore_memory()
def check_if_vm_migration_test_possible(): inst = model.Model(objstore_loc='/tmp/kimchi-store-test') try: inst.vm_migration_pre_check(KIMCHI_LIVE_MIGRATION_TEST, 'root', None) except: return False return True
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_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_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_vm_coldmigrate(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: 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()) 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 setUp(self): self.tmp_store = '/tmp/kimchi-store-test' self.inst = model.Model('qemu:///system', objstore_loc=self.tmp_store) params = { 'name': u'template_test_vm_migrate', 'disks': [], 'source_media': UBUNTU_ISO, 'memory': { 'current': 2048, 'max_memory': 4096 << 10 } } self.inst.templates_create(params) params = { 'name': u'template_test_vm_migrate_nonshared', 'disks': [{ 'name': 'test_vm_migrate.img', 'size': 1 }], 'source_media': UBUNTU_ISO, 'memory': { 'current': 2048, 'maxmemory': 4096 * 1024 } } self.inst.templates_create(params)
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 __init__(self, wok_options): if hasattr(wok_options, "model"): self.model = wok_options.model elif wok_options.test: self.model = mockmodel.MockModel() else: self.model = kimchiModel.Model() dev_env = wok_options.environment != 'production' super(KimchiRoot, self).__init__(self.model, dev_env) for ident, node in sub_nodes.items(): setattr(self, ident, node(self.model)) if isinstance(self.model, kimchiModel.Model): vnc_ws_proxy = vnc.new_ws_proxy() cherrypy.engine.subscribe('exit', vnc_ws_proxy.terminate) self.api_schema = json.load( open( os.path.join(os.path.dirname(os.path.abspath(__file__)), 'API.json'))) self.paths = config.kimchiPaths self.domain = 'kimchi' self.messages = messages make_dirs = [ os.path.dirname(os.path.abspath(config.get_object_store())), os.path.abspath(config.get_distros_store()), os.path.abspath(config.get_debugreports_path()), os.path.abspath(config.get_screenshot_path()) ] for directory in make_dirs: if not os.path.isdir(directory): os.makedirs(directory)
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', 'mem_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_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 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 setUp(self): self.tmp_store = '/tmp/kimchi-store-test' self.inst = model.Model(objstore_loc=self.tmp_store) params = {'name': u'template_test_vm_migrate', 'disks': [], 'cdrom': UBUNTU_ISO, 'memory': 2048, 'max_memory': 4096*1024} self.inst.templates_create(params)
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('os_arch', distro) self.assertIn('path', distro)
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 __init__(self, wok_options): make_dirs = [ os.path.dirname(os.path.abspath(config.get_object_store())), os.path.abspath(config.get_distros_store()), os.path.abspath(config.get_screenshot_path()), os.path.abspath(config.get_virtviewerfiles_path()) ] for directory in make_dirs: if not os.path.isdir(directory): os.makedirs(directory) if hasattr(wok_options, "model"): self.model = wok_options.model elif wok_options.test: self.model = mockmodel.MockModel() else: self.model = kimchiModel.Model() dev_env = wok_options.environment != 'production' super(Kimchi, self).__init__(self.model, dev_env) for ident, node in sub_nodes.items(): setattr(self, ident, node(self.model)) if isinstance(self.model, kimchiModel.Model): ws_proxy = websocket.new_ws_proxy() cherrypy.engine.subscribe('exit', ws_proxy.terminate) self.api_schema = json.load( open( os.path.join(os.path.dirname(os.path.abspath(__file__)), 'API.json'))) self.paths = config.kimchiPaths self.domain = 'kimchi' self.messages = messages self.extends = { "/plugins/gingerbase": { "host-dashboard.html": "/plugins/kimchi/js/kimchi.peers.js" } } # Some paths or URI's present in the objectstore have changed after # Kimchi 2.0.0 release. Check here if an upgrade in the schema and data # are necessary. if upgrade_objectstore_schema(config.get_object_store(), 'version'): upgrade_objectstore_data('icon', 'images', 'plugins/kimchi/') upgrade_objectstore_data('storagepool', '/storagepools', '/plugins/kimchi') upgrade_objectstore_template_disks(self.model.conn) # Upgrade memory data, if necessary upgrade_objectstore_memory()
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_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_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_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_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_edit(self): config.set("authentication", "method", "pam") inst = model.Model(None, objstore_loc=self.tmp_store) # template disk format must be qcow2 because vmsnapshot # only supports this format orig_params = {'name': 'test', 'memory': 1024, 'cpus': 1, 'cdrom': UBUNTU_ISO, 'disks': [{'size': 1, 'format': 'qcow2'}]} inst.templates_create(orig_params) with RollbackContext() as rollback: params_1 = {'name': 'kimchi-vm1', 'template': '/plugins/kimchi/templates/test'} params_2 = {'name': 'kimchi-vm2', 'template': '/plugins/kimchi/templates/test'} task1 = inst.vms_create(params_1) inst.task_wait(task1['id']) rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, 'kimchi-vm1') task2 = inst.vms_create(params_2) inst.task_wait(task2['id']) rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, 'kimchi-vm2') vms = inst.vms_get_list() self.assertTrue('kimchi-vm1' in vms) # make sure "vm_update" works when the domain has a snapshot inst.vmsnapshots_create(u'kimchi-vm1') # update vm graphics when vm is not running inst.vm_update(u'kimchi-vm1', {"graphics": {"passwd": "123456"}}) inst.vm_start('kimchi-vm1') rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff, 'kimchi-vm1') vm_info = inst.vm_lookup(u'kimchi-vm1') self.assertEquals('123456', vm_info['graphics']["passwd"]) self.assertEquals(None, vm_info['graphics']["passwdValidTo"]) # update vm graphics when vm is running inst.vm_update(u'kimchi-vm1', {"graphics": {"passwd": "abcdef", "passwdValidTo": 20}}) vm_info = inst.vm_lookup(u'kimchi-vm1') self.assertEquals('abcdef', vm_info['graphics']["passwd"]) self.assertGreaterEqual(20, vm_info['graphics']['passwdValidTo']) info = inst.vm_lookup('kimchi-vm1') self.assertEquals('running', info['state']) params = {'name': 'new-vm'} self.assertRaises(InvalidParameter, inst.vm_update, 'kimchi-vm1', params) # change VM users and groups, when wm is running. inst.vm_update(u'kimchi-vm1', {'users': ['root'], 'groups': ['root']}) vm_info = inst.vm_lookup(u'kimchi-vm1') self.assertEquals(['root'], vm_info['users']) self.assertEquals(['root'], vm_info['groups']) # change VM users and groups by removing all elements, # when wm is running. inst.vm_update(u'kimchi-vm1', {'users': [], 'groups': []}) vm_info = inst.vm_lookup(u'kimchi-vm1') self.assertEquals([], vm_info['users']) self.assertEquals([], vm_info['groups']) inst.vm_poweroff('kimchi-vm1') self.assertRaises(OperationFailed, inst.vm_update, 'kimchi-vm1', {'name': 'kimchi-vm2'}) params = {'name': u'пeω-∨м', 'cpus': 4, 'memory': 2048} inst.vm_update('kimchi-vm1', params) rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, u'пeω-∨м') self.assertEquals(info['uuid'], inst.vm_lookup(u'пeω-∨м')['uuid']) info = inst.vm_lookup(u'пeω-∨м') for key in params.keys(): self.assertEquals(params[key], info[key]) # change only VM users - groups are not changed (default is empty) users = inst.users_get_list()[:3] inst.vm_update(u'пeω-∨м', {'users': users}) self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users']) self.assertEquals([], inst.vm_lookup(u'пeω-∨м')['groups']) # change only VM groups - users are not changed (default is empty) groups = inst.groups_get_list()[:2] inst.vm_update(u'пeω-∨м', {'groups': groups}) self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users']) self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups']) # change VM users and groups by adding a new element to each one users.append(pwd.getpwuid(os.getuid()).pw_name) groups.append(grp.getgrgid(os.getgid()).gr_name) inst.vm_update(u'пeω-∨м', {'users': users, 'groups': groups}) self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users']) self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups']) # change VM users (wrong value) and groups # when an error occurs, everything fails and nothing is changed self.assertRaises(InvalidParameter, inst.vm_update, u'пeω-∨м', {'users': ['userdoesnotexist'], 'groups': []}) self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users']) self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups']) # change VM users and groups (wrong value) # when an error occurs, everything fails and nothing is changed self.assertRaises(InvalidParameter, inst.vm_update, u'пeω-∨м', {'users': [], 'groups': ['groupdoesnotexist']}) self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users']) self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups']) # change VM users and groups by removing all elements inst.vm_update(u'пeω-∨м', {'users': [], 'groups': []}) self.assertEquals([], inst.vm_lookup(u'пeω-∨м')['users']) self.assertEquals([], inst.vm_lookup(u'пeω-∨м')['groups'])
def test_vm_cdrom(self): inst = model.Model(objstore_loc=self.tmp_store) with RollbackContext() as rollback: vm_name = 'kimchi-cdrom' params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO} inst.templates_create(params) rollback.prependDefer(inst.template_delete, 'test') params = {'name': vm_name, 'template': '/plugins/kimchi/templates/test'} task = inst.vms_create(params) inst.task_wait(task['id']) rollback.prependDefer(inst.vm_delete, vm_name) prev_count = len(inst.vmstorages_get_list(vm_name)) self.assertEquals(1, prev_count) # dummy .iso files iso_path = os.path.join(TMP_DIR, 'existent.iso') iso_path2 = os.path.join(TMP_DIR, 'existent2.iso') open(iso_path, 'w').close() rollback.prependDefer(os.remove, iso_path) open(iso_path2, 'w').close() rollback.prependDefer(os.remove, iso_path2) wrong_iso_path = '/nonexistent.iso' # Create a cdrom cdrom_args = {"type": "cdrom", "path": iso_path} cdrom_dev = inst.vmstorages_create(vm_name, cdrom_args) storage_list = inst.vmstorages_get_list(vm_name) self.assertEquals(prev_count + 1, len(storage_list)) # Get cdrom info cd_info = inst.vmstorage_lookup(vm_name, cdrom_dev) self.assertEquals(u'cdrom', cd_info['type']) self.assertEquals(iso_path, cd_info['path']) # update path of existing cd with # non existent iso self.assertRaises(InvalidParameter, inst.vmstorage_update, vm_name, cdrom_dev, {'path': wrong_iso_path}) # Make sure CD ROM still exists after failure cd_info = inst.vmstorage_lookup(vm_name, cdrom_dev) self.assertEquals(u'cdrom', cd_info['type']) self.assertEquals(iso_path, cd_info['path']) # update path of existing cd with existent iso of shutoff vm inst.vmstorage_update(vm_name, cdrom_dev, {'path': iso_path2}) cdrom_info = inst.vmstorage_lookup(vm_name, cdrom_dev) self.assertEquals(iso_path2, cdrom_info['path']) # update path of existing cd with existent iso of running vm inst.vm_start(vm_name) inst.vmstorage_update(vm_name, cdrom_dev, {'path': iso_path}) cdrom_info = inst.vmstorage_lookup(vm_name, cdrom_dev) self.assertEquals(iso_path, cdrom_info['path']) # eject cdrom cdrom_dev = inst.vmstorage_update(vm_name, cdrom_dev, {'path': ''}) cdrom_info = inst.vmstorage_lookup(vm_name, cdrom_dev) self.assertEquals('', cdrom_info['path']) inst.vm_poweroff(vm_name) # removing non existent cdrom self.assertRaises(NotFoundError, inst.vmstorage_delete, vm_name, "fakedev") # removing valid cdrom inst.vmstorage_delete(vm_name, cdrom_dev) storage_list = inst.vmstorages_get_list(vm_name) self.assertEquals(prev_count, len(storage_list)) # Create a new cdrom using a remote iso valid_remote_iso_path = utils.get_remote_iso_path() cdrom_args = {"type": "cdrom", "path": valid_remote_iso_path} cdrom_dev = inst.vmstorages_create(vm_name, cdrom_args) storage_list = inst.vmstorages_get_list(vm_name) self.assertEquals(prev_count + 1, len(storage_list)) # Update remote-backed cdrom with the same ISO inst.vmstorage_update(vm_name, cdrom_dev, {'path': valid_remote_iso_path}) cdrom_info = inst.vmstorage_lookup(vm_name, cdrom_dev) cur_cdrom_path = re.sub(":80/", '/', cdrom_info['path']) self.assertEquals(valid_remote_iso_path, cur_cdrom_path)
def test_vm_disk(self): disk_path = os.path.join(TMP_DIR, 'existent2.iso') open(disk_path, 'w').close() modern_disk_bus = osinfo.get_template_default('modern', 'disk_bus') def _attach_disk(expect_bus=modern_disk_bus): disk_args = {"type": "disk", "pool": pool, "vol": vol} disk = inst.vmstorages_create(vm_name, disk_args) storage_list = inst.vmstorages_get_list(vm_name) self.assertEquals(prev_count + 1, len(storage_list)) # Check the bus type to be 'virtio' disk_info = inst.vmstorage_lookup(vm_name, disk) self.assertEquals(u'disk', disk_info['type']) self.assertEquals(vol_path, disk_info['path']) self.assertEquals(expect_bus, disk_info['bus']) return disk inst = model.Model(objstore_loc=self.tmp_store) with RollbackContext() as rollback: path = os.path.join(TMP_DIR, 'kimchi-images') pool = 'test-pool' vol = 'test-volume.img' vol_path = "%s/%s" % (path, vol) if not os.path.exists(path): os.mkdir(path) rollback.prependDefer(shutil.rmtree, path) args = {'name': pool, 'path': path, 'type': 'dir'} inst.storagepools_create(args) rollback.prependDefer(inst.storagepool_delete, pool) # Activate the pool before adding any volume inst.storagepool_activate(pool) rollback.prependDefer(inst.storagepool_deactivate, pool) params = {'name': vol, 'capacity': 1073741824, # 1 GiB 'allocation': 536870912, # 512 MiB 'format': 'qcow2'} task_id = inst.storagevolumes_create(pool, params)['id'] rollback.prependDefer(inst.storagevolume_delete, pool, vol) inst.task_wait(task_id) vm_name = 'kimchi-cdrom' params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO} inst.templates_create(params) rollback.prependDefer(inst.template_delete, 'test') params = {'name': vm_name, 'template': '/plugins/kimchi/templates/test'} task1 = inst.vms_create(params) inst.task_wait(task1['id']) rollback.prependDefer(inst.vm_delete, vm_name) prev_count = len(inst.vmstorages_get_list(vm_name)) self.assertEquals(1, prev_count) # Volume format with mismatched type raise error cdrom_args = {"type": "cdrom", "pool": pool, "vol": vol} self.assertRaises(InvalidParameter, inst.vmstorages_create, vm_name, cdrom_args) # Cold plug and unplug a disk disk = _attach_disk() inst.vmstorage_delete(vm_name, disk) # Hot plug a disk inst.vm_start(vm_name) disk = _attach_disk() # VM disk still there after powered off inst.vm_poweroff(vm_name) disk_info = inst.vmstorage_lookup(vm_name, disk) self.assertEquals(u'disk', disk_info['type']) inst.vmstorage_delete(vm_name, disk) # Specifying pool and path at same time will fail disk_args = {"type": "disk", "pool": pool, "vol": vol, "path": disk_path} self.assertRaises( InvalidParameter, inst.vmstorages_create, vm_name, disk_args) old_distro_iso = TMP_DIR + 'rhel4_8.iso' iso_gen.construct_fake_iso(old_distro_iso, True, '4.8', 'rhel') vm_name = 'kimchi-ide-bus-vm' params = {'name': 'old_distro_template', 'disks': [], 'cdrom': old_distro_iso} inst.templates_create(params) rollback.prependDefer(inst.template_delete, 'old_distro_template') params = { 'name': vm_name, 'template': '/plugins/kimchi/templates/old_distro_template' } task2 = inst.vms_create(params) inst.task_wait(task2['id']) rollback.prependDefer(inst.vm_delete, vm_name) # Need to check the right disk_bus for old distro disk = _attach_disk(osinfo.get_template_default('old', 'disk_bus')) inst.vmstorage_delete('kimchi-ide-bus-vm', disk) # Hot plug IDE bus disk does not work inst.vm_start(vm_name) self.assertRaises(InvalidOperation, _attach_disk) inst.vm_poweroff(vm_name)
def test_vm_ifaces(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') # 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) inst.network_activate(net_name) rollback.prependDefer(inst.network_deactivate, net_name) for vm_name in ['kimchi-ifaces', 'kimchi-ifaces-running']: params = {'name': vm_name, 'template': '/plugins/kimchi/templates/test'} task = inst.vms_create(params) inst.task_wait(task['id']) rollback.prependDefer(inst.vm_delete, vm_name) ifaces = inst.vmifaces_get_list(vm_name) self.assertEquals(1, len(ifaces)) iface = inst.vmiface_lookup(vm_name, 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(vm_name, iface_args) # detach network interface from vm rollback.prependDefer(inst.vmiface_delete, vm_name, mac) self.assertEquals(17, len(mac)) iface = inst.vmiface_lookup(vm_name, mac) self.assertEquals("network", iface["type"]) self.assertEquals("test-network", iface['network']) self.assertEquals("virtio", iface["model"]) # attach network interface to vm without providing model iface_args = {"type": "network", "network": "test-network"} mac = inst.vmifaces_create(vm_name, iface_args) rollback.prependDefer(inst.vmiface_delete, vm_name, mac) iface = inst.vmiface_lookup(vm_name, mac) self.assertEquals("network", iface["type"]) self.assertEquals("test-network", iface['network']) # update vm interface newMacAddr = '54:50:e3:44:8a:af' iface_args = {"mac": newMacAddr} inst.vmiface_update(vm_name, mac, iface_args) iface = inst.vmiface_lookup(vm_name, newMacAddr) self.assertEquals(newMacAddr, iface['mac']) # undo mac address change iface_args = {"mac": mac} inst.vmiface_update(vm_name, newMacAddr, iface_args) iface = inst.vmiface_lookup(vm_name, mac) self.assertEquals(mac, iface['mac'])
def test_events_vm_lifecycle(self): inst = model.Model(objstore_loc=self.tmp_store) self.objstore = inst.objstore conn = inst.conn.get() # Create a template and VM to test, and start lifecycle tests with RollbackContext() as rollback: # Register the most common Libvirt domain events to be handled. event_map = [(libvirt.VIR_DOMAIN_EVENT_ID_LIFECYCLE, self.domain_event_lifecycle_cb), (libvirt.VIR_DOMAIN_EVENT_ID_REBOOT, self.domain_event_reboot_cb)] for event, event_cb in event_map: ev_id = conn.domainEventRegisterAny(None, event, event_cb, None) rollback.prependDefer(conn.domainEventDeregisterAny, ev_id) # Create a template template_params = { 'name': 'ttest', 'source_media': { 'type': 'disk', 'path': UBUNTU_ISO } } inst.templates_create(template_params) rollback.prependDefer(inst.template_delete, 'ttest') # Create a VM (guest) vm_params = { 'name': 'kimchi-vm1', 'template': '/plugins/kimchi/templates/ttest' } task = inst.vms_create(vm_params) inst.task_wait(task['id'], 10) task = inst.task_lookup(task['id']) self.assertEquals('finished', task['status']) time.sleep(5) # Check event of domain definition (addition) res = json.loads(_get_event(str(_get_event_id()))) self.assertEquals('kimchi-vm1', res['domain']) self.assertEquals('Defined', res['event']) self.assertEquals('Added', res['event_detail']) # Start the VM and check the event inst.vm_start('kimchi-vm1') time.sleep(5) res = json.loads(_get_event(str(_get_event_id()))) self.assertEquals('kimchi-vm1', res['domain']) self.assertEquals('Started', res['event']) self.assertEquals('Booted', res['event_detail']) # Suspend the VM and check the event inst.vm_suspend('kimchi-vm1') time.sleep(5) res = json.loads(_get_event(str(_get_event_id()))) self.assertEquals('kimchi-vm1', res['domain']) self.assertEquals('Suspended', res['event']) self.assertEquals('Paused', res['event_detail']) # Resume the VM and check the event inst.vm_resume('kimchi-vm1') time.sleep(5) res = json.loads(_get_event(str(_get_event_id()))) self.assertEquals('kimchi-vm1', res['domain']) self.assertEquals('Resumed', res['event']) self.assertEquals('Unpaused', res['event_detail']) # Reboot the VM and check the event inst.vm_reset('kimchi-vm1') time.sleep(5) res = json.loads(_get_event(str(_get_event_id()))) self.assertEquals('kimchi-vm1', res['domain']) self.assertEquals('Rebooted', res['event']) # PowerOff (hard stop) the VM and check the event inst.vm_poweroff('kimchi-vm1') time.sleep(5) res = json.loads(_get_event(str(_get_event_id()))) self.assertEquals('kimchi-vm1', res['domain']) self.assertEquals('Stopped', res['event']) self.assertEquals('Destroyed', res['event_detail']) # Delete the VM and check the event inst.vm_delete('kimchi-vm1') time.sleep(5) res = json.loads(_get_event(str(_get_event_id()))) self.assertEquals('kimchi-vm1', res['domain']) self.assertEquals('Undefined', res['event']) self.assertEquals('Removed', res['event_detail'])
def _is_yum_distro(): inst = model.Model('test:///default') repo_type = inst.capabilities_lookup()['repo_mngt_tool'] return repo_type == 'yum'
def test_vm_lifecycle(self): inst = model.Model(objstore_loc=self.tmp_store) with RollbackContext() as rollback: vol_params = {'name': u'test-vol', 'capacity': 1024} task = inst.storagevolumes_create(u'default', vol_params) rollback.prependDefer(inst.storagevolume_delete, u'default', vol_params['name']) inst.task_wait(task['id']) task = inst.task_lookup(task['id']) self.assertEquals('finished', task['status']) vol = inst.storagevolume_lookup(u'default', vol_params['name']) params = {'name': 'test', 'disks': [{'base': vol['path'], 'size': 1}], '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) rollback.prependDefer(inst.vm_delete, 'kimchi-vm') inst.task_wait(task['id'], 10) task = inst.task_lookup(task['id']) self.assertEquals('finished', task['status']) vms = inst.vms_get_list() self.assertTrue('kimchi-vm' in vms) inst.vm_start('kimchi-vm') info = inst.vm_lookup('kimchi-vm') self.assertEquals('running', info['state']) self.assertRaises(InvalidOperation, inst.vmsnapshots_create, u'kimchi-vm') inst.vm_poweroff(u'kimchi-vm') vm = inst.vm_lookup(u'kimchi-vm') empty_snap = inst.currentvmsnapshot_lookup(u'kimchi-vm') self.assertEquals({}, empty_snap) # this snapshot should be deleted when its VM is deleted params = {'name': u'mysnap'} task = inst.vmsnapshots_create(u'kimchi-vm', params) inst.task_wait(task['id']) task = inst.task_lookup(task['id']) self.assertEquals('finished', task['status']) self.assertRaises(NotFoundError, inst.vmsnapshot_lookup, u'kimchi-vm', u'foobar') snap = inst.vmsnapshot_lookup(u'kimchi-vm', params['name']) self.assertTrue(int(time.time()) >= int(snap['created'])) self.assertEquals(vm['state'], snap['state']) self.assertEquals(params['name'], snap['name']) self.assertEquals(u'', snap['parent']) snaps = inst.vmsnapshots_get_list(u'kimchi-vm') self.assertEquals([params['name']], snaps) current_snap = inst.currentvmsnapshot_lookup(u'kimchi-vm') self.assertEquals(snap, current_snap) task = inst.vmsnapshots_create(u'kimchi-vm') snap_name = task['target_uri'].split('/')[-1] rollback.prependDefer(inst.vmsnapshot_delete, u'kimchi-vm', snap_name) inst.task_wait(task['id']) task = inst.task_lookup(task['id']) self.assertEquals('finished', task['status']) snaps = inst.vmsnapshots_get_list(u'kimchi-vm') self.assertEquals(sorted([params['name'], snap_name], key=unicode.lower), snaps) snap = inst.vmsnapshot_lookup(u'kimchi-vm', snap_name) current_snap = inst.currentvmsnapshot_lookup(u'kimchi-vm') self.assertEquals(snap, current_snap) # update vm name inst.vm_update('kimchi-vm', {'name': u'kimchi-vm-new'}) # Look up the first created snapshot from the renamed vm snap = inst.vmsnapshot_lookup(u'kimchi-vm-new', params['name']) # snapshot revert to the first created vm result = inst.vmsnapshot_revert(u'kimchi-vm-new', params['name']) self.assertEquals(result, [u'kimchi-vm', snap['name']]) vm = inst.vm_lookup(u'kimchi-vm') self.assertEquals(vm['state'], snap['state']) current_snap = inst.currentvmsnapshot_lookup(u'kimchi-vm') self.assertEquals(params['name'], current_snap['name']) self.assertRaises(NotFoundError, inst.vmsnapshot_delete, u'kimchi-vm', u'foobar') # suspend and resume the VM info = inst.vm_lookup(u'kimchi-vm') self.assertEquals(info['state'], 'shutoff') self.assertRaises(InvalidOperation, inst.vm_suspend, u'kimchi-vm') inst.vm_start(u'kimchi-vm') info = inst.vm_lookup(u'kimchi-vm') self.assertEquals(info['state'], 'running') inst.vm_suspend(u'kimchi-vm') info = inst.vm_lookup(u'kimchi-vm') self.assertEquals(info['state'], 'paused') self.assertRaises(InvalidParameter, inst.vm_update, u'kimchi-vm', {'name': 'foo'}) inst.vm_resume(u'kimchi-vm') info = inst.vm_lookup(u'kimchi-vm') self.assertEquals(info['state'], 'running') self.assertRaises(InvalidOperation, inst.vm_resume, u'kimchi-vm') # leave the VM suspended to make sure a paused VM can be # deleted correctly inst.vm_suspend(u'kimchi-vm') vms = inst.vms_get_list() self.assertFalse('kimchi-vm' in vms)