def delete(self, vmid, dev_name):
dom = VMModel.get_vm(vmid, self.conn)
xmlstr = dom.XMLDesc(0)
root = objectify.fromstring(xmlstr)
try:
hostdev = root.devices.hostdev
except AttributeError:
raise NotFoundError('KCHVMHDEV0001E', {
'vmid': vmid,
'dev_name': dev_name
})
devsmodel = VMHostDevsModel(conn=self.conn)
pci_devs = [(devsmodel._deduce_dev_name(e), e) for e in hostdev
if e.attrib['type'] == 'pci']
for e in hostdev:
if devsmodel._deduce_dev_name(e) == dev_name:
xmlstr = etree.tostring(e)
dom.detachDeviceFlags(xmlstr,
get_vm_config_flag(dom, mode='all'))
if e.attrib['type'] == 'pci':
self._delete_affected_pci_devices(dom, dev_name, pci_devs)
break
else:
raise NotFoundError('KCHVMHDEV0001E', {
'vmid': vmid,
'dev_name': dev_name
})
def lookup(self, vmid, dev_name):
dom = VMModel.get_vm(vmid, self.conn)
xmlstr = dom.XMLDesc(0)
root = objectify.fromstring(xmlstr)
try:
hostdev = root.devices.hostdev
except AttributeError:
raise NotFoundError('KCHVMHDEV0001E', {
'vmid': vmid,
'dev_name': dev_name
})
dev_model = DeviceModel(conn=self.conn)
for e in hostdev:
deduced_name = DeviceModel.deduce_dev_name(e, self.conn)
if deduced_name == dev_name:
dev_info = dev_model.lookup(dev_name)
return {
'name': dev_name,
'type': e.attrib['type'],
'product': dev_info.get('product', None),
'vendor': dev_info.get('vendor', None)
}
raise NotFoundError('KCHVMHDEV0001E', {
'vmid': vmid,
'dev_name': dev_name
})
def disableRepository(self, repo_id):
if not repo_id in self._repos.keys():
raise NotFoundError("KCHREPOS0012E", {'repo_id': repo_id})
info = self._repos[repo_id]
# Check if repo_id is already disabled
if not info['enabled']:
raise NotFoundError("KCHREPOS0016E", {'repo_id': repo_id})
info['enabled'] = False
self._repos[repo_id] = info
return repo_id
def toggleRepo(self, repo_id, enable):
repos = self._get_repos('KCHREPOS0011E')
if repo_id not in repos.keys():
raise NotFoundError("KCHREPOS0012E", {'repo_id': repo_id})
entry = repos.get(repo_id)
if enable and entry.enabled:
raise InvalidOperation("KCHREPOS0015E", {'repo_id': repo_id})
if not enable and not entry.enabled:
raise InvalidOperation("KCHREPOS0016E", {'repo_id': repo_id})
kimchiLock.acquire()
try:
if enable:
entry.enable()
else:
entry.disable()
write_repo_to_file(entry)
except:
if enable:
raise OperationFailed("KCHREPOS0020E", {'repo_id': repo_id})
raise OperationFailed("KCHREPOS0021E", {'repo_id': repo_id})
finally:
kimchiLock.release()
return repo_id
def lookup(self, nodedev_name):
conn = self.conn.get()
try:
dev = conn.nodeDeviceLookupByName(nodedev_name)
except:
raise NotFoundError('KCHHOST0003E', {'name': nodedev_name})
return hostdev.get_dev_info(dev)
def get_vm_disk(dom, dev_name):
# Retrieve disk xml and format return dict
disk = get_device_xml(dom, dev_name)
if disk is None:
raise NotFoundError("KCHVMSTOR0007E", {
'dev_name': dev_name,
'vm_name': dom.name()
})
path = ""
dev_bus = 'ide'
try:
source = disk.source
if source is not None:
src_type = disk.attrib['type']
if src_type == 'network':
host = source.host
path = (source.attrib['protocol'] + '://' +
host.attrib['name'] + ':' + host.attrib['port'] +
source.attrib['name'])
else:
path = source.attrib[DEV_TYPE_SRC_ATTR_MAP[src_type]]
# Retrieve storage bus type
dev_bus = disk.target.attrib['bus']
except:
pass
dev_type = disk.attrib['device']
return {
'dev': dev_name,
'type': dev_type,
'path': path,
'format': disk.driver.attrib['type'],
'bus': dev_bus
}
def getRepo(self, repo_id):
"""
Return a dictionary in the repositories.Repositories() of the given
repository ID format with the information of a YumRepository object.
"""
kimchiLock.acquire()
repos = self._get_repos('KCHREPOS0025E')
kimchiLock.release()
if repo_id not in repos.repos.keys():
raise NotFoundError("KCHREPOS0012E", {'repo_id': repo_id})
entry = repos.getRepo(repo_id)
info = {}
info['enabled'] = entry.enabled
baseurl = ''
if entry.baseurl:
baseurl = entry.baseurl[0]
info['baseurl'] = baseurl
info['config'] = {}
info['config']['repo_name'] = entry.name
info['config']['gpgcheck'] = entry.gpgcheck
info['config']['gpgkey'] = entry.gpgkey
info['config']['mirrorlist'] = entry.mirrorlist or ''
info['config']['metalink'] = entry.metalink or ''
return info
def vmiface_lookup(self, vm, mac):
dom = self._get_vm(vm)
try:
info = dom.ifaces[mac].info
except KeyError:
raise NotFoundError("KCHVMIF0001E", {'iface': mac, 'name': vm})
return info
def lookup(self, subscription):
"""
Returns a dictionary with all SEP information.
"""
cmd = ['/opt/ibm/seprovider/bin/getSubscriber']
output, error, rc = run_command(cmd)
# error: report
if rc != 0:
kimchi_log.error('SEP execution error: %s - %s - %s' % (cmd, rc,
error))
raise OperationFailed('GINSEP0005E', {'error': error})
if len(output) > 1:
# iterate over lines and parse to dict
for line in output.splitlines():
if len(line) > 0:
entry = SUBSCRIBER.search(line).groupdict()
# subscriber found
if entry["hostname"] == subscription:
return entry
raise NotFoundError("GINSEP0006E", {'hostname': subscription})
def updateRepo(self, repo_id, params):
"""
Update a given repository in repositories.Repositories() format
"""
kimchiLock.acquire()
repos = self._get_repos('KCHREPOS0011E')
kimchiLock.release()
if repo_id not in repos.repos.keys():
raise NotFoundError("KCHREPOS0012E", {'repo_id': repo_id})
config = params.get('config', {})
entry = repos.getRepo(repo_id)
baseurl = params.get('baseurl', None)
mirrorlist = config.get('mirrorlist', None)
if baseurl is not None:
validate_repo_url(baseurl)
entry.baseurl = baseurl
if mirrorlist == '':
mirrorlist = None
if mirrorlist is not None:
validate_repo_url(mirrorlist)
entry.mirrorlist = mirrorlist
entry.id = params.get('repo_id', repo_id)
entry.name = config.get('repo_name', entry.name)
entry.gpgcheck = config.get('gpgcheck', entry.gpgcheck)
entry.gpgkey = config.get('gpgkey', entry.gpgkey)
kimchiLock.acquire()
self._conf.writeRawRepoFile(entry)
kimchiLock.release()
return repo_id
def update(self, vm, mac, params):
dom = VMModel.get_vm(vm, self.conn)
iface = self._get_vmiface(vm, mac)
if iface is None:
raise NotFoundError("KCHVMIF0001E", {'name': vm, 'iface': mac})
flags = 0
if dom.isPersistent():
flags |= libvirt.VIR_DOMAIN_AFFECT_CONFIG
if DOM_STATE_MAP[dom.info()[0]] != "shutoff":
flags |= libvirt.VIR_DOMAIN_AFFECT_LIVE
if iface.attrib['type'] == 'network' and 'network' in params:
iface.source.attrib['network'] = params['network']
xml = etree.tostring(iface)
dom.updateDeviceFlags(xml, flags=flags)
if 'model' in params:
iface.model.attrib["type"] = params['model']
xml = etree.tostring(iface)
dom.updateDeviceFlags(xml, flags=flags)
return mac
def updateRepo(self, repo_id, params):
"""
Update a given repository in repositories.Repositories() format
"""
r = self._get_source_entry(repo_id)
if r is None:
raise NotFoundError("KCHREPOS0012E", {'repo_id': repo_id})
info = {
'enabled': not r.disabled,
'baseurl': params.get('baseurl', r.uri),
'config': {
'type': 'deb',
'dist': r.dist,
'comps': r.comps
}
}
if 'config' in params.keys():
config = params['config']
info['config']['dist'] = config.get('dist', r.dist)
info['config']['comps'] = config.get('comps', r.comps)
self.removeRepo(repo_id)
return self.addRepo(info)
def vmstorage_delete(self, vm_name, dev_name):
dom = self._get_vm(vm_name)
if dev_name not in self.vmstorages_get_list(vm_name):
raise NotFoundError("KCHVMSTOR0007E", {
'dev_name': dev_name,
'vm_name': vm_name
})
dom.storagedevices.pop(dev_name)
def lookup(self, name):
try:
info = netinfo.get_interface_info(name)
except ValueError:
raise NotFoundError("KCHIFACE0001E", {'name': name})
info['editable'] = self._is_interface_editable(name)
return info
def vmscreenshot_lookup(self, name):
vm = self._get_vm(name)
if vm.info['state'] != 'running':
raise NotFoundError("KCHVM0004E", {'name': name})
screenshot = self._mock_screenshots.setdefault(
vm.uuid, MockVMScreenshot({'uuid': vm.uuid}))
return screenshot.lookup()
def lookup(self, name):
if not os.path.isdir(FC_HOST_SYS_PATH % name):
raise NotFoundError('GINADAP0001E', {'adapter': name})
info = {}
for key in FC_HOST_INFOS:
info[key] = self._read_info(FC_HOST_SYS_PATH % name +
FC_HOST_INFOS[key])
return info
def vmstorage_lookup(self, vm_name, dev_name):
dom = self._get_vm(vm_name)
if dev_name not in self.vmstorages_get_list(vm_name):
raise NotFoundError("KCHVMSTOR0007E", {
'dev_name': dev_name,
'vm_name': vm_name
})
return dom.storagedevices.get(dev_name).info
def getUpdate(self, name):
"""
Return a dictionary with all info from a given package name.
"""
if name not in self._packages.keys():
raise NotFoundError('KCHPKGUPD0002E', {'name': name})
return self._packages[name]
def delete(self, obj_type, ident, ignore_missing=False):
c = self.conn.cursor()
c.execute('DELETE FROM objects WHERE type=? AND id=?',
(obj_type, ident))
if c.rowcount != 1 and not ignore_missing:
self.conn.rollback()
raise NotFoundError("KCHOBJST0001E", {'item': ident})
self.conn.commit()
def getRepository(self, repo_id):
if not repo_id in self._repo_storage.keys():
raise NotFoundError("KCHREPOS0010E", {'repo_id': repo_id})
repo = self._repo_storage[repo_id]
if (isinstance(repo['baseurl'], list)) and (len(repo['baseurl']) > 0):
repo['baseurl'] = repo['baseurl'][0]
return repo
def updateRepository(self, repo_id, params):
if not repo_id in self._repos.keys():
raise NotFoundError("KCHREPOS0012E", {'repo_id': repo_id})
info = self._repos[repo_id]
info.update(params)
del self._repos[repo_id]
self._repos[info['repo_id']] = info
return info['repo_id']
def get_storagepool(name, conn):
conn = conn.get()
try:
return conn.storagePoolLookupByName(name.encode("utf-8"))
except libvirt.libvirtError as e:
if e.get_error_code() == libvirt.VIR_ERR_NO_STORAGE_POOL:
raise NotFoundError("KCHPOOL0002E", {'name': name})
else:
raise
def _get_interface_info(self, name):
try:
info = netinfo.get_interface_info(name)
except ValueError:
raise NotFoundError("KCHIFACE0001E", {'name': name})
if not info['ipaddr']:
info['ipaddr'], info['netmask'] = \
self._get_static_config_interface_address(name)
return info
def delete(self, name):
path = config.get_debugreports_path()
file_pattern = os.path.join(path, name + '.*')
try:
file_target = glob.glob(file_pattern)[0]
except IndexError:
raise NotFoundError("KCHDR0001E", {'name': name})
os.remove(file_target)
def removeRepository(self, repo_id):
"""
Remove a given repository
"""
if not repo_id in self._repo_storage.keys():
raise NotFoundError("KCHREPOS0010E", {'repo_id': repo_id})
del self._repo_storage[repo_id]
self._pkg_mnger.removeRepo(repo_id)
return True
def get(self, obj_type, ident):
c = self.conn.cursor()
res = c.execute('SELECT json FROM objects WHERE type=? AND id=?',
(obj_type, ident))
try:
jsonstr = res.fetchall()[0][0]
except IndexError:
self.conn.rollback()
raise NotFoundError("KCHOBJST0001E", {'item': ident})
return json.loads(jsonstr)
def vmiface_update(self, vm, mac, params):
dom = self._get_vm(vm)
try:
info = dom.ifaces[mac].info
except KeyError:
raise NotFoundError("KCHVMIF0001E", {'iface': mac, 'name': vm})
if info['type'] == 'network' and 'network' in params:
info['network'] = params['network']
if 'model' in params:
info['model'] = params['model']
return mac
def _get_template(self, name, overrides=None):
try:
t = self._mock_templates[name]
if overrides:
args = copy.copy(t.info)
args.update(overrides)
return MockVMTemplate(args, self)
else:
return t
except KeyError:
raise NotFoundError("KCHTMPL0002E", {'name': name})
def get_vm(name, conn):
conn = conn.get()
try:
# outgoing text to libvirt, encode('utf-8')
return conn.lookupByName(name.encode("utf-8"))
except libvirt.libvirtError as e:
if e.get_error_code() == libvirt.VIR_ERR_NO_DOMAIN:
raise NotFoundError("KCHVM0002E", {'name': name})
else:
raise OperationFailed("KCHVM0009E", {'name': name,
'err': e.message})
def _get_user(self, _user_id):
ldap_server = config.get("authentication", "ldap_server").strip('"')
ldap_search_base = config.get("authentication",
"ldap_search_base").strip('"')
ldap_search_filter = config.get("authentication",
"ldap_search_filter",
vars={
"username":
_user_id.encode("utf-8")
}).strip('"')
connect = ldap.open(ldap_server)
try:
result = connect.search_s(ldap_search_base, ldap.SCOPE_SUBTREE,
ldap_search_filter)
if len(result) == 0:
raise NotFoundError("KCHAUTH0004E", {'user_id': _user_id})
return result[0][1]
except ldap.NO_SUCH_OBJECT:
raise NotFoundError("KCHAUTH0004E", {'user_id': _user_id})
