def _attach_pci_device(self, vmid, dev_info): self._validate_pci_passthrough_env() dom = VMModel.get_vm(vmid, self.conn) # Due to libvirt limitation, we don't support live assigne device to # vfio driver. driver = ('vfio' if DOM_STATE_MAP[dom.info()[0]] == "shutoff" and self.caps.kernel_vfio else 'kvm') # on powerkvm systems it must be vfio driver. distro, _, _ = platform.linux_distribution() if distro == 'IBM_PowerKVM': driver = 'vfio' # Attach all PCI devices in the same IOMMU group dev_model = DeviceModel(conn=self.conn) devs_model = DevicesModel(conn=self.conn) affected_names = devs_model.get_list( _passthrough_affected_by=dev_info['name']) passthrough_names = devs_model.get_list(_cap='pci', _passthrough='true') group_names = list(set(affected_names) & set(passthrough_names)) pci_infos = [dev_model.lookup(dev_name) for dev_name in group_names] pci_infos.append(dev_info) # all devices in the group that is going to be attached to the vm # must be detached from the host first with RollbackContext() as rollback: for pci_info in pci_infos: try: dev = self.conn.get().nodeDeviceLookupByName( pci_info['name']) dev.dettach() except Exception: raise OperationFailed('KCHVMHDEV0005E', {'name': pci_info['name']}) else: rollback.prependDefer(dev.reAttach) rollback.commitAll() device_flags = get_vm_config_flag(dom, mode='all') with RollbackContext() as rollback: for pci_info in pci_infos: pci_info['detach_driver'] = driver xmlstr = self._get_pci_device_xml(pci_info) try: dom.attachDeviceFlags(xmlstr, device_flags) except libvirt.libvirtError: kimchi_log.error( 'Failed to attach host device %s to VM %s: \n%s', pci_info['name'], vmid, xmlstr) raise rollback.prependDefer(dom.detachDeviceFlags, xmlstr, device_flags) rollback.commitAll() return dev_info['name']
def test_get_networks(self): networks = json.loads(self.request('/networks').read()) self.assertIn('default', [net['name'] for net in networks]) with RollbackContext() as rollback: # Now add a couple of Networks to the mock model for i in xrange(5): name = 'network-%i' % i req = json.dumps({'name': name, 'connection': 'nat', 'subnet': '127.0.10%i.0/24' % i}) resp = self.request('/networks', req, 'POST') rollback.prependDefer(model.network_delete, name) self.assertEquals(201, resp.status) network = json.loads(resp.read()) self.assertEquals([], network["vms"]) nets = json.loads(self.request('/networks').read()) self.assertEquals(len(networks) + 5, len(nets)) network = json.loads(self.request('/networks/network-1').read()) keys = [u'name', u'connection', u'interface', u'subnet', u'dhcp', u'vms', u'in_use', u'autostart', u'state', u'persistent'] self.assertEquals(sorted(keys), sorted(network.keys()))
def test_empty_repo_file(self): with RollbackContext() as rollback: repos = get_yum_repositories() tmp_file_name = _create_empty_repo_file() rollback.prependDefer(os.remove, tmp_file_name) repos_after = get_yum_repositories() self.assertEqual(len(repos_after), len(repos))
def probe_user(cls): with cls.lock: if cls.user: return cls.user arch = 'ppc64' if platform.machine() == 'ppc64le' \ else platform.machine() xml = cls.SIMPLE_VM_XML % {'name': KVMUSERTEST_VM_NAME, 'arch': arch} with RollbackContext() as rollback: with cls.lock: conn = libvirt.open(None) rollback.prependDefer(conn.close) f = libvirt.VIR_DOMAIN_START_AUTODESTROY dom = conn.createXML(xml, flags=f) rollback.prependDefer(dom.destroy) filename = '/var/run/libvirt/qemu/%s.pid' % KVMUSERTEST_VM_NAME with open(filename) as f: pidStr = f.read() p = psutil.Process(int(pidStr)) # bug fix #357 # in psutil 2.0 and above versions, username will be a method, # not a string if callable(p.username): cls.user = p.username() else: cls.user = p.username return cls.user
def has_metadata_support(conn): KIMCHI_META_URL = "https://github.com/kimchi-project/kimchi/" KIMCHI_NAMESPACE = "kimchi" with RollbackContext() as rollback: FeatureTests.disable_libvirt_error_logging() rollback.prependDefer(FeatureTests.enable_libvirt_error_logging) conn_type = conn.getType().lower() domain_type = 'test' if conn_type == 'test' else 'kvm' arch = 'i686' if conn_type == 'test' else platform.machine() arch = 'ppc64' if arch == 'ppc64le' else arch dom = conn.defineXML(SIMPLE_VM_XML % { 'name': FEATURETEST_VM_NAME, 'domain': domain_type, 'arch': arch }) rollback.prependDefer(dom.undefine) try: dom.setMetadata(libvirt.VIR_DOMAIN_METADATA_ELEMENT, "<metatest/>", KIMCHI_NAMESPACE, KIMCHI_META_URL, flags=libvirt.VIR_DOMAIN_AFFECT_CURRENT) return True except libvirt.libvirtError: return False
def has_mem_hotplug_support(conn): ''' A memory device can be hot-plugged or hot-unplugged since libvirt version 1.2.14. ''' # Libvirt < 1.2.14 does not support memory devices, so firstly, check # its version, then try to attach a device. These steps avoid errors # with Libvirt 'test' driver for KVM version = 1000000 * 1 + 1000 * 2 + 14 if libvirt.getVersion() < version: return False with RollbackContext() as rollback: FeatureTests.disable_libvirt_error_logging() rollback.prependDefer(FeatureTests.enable_libvirt_error_logging) conn_type = conn.getType().lower() domain_type = 'test' if conn_type == 'test' else 'kvm' arch = 'i686' if conn_type == 'test' else platform.machine() arch = 'ppc64' if arch == 'ppc64le' else arch dom = conn.defineXML(MAXMEM_VM_XML % { 'name': FEATURETEST_VM_NAME, 'domain': domain_type, 'arch': arch }) rollback.prependDefer(dom.undefine) try: dom.attachDeviceFlags(DEV_MEM_XML, libvirt.VIR_DOMAIN_MEM_CONFIG) return True except libvirt.libvirtError: return False
def test_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_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 prepare(self, conn): mnt_point = tempfile.mkdtemp(dir='/tmp') export_path = "%s:%s" % (self.poolArgs['source']['host'], self.poolArgs['source']['path']) mount_cmd = [ "mount", "-o", 'soft,timeo=100,retrans=3,retry=0', export_path, mnt_point ] umount_cmd = ["umount", "-f", export_path] mounted = False # 2 seconds looks like a reasonable time to wait for a refresh # in the UI and enough time to verify that the NFS server # is down. cmd_timeout = 2 with RollbackContext() as rollback: rollback.prependDefer(os.rmdir, mnt_point) try: run_command(mount_cmd, cmd_timeout) rollback.prependDefer(run_command, umount_cmd, cmd_timeout) except TimeoutExpired: raise InvalidParameter("KCHPOOL0012E", {'path': export_path}) with open("/proc/mounts", "rb") as f: rawMounts = f.read() output_items = ['dev_path', 'mnt_point', 'type'] mounts = parse_cmd_output(rawMounts, output_items) for item in mounts: if 'dev_path' in item and item['dev_path'] == export_path: mounted = True if not mounted: raise InvalidParameter("KCHPOOL0013E", {'path': export_path})
def test_create_user(self): users_model = UsersModel() user_model = UserModel() user = '******' passwd = 'fakepass' group = 'unit_test_fake_group' profile = 'unit_test_fake_profile' common_users = users_model.get_list() params = { 'name': user, 'password': passwd, 'group': group, 'profile': profile } with RollbackContext() as rollback: users_model.create(params) rollback.prependDefer(user_model.delete, user) new_users = users_model.get_list() self.assertEqual(len(new_users), len(common_users) + 1) enc_passwd = spwd.getspnam(user)[1] invalid_passwd = [None, "NP", "!", "!!", "", "LK", "*"] self.assertNotIn(enc_passwd, invalid_passwd) self.assertEqual(crypt.crypt(passwd, enc_passwd), enc_passwd)
def 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_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 probe_user(cls): if cls.user: return cls.user vm_uuid = uuid.uuid1() vm_name = "kimchi_test_%s" % vm_uuid arch = 'ppc64' if platform.machine() == 'ppc64le' \ else platform.machine() xml = cls.SIMPLE_VM_XML % { 'vm_name': vm_name, 'vm_uuid': vm_uuid, 'arch': arch } with RollbackContext() as rollback: conn = libvirt.open(None) rollback.prependDefer(conn.close) dom = conn.defineXML(xml) rollback.prependDefer(dom.undefine) dom.create() rollback.prependDefer(dom.destroy) with open('/var/run/libvirt/qemu/%s.pid' % vm_name) as f: pidStr = f.read() p = psutil.Process(int(pidStr)) # bug fix #357 # in psutil 2.0 and above versions, username will be a method, # not a string if callable(p.username): cls.user = p.username() else: cls.user = p.username return cls.user
def prepare(self, conn): mnt_point = tempfile.mkdtemp(dir='/tmp') export_path = "%s:%s" % (self.poolArgs['source']['host'], self.poolArgs['source']['path']) mount_cmd = [ "mount", "-o", 'soft,timeo=100,retrans=3,retry=0', export_path, mnt_point ] umount_cmd = ["umount", "-f", export_path] mounted = False # Due to an NFS bug (See Red Hat BZ 1023059), NFSv4 exports may take # 10-15 seconds to mount the first time. cmd_timeout = 15 with RollbackContext() as rollback: rollback.prependDefer(os.rmdir, mnt_point) try: run_command(mount_cmd, cmd_timeout) rollback.prependDefer(run_command, umount_cmd, cmd_timeout) except TimeoutExpired: raise InvalidParameter("KCHPOOL0012E", {'path': export_path}) with open("/proc/mounts", "rb") as f: rawMounts = f.read() output_items = ['dev_path', 'mnt_point', 'type'] mounts = parse_cmd_output(rawMounts, output_items) for item in mounts: if 'dev_path' in item and item['dev_path'] == export_path: mounted = True if not mounted: raise InvalidParameter("KCHPOOL0013E", {'path': export_path})
def test_create_existing_user_fails(self): user = '******' passwd = 'fakepass' with RollbackContext() as rollback: users.create_user(user, passwd) rollback.prependDefer(users.delete_user, user) with self.assertRaises(OperationFailed): users.create_user(user, passwd)
def test_create_group(self): groupname = 'unit_test_fake_group' groups = users.get_groups() with RollbackContext() as rollback: users.create_group(groupname) rollback.prependDefer(users.delete_group, groupname) new_groups = users.get_groups() self.assertEqual(len(new_groups), len(groups) + 1)
def test_raise_undo(self): try: with RollbackContext() as rollback: rollback.prependDefer(self._inc_counter) rollback.prependDefer(self._raise) rollback.prependDefer(self._inc_counter) except FirstError: # All undo should be run self.assertEquals(self._counter, 2) else: self.fail('Should have raised FirstError')
def test_raise_prefer_first_undo(self): try: with RollbackContext() as rollback: rollback.prependDefer(self._raise, SecondError) rollback.prependDefer(self._raise, FirstError) except FirstError: pass except SecondError: self.fail('Should have preferred FirstError to SecondError') else: self.fail('Should have raised FirstError')
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_storagepools(self): storagepools = json.loads(self.request('/storagepools').read()) self.assertIn('default', [pool['name'] for pool in storagepools]) with RollbackContext() as rollback: # Now add a couple of StoragePools to the mock model for i in xrange(3): name = u'kīмсhī-storagepool-%i' % i req = json.dumps({ 'name': name, 'type': 'dir', 'path': '/var/lib/libvirt/images/%i' % i }) resp = self.request('/storagepools', req, 'POST') rollback.prependDefer(model.storagepool_delete, name) self.assertEquals(201, resp.status) # Pool name must be unique req = json.dumps({ 'name': name, 'type': 'dir', 'path': '/var/lib/libvirt/images/%i' % i }) resp = self.request('/storagepools', req, 'POST') self.assertEquals(400, resp.status) # Verify pool information resp = self.request('/storagepools/%s' % name.encode("utf-8")) p = json.loads(resp.read()) keys = [ u'name', u'state', u'capacity', u'allocated', u'available', u'path', u'source', u'type', u'nr_volumes', u'autostart', u'persistent' ] self.assertEquals(sorted(keys), sorted(p.keys())) self.assertEquals(name, p['name']) self.assertEquals('inactive', p['state']) self.assertEquals(True, p['persistent']) self.assertEquals(True, p['autostart']) self.assertEquals(0, p['nr_volumes']) pools = json.loads(self.request('/storagepools').read()) self.assertEquals(len(storagepools) + 3, len(pools)) # Reserved pool return 400 req = json.dumps({ 'name': 'kimchi_isos', 'type': 'dir', 'path': '/var/lib/libvirt/images/%i' % i }) resp = request(host, ssl_port, '/storagepools', req, 'POST') self.assertEquals(400, resp.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_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_create_debugreport(self): req = json.dumps({'name': 'report1'}) with RollbackContext() as rollback: resp = request(host, ssl_port, '/debugreports', req, 'POST') self.assertEquals(202, resp.status) task = json.loads(resp.read()) # make sure the debugreport doesn't exist until the # the task is finished wait_task(self._task_lookup, task['id']) rollback.prependDefer(self._report_delete, 'report2') resp = request(host, ssl_port, '/debugreports/report1') debugreport = json.loads(resp.read()) self.assertEquals("report1", debugreport['name']) self.assertEquals(200, resp.status) req = json.dumps({'name': 'report2'}) resp = request(host, ssl_port, '/debugreports/report1', req, 'PUT') self.assertEquals(303, resp.status)
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_create_user(self): user = '******' passwd = 'fakepass' common_users = users.get_users() with RollbackContext() as rollback: users.create_user(user, passwd) rollback.prependDefer(users.delete_user, user) new_users = users.get_users() self.assertEqual(len(new_users), len(common_users) + 1) enc_passwd = spwd.getspnam(user)[1] invalid_passwd = [None, "NP", "!", "!!", "", "LK", "*"] self.assertNotIn(enc_passwd, invalid_passwd) self.assertEqual(crypt.crypt(passwd, enc_passwd), enc_passwd)
def test_add_user_to_primary_group(self): user = '******' passwd = 'fakepass' group = 'unit_test_fake_group' with RollbackContext() as rollback: users.create_group(group) rollback.prependDefer(users.delete_group, group) users.create_user(user, passwd) rollback.prependDefer(users.delete_user, user) users.add_user_to_primary_group(user, group) users_group = users.get_users_from_group(group) self.assertEqual(len(users_group), 1) self.assertIn(user, users_group)
def has_metadata_support(): KIMCHI_META_URL = "https://github.com/kimchi-project/kimchi/" KIMCHI_NAMESPACE = "kimchi" with RollbackContext() as rollback: FeatureTests.disable_screen_error_logging() rollback.prependDefer(FeatureTests.enable_screen_error_logging) conn = libvirt.open('qemu:///system') rollback.prependDefer(conn.close) dom = conn.defineXML(SIMPLE_VM_XML) rollback.prependDefer(dom.undefine) try: dom.setMetadata(libvirt.VIR_DOMAIN_METADATA_ELEMENT, "<metatest/>", KIMCHI_NAMESPACE, KIMCHI_META_URL, flags=libvirt.VIR_DOMAIN_AFFECT_CURRENT) return True except libvirt.libvirtError: return False
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)