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)