def create(self, vmid, params):
dev_name = params['name']
self._passthrough_device_validate(dev_name)
dev_info = DeviceModel(conn=self.conn).lookup(dev_name)
if dev_info['device_type'] == 'pci':
taskid = add_task(u'/plugins/kimchi/vms/%s/hostdevs/' %
VMModel.get_vm(vmid, self.conn).name(),
self._attach_pci_device, self.objstore,
{'vmid': vmid, 'dev_info': dev_info})
return self.task.lookup(taskid)
with RollbackContext() as rollback:
try:
dev = self.conn.get().nodeDeviceLookupByName(dev_name)
dev.dettach()
except Exception:
raise OperationFailed('KCHVMHDEV0005E', {'name': dev_name})
else:
rollback.prependDefer(dev.reAttach)
rollback.commitAll()
taskid = add_task(u'/plugins/kimchi/vms/%s/hostdevs/' %
VMModel.get_vm(vmid, self.conn).name(),
'_attach_%s_device' % dev_info['device_type'],
self.objstore, {'vmid': vmid, 'dev_info': dev_info})
return self.task.lookup(taskid)
def test_tasks(self):
id1 = add_task('/plugins/ginger/tasks/1', self._async_op,
model._objstore)
id2 = add_task('/plugins/ginger/tasks/2', self._except_op,
model._objstore)
id3 = add_task('/plugins/ginger/tasks/3', self._intermid_op,
model._objstore)
target_uri = urllib2.quote('^/plugins/ginger/tasks/*', safe="")
filter_data = 'status=running&target_uri=%s' % target_uri
tasks = json.loads(
self.request('/plugins/ginger/tasks?%s' % filter_data).read()
)
self.assertEquals(3, len(tasks))
tasks = json.loads(self.request('/plugins/ginger/tasks').read())
tasks_ids = [int(t['id']) for t in tasks]
self.assertEquals(set([id1, id2, id3]) - set(tasks_ids), set([]))
wait_task(self._task_lookup, id2)
foo2 = json.loads(
self.request('/plugins/ginger/tasks/%s' % id2).read()
)
keys = ['id', 'status', 'message', 'target_uri']
self.assertEquals(sorted(keys), sorted(foo2.keys()))
self.assertEquals('failed', foo2['status'])
wait_task(self._task_lookup, id3)
foo3 = json.loads(
self.request('/plugins/ginger/tasks/%s' % id3).read()
)
self.assertEquals('in progress', foo3['message'])
self.assertEquals('running', foo3['status'])
def create(self, vmid, params):
dev_name = params['name']
self._passthrough_device_validate(dev_name)
dev_info = DeviceModel(conn=self.conn).lookup(dev_name)
if dev_info['device_type'] == 'pci':
taskid = add_task(
u'/plugins/kimchi/vms/%s/hostdevs/' %
VMModel.get_vm(vmid, self.conn).name(),
self._attach_pci_device, self.objstore, {
'vmid': vmid,
'dev_info': dev_info
})
return self.task.lookup(taskid)
with RollbackContext() as rollback:
try:
dev = self.conn.get().nodeDeviceLookupByName(dev_name)
dev.dettach()
except Exception:
raise OperationFailed('KCHVMHDEV0005E', {'name': dev_name})
else:
rollback.prependDefer(dev.reAttach)
rollback.commitAll()
taskid = add_task(
u'/plugins/kimchi/vms/%s/hostdevs/' %
VMModel.get_vm(vmid, self.conn).name(),
'_attach_%s_device' % dev_info['device_type'], self.objstore, {
'vmid': vmid,
'dev_info': dev_info
})
return self.task.lookup(taskid)
def test_async_tasks(self):
class task_except(Exception):
pass
def quick_op(cb, message):
cb(message, True)
def long_op(cb, params):
time.sleep(params.get('delay', 3))
cb(params.get('message', ''), params.get('result', False))
def abnormal_op(cb, params):
try:
raise task_except
except:
cb("Exception raised", False)
def continuous_ops(cb, params):
cb("step 1 OK")
time.sleep(2)
cb("step 2 OK")
time.sleep(2)
cb("step 3 OK", params.get('result', True))
inst = model.Model('test:///default',
objstore_loc=self.tmp_store)
taskid = add_task('', quick_op, inst.objstore, 'Hello')
inst.task_wait(taskid)
self.assertEquals(1, taskid)
self.assertEquals('finished', inst.task_lookup(taskid)['status'])
self.assertEquals('Hello', inst.task_lookup(taskid)['message'])
taskid = add_task('', long_op, inst.objstore,
{'delay': 3, 'result': False,
'message': 'It was not meant to be'})
self.assertEquals(2, taskid)
self.assertEquals('running', inst.task_lookup(taskid)['status'])
self.assertEquals('OK', inst.task_lookup(taskid)['message'])
inst.task_wait(taskid)
self.assertEquals('failed', inst.task_lookup(taskid)['status'])
self.assertEquals('It was not meant to be',
inst.task_lookup(taskid)['message'])
taskid = add_task('', abnormal_op, inst.objstore, {})
inst.task_wait(taskid)
self.assertEquals('Exception raised',
inst.task_lookup(taskid)['message'])
self.assertEquals('failed', inst.task_lookup(taskid)['status'])
taskid = add_task('', continuous_ops, inst.objstore,
{'result': True})
self.assertEquals('running', inst.task_lookup(taskid)['status'])
inst.task_wait(taskid, timeout=10)
self.assertEquals('finished', inst.task_lookup(taskid)['status'])
def test_async_tasks(self):
class task_except(Exception):
pass
def quick_op(cb, message):
cb(message, True)
def long_op(cb, params):
time.sleep(params.get('delay', 3))
cb(params.get('message', ''), params.get('result', False))
def abnormal_op(cb, params):
try:
raise task_except
except:
cb("Exception raised", False)
def continuous_ops(cb, params):
cb("step 1 OK")
time.sleep(2)
cb("step 2 OK")
time.sleep(2)
cb("step 3 OK", params.get('result', True))
inst = model.Model('test:///default',
objstore_loc=self.tmp_store)
taskid = add_task('', quick_op, inst.objstore, 'Hello')
inst.task_wait(taskid)
self.assertEquals(1, taskid)
self.assertEquals('finished', inst.task_lookup(taskid)['status'])
self.assertEquals('Hello', inst.task_lookup(taskid)['message'])
taskid = add_task('', long_op, inst.objstore,
{'delay': 3, 'result': False,
'message': 'It was not meant to be'})
self.assertEquals(2, taskid)
self.assertEquals('running', inst.task_lookup(taskid)['status'])
self.assertEquals('OK', inst.task_lookup(taskid)['message'])
inst.task_wait(taskid)
self.assertEquals('failed', inst.task_lookup(taskid)['status'])
self.assertEquals('It was not meant to be',
inst.task_lookup(taskid)['message'])
taskid = add_task('', abnormal_op, inst.objstore, {})
inst.task_wait(taskid)
self.assertEquals('Exception raised',
inst.task_lookup(taskid)['message'])
self.assertEquals('failed', inst.task_lookup(taskid)['status'])
taskid = add_task('', continuous_ops, inst.objstore,
{'result': True})
self.assertEquals('running', inst.task_lookup(taskid)['status'])
inst.task_wait(taskid, timeout=10)
self.assertEquals('finished', inst.task_lookup(taskid)['status'])
def test_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 _mock_vmsnapshots_create(self, vm_name, params):
name = params.get('name', unicode(int(time.time())))
params = {'vm_name': vm_name, 'name': name}
taskid = add_task(u'/plugins/kimchi/vms/%s/snapshots/%s' %
(vm_name, name), self._vmsnapshots_create_task,
self.objstore, params)
return self.task_lookup(taskid)
def _mock_vmsnapshots_create(self, vm_name, params):
name = params.get('name', unicode(int(time.time())))
params = {'vm_name': vm_name, 'name': name}
taskid = add_task(
u'/plugins/kimchi/vms/%s/snapshots/%s' % (vm_name, name),
self._vmsnapshots_create_task, self.objstore, params)
return self.task_lookup(taskid)
def create(self, vm_name, params={}):
"""Create a snapshot with the current domain state.
The VM must be stopped and contain only disks with format 'qcow2';
otherwise an exception will be raised.
Parameters:
vm_name -- the name of the VM where the snapshot will be created.
params -- a dict with the following values:
"name": The snapshot name (optional). If omitted, a default value
based on the current time will be used.
Return:
A Task running the operation.
"""
vir_dom = VMModel.get_vm(vm_name, self.conn)
if DOM_STATE_MAP[vir_dom.info()[0]] != u'shutoff':
raise InvalidOperation('KCHSNAP0001E', {'vm': vm_name})
# if the VM has a non-CDROM disk with type 'raw', abort.
for storage_name in self.vmstorages.get_list(vm_name):
storage = self.vmstorage.lookup(vm_name, storage_name)
type = storage['type']
format = storage['format']
if type != u'cdrom' and format != u'qcow2':
raise InvalidOperation('KCHSNAP0010E', {'vm': vm_name,
'format': format})
name = params.get('name', unicode(int(time.time())))
task_params = {'vm_name': vm_name, 'name': name}
taskid = add_task(u'/plugins/kimchi/vms/%s/snapshots/%s' % (vm_name,
name), self._create_task, self.objstore, task_params)
return self.task.lookup(taskid)
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
})
task_params = {
'vmid': vmid,
'dev_name': dev_name,
'dom': dom,
'hostdev': hostdev,
'lock': threading.RLock()
}
task_uri = u'/plugins/kimchi/vms/%s/hostdevs/%s' % \
(VMModel.get_vm(vmid, self.conn).name(), dev_name)
taskid = add_task(task_uri, self._detach_device, self.objstore,
task_params)
return self.task.lookup(taskid)
def clone(self, pool, name, new_pool=None, new_name=None):
"""Clone a storage volume.
Arguments:
pool -- The name of the original pool.
name -- The name of the original volume.
new_pool -- The name of the destination pool (optional). If omitted,
the new volume will be created on the same pool as the
original one.
new_name -- The name of the new volume (optional). If omitted, a new
value based on the original volume's name will be used.
Return:
A Task running the clone operation.
"""
# the same pool will be used if no pool is specified
if new_pool is None:
new_pool = pool
# a default name based on the original name will be used if no name
# is specified
if new_name is None:
base, ext = os.path.splitext(name)
new_name = get_next_clone_name(self.storagevolumes.get_list(pool),
base, ext)
params = {'pool': pool,
'name': name,
'new_pool': new_pool,
'new_name': new_name}
taskid = add_task(u'/plugins/kimchi/storagepools/%s/storagevolumes/%s'
% (pool, new_name), self._clone_task, self.objstore,
params)
return self.task.lookup(taskid)
def create(self, params):
uuid_uuid4 = uuid.uuid4()
if isinstance(uuid_uuid4, unicode):
uuid_uuid4 = uuid_uuid4.encode('utf-8')
archive_id = str(uuid_uuid4)
stamp = int(time.mktime(time.localtime()))
# Though formally we ask front-end to not send "include" at all when
# it's empty, but in implementation we try to be tolerant.
# Front-end can also send [] to indicate the "include" is empty.
include = params.get('include')
exclude = params.get('exclude', [])
if not include:
include = self._default_include
if not exclude:
exclude = self._default_exclude
ar_params = {'identity': archive_id,
'include': include,
'exclude': exclude,
'description': params.get('description', ''),
'checksum': {},
'timestamp': stamp,
'file': ''}
taskid = add_task(u'/backup/create/%s' % (archive_id),
self._create_task, self._objstore, ar_params)
return self.task.lookup(taskid)
def _gen_debugreport_file(self, name):
gen_cmd = self.get_system_report_tool()
if gen_cmd is not None:
return add_task("/plugins/gingerbase/debugreports/%s" % name, gen_cmd, self.objstore, name)
raise OperationFailed("GGBDR0002E")
def _gen_debugreport_file(self, name):
gen_cmd = self.get_system_report_tool()
if gen_cmd is not None:
return add_task('/plugins/gingerbase/debugreports/%s' % name,
gen_cmd, self.objstore, name)
raise OperationFailed("GGBDR0002E")
def trigger(self, name):
"""
Trigger LUN scanning
"""
taskid = add_task('/plugins/gingers390/lunscan/trigger',
utils.trigger_lun_scan, self.objstore, {})
return self.task.lookup(taskid)
def _gen_debugreport_file(self, name):
gen_cmd = self.get_system_report_tool()
if gen_cmd is not None:
return add_task('/plugins/kimchi/debugreports/%s' % name, gen_cmd,
self.objstore, name)
raise OperationFailed("KCHDR0002E")
def lookup(self, *name):
try:
swupdate = SoftwareUpdate()
except:
raise OperationFailed('GGBPKGUPD0004E')
taskid = add_task('/plugins/gingerbase/host/swupdateprogress',
swupdate.tailUpdateLogs, self.objstore, None)
return self.task.lookup(taskid)
def lookup(self, *name):
try:
swupdate = SoftwareUpdate()
except:
raise OperationFailed('KCHPKGUPD0004E')
taskid = add_task('/plugins/kimchi/host/swupdateprogress',
swupdate.tailUpdateLogs, self.objstore, None)
return self.task.lookup(taskid)
def format(self, name, fstype):
if utils._is_mntd(name):
raise OperationFailed('GINPART00004E')
task_params = {'name': name, 'fstype': fstype}
taskid = add_task(u'/partitions/%s/fstype%s' % (name, fstype),
self._format_task, self.objstore, task_params)
return self.task.lookup(taskid)
def create(self, pool_name, params):
vol_source = ["url", "capacity"]
name = params.get("name")
index_list = list(i for i in range(len(vol_source)) if vol_source[i] in params)
if len(index_list) != 1:
raise InvalidParameter("KCHVOL0018E", {"param": ",".join(vol_source)})
create_param = vol_source[index_list[0]]
# Verify if the URL is valid
if create_param == "url":
url = params["url"]
try:
urllib2.urlopen(url).close()
except:
raise InvalidParameter("KCHVOL0022E", {"url": url})
all_vol_names = self.get_list(pool_name)
if name is None:
# the methods listed in 'REQUIRE_NAME_PARAMS' cannot have
# 'name' == None
if create_param in REQUIRE_NAME_PARAMS:
raise InvalidParameter("KCHVOL0016E")
# if 'name' is omitted - except for the methods listed in
# 'REQUIRE_NAME_PARAMS' - the default volume name will be the
# file/URL basename.
if create_param == "url":
name = os.path.basename(params["url"])
else:
name = "upload-%s" % int(time.time())
name = get_unique_file_name(all_vol_names, name)
params["name"] = name
try:
create_func = getattr(self, "_create_volume_with_%s" % create_param)
except AttributeError:
raise InvalidParameter("KCHVOL0019E", {"param": create_param})
pool_info = StoragePoolModel(conn=self.conn, objstore=self.objstore).lookup(pool_name)
if pool_info["type"] in READONLY_POOL_TYPE:
raise InvalidParameter("KCHVOL0012E", {"type": pool_info["type"]})
if pool_info["state"] == "inactive":
raise InvalidParameter("KCHVOL0003E", {"pool": pool_name, "volume": name})
if name in all_vol_names:
raise InvalidParameter("KCHVOL0001E", {"name": name})
params["pool"] = pool_name
targeturi = "/plugins/kimchi/storagepools/%s/storagevolumes/%s" % (pool_name, name)
taskid = add_task(targeturi, create_func, self.objstore, params)
return self.task.lookup(taskid)
def create(self, params):
if 'pv_name' not in params:
raise MissingParameter("GINPV00001E")
pvname = params['pv_name']
taskid = add_task(u'/pvs/pv_name/%s' % (pvname),
self._create_task, self.objstore, params)
return self.task.lookup(taskid)
def create(self, params):
if 'vg_name' not in params:
raise MissingParameter('GINLV00001E')
vgname = params['vg_name']
if 'size' not in params:
raise MissingParameter('GINLV00002E')
taskid = add_task(u'/lvs/vg_name/%s' % (vgname),
self._create_linear_task, self.objstore, params)
return self.task.lookup(taskid)
def swupdate(self, *name):
try:
swupdate = SoftwareUpdate()
except:
raise OperationFailed('KCHPKGUPD0004E')
pkgs = swupdate.getNumOfUpdates()
if pkgs == 0:
raise OperationFailed('KCHPKGUPD0001E')
wok_log.debug('Host is going to be updated.')
taskid = add_task('/plugins/kimchi/host/swupdate', swupdate.doUpdate,
self.objstore, None)
return self.task.lookup(taskid)
def create(self, params):
if 'vg_name' not in params:
raise MissingParameter("GINVG00013E")
vgname = params['vg_name']
if "pv_paths" not in params:
raise MissingParameter("GINVG00014E")
taskid = add_task(u'/vgs/vg_name/%s' % (vgname),
self._create_task, self.objstore, params)
return self.task.lookup(taskid)
def swupdate(self, *name):
try:
swupdate = SoftwareUpdate()
except:
raise OperationFailed('KCHPKGUPD0004E')
pkgs = swupdate.getNumOfUpdates()
if pkgs == 0:
raise OperationFailed('KCHPKGUPD0001E')
wok_log.debug('Host is going to be updated.')
taskid = add_task('/plugins/kimchi/host/swupdate', swupdate.doUpdate,
self.objstore, None)
return self.task.lookup(taskid)
def swupdate(self, *name):
try:
swupdate = SoftwareUpdate()
except:
raise OperationFailed('GGBPKGUPD0004E')
pkgs = swupdate.getNumOfUpdates()
if pkgs == 0:
wok_log.debug(messages['GGBPKGUPD0001E'])
return {'message': messages['GGBPKGUPD0001E']}
wok_log.debug('Host is going to be updated.')
taskid = add_task('/plugins/gingerbase/host/swupdate',
swupdate.doUpdate,
self.objstore, None)
return self.task.lookup(taskid)
def unconfigure(self, interface):
"""
method to un-configure network device - remove or bring the network
device offline and unpersist it
:param interface: name of the network interface
:return: returns task json
"""
wok_log.info('Un-configuring network device %s' % interface)
device = str(interface).strip()
if ENCCW in device:
# filtering out device id from interface
device = device.replace(ENCCW, '')
taskid = add_task('/plugins/gingers390x/nwdevices/%s/unconfigure'
% interface, _unconfigure_interface,
self.objstore, device)
return self.task.lookup(taskid)
def swupdate(self, *name):
try:
swupdate = SoftwareUpdate()
except:
raise OperationFailed('GGBPKGUPD0004E')
pkgs = swupdate.getNumOfUpdates()
if pkgs == 0:
wok_log.debug(messages['GGBPKGUPD0001E'])
return {'message': messages['GGBPKGUPD0001E']}
wok_log.debug('Host is going to be updated.')
taskid = add_task('/plugins/gingerbase/host/swupdate',
swupdate.doUpdate,
self.objstore, None)
return self.task.lookup(taskid)
def remove(self, name, devices):
"""
Remove one or more device IDs from blacklist.
:param devices: List of devices
:return: task json
"""
# Check the type of devices.
if not (isinstance(devices, list)):
wok_log.error('Input is not of type list. Input: %s' % devices)
raise InvalidParameter('GS390XINVINPUT', {'reason': 'input must '
'be of type'
' list'})
wok_log.info('Removing devices %s from ignore list' % devices)
taskid = add_task('/plugins/gingers390x/cioignore/remove',
_remove_devices, self.objstore, devices)
return self.task.lookup(taskid)
def upgrade(self, ident, fw_path=None, pow_ok=None):
if detect_live_vm():
wok_log.error('Cannot update system fw while running VMs.')
raise OperationFailed('GINFW0001E')
# Process argumets provided by user: firmware path and overwrite-perm
if fw_path is None:
wok_log.error('FW update failed: '
'No image file found in the package file.')
raise OperationFailed('GINFW0003E')
ms = magic.open(magic.NONE)
ms.load()
if ms.file(fw_path).lower().startswith('rpm'):
# First unpack the rpm to get the fw img file
command = ['rpm', '-U', '--force', '--ignoreos', fw_path]
output, error, rc = run_command(command)
if rc:
# rpm returns num failed pkgs on failure or neg for unknown
raise OperationFailed('GINFW0002E', {'rc': rc, 'err': error})
# The image file should now be in /tmp/fwupdate/
# and match the rpm name.
image_file, ext = os.path.splitext(os.path.basename(fw_path))
image_file = os.path.join('/tmp/fwupdate', '%s.img' % image_file)
if not os.path.exists(image_file):
wok_log.error('FW update failed: '
'No image file found in the package file.')
raise OperationFailed('GINFW0003E')
else:
image_file = fw_path
ms.close()
command = ['update_flash', '-f', image_file]
if pow_ok is not None:
command.insert(1, '-n')
# update_flash may take some time to restart the system. Inform user.
wok_log.info('FW update: System will reboot to flash the firmware.')
cmd_params = {'command': command, 'operation': 'update'}
taskid = add_task('/plugins/ginger/firmware/upgrade',
self._execute_task, self.objstore, cmd_params)
return self.task.lookup(taskid)
def upgrade(self, name):
"""
Execute the update of a specific package (and its dependencies, if
necessary) in the system.
@param: Name
@return: task
"""
if self.host_swupdate is None:
raise OperationFailed('GGBPKGUPD0004E')
self.pkgs2update = self.host_swupdate.getUpdates()
pkgs_list = self._resolve_dependencies(name)
msg = 'The following packages will be updated: ' + ', '.join(pkgs_list)
wok_log.debug(msg)
taskid = add_task('/plugins/gingerbase/host/packagesupdate/%s/upgrade'
% name, self.host_swupdate.doUpdate,
self.objstore, pkgs_list)
return self.task.lookup(taskid)
def format(self, bus_id, blk_size):
woklock = threading.Lock()
name = self.dev_details['name']
dasd_name_list = dasd_utils._get_dasd_names()
if name not in dasd_name_list:
raise NotFoundError('GINDASD0007E')
task_params = {'blk_size': blk_size, 'name': name}
try:
woklock.acquire()
taskid = add_task(u'/dasddevs/%s/blksize/%s' % (name, blk_size),
self._format_task, self.objstore, task_params)
except OperationFailed as e:
woklock.release()
wok_log.error("Formatting of DASD device %s failed" % bus_id)
raise OperationFailed("GINDASD0008E", {'err': e})
finally:
woklock.release()
return self.task.lookup(taskid)
def format(self, bus_id, blk_size):
woklock = threading.Lock()
name = dev_details['name']
dasd_name_list = dasd_utils._get_dasd_names()
if name not in dasd_name_list:
raise NotFoundError('GINDASD0007E')
task_params = {'blk_size': blk_size, 'name': name}
try:
woklock.acquire()
taskid = add_task(u'/dasddevs/%s/blksize/%s' % (name, blk_size),
self._format_task, self.objstore, task_params)
except OperationFailed as e:
woklock.release()
wok_log.error("Formatting of DASD device %s failed" % bus_id)
raise OperationFailed("GINDASD0008E", {'err': e})
finally:
woklock.release()
return self.task.lookup(taskid)
def remove(self, name, devices):
"""
Remove one or more device IDs from blacklist.
:param devices: List of devices
:return: task json
"""
# Check the type of devices.
if not (isinstance(devices, list)):
wok_log.error('Input is not of type list. Input: %s' % devices)
raise InvalidParameter(
'GS390XINVINPUT',
{'reason': 'input must '
'be of type'
' list'})
wok_log.info('Removing devices %s from ignore list' % devices)
taskid = add_task('/plugins/gingers390x/cioignore/remove',
_remove_devices, self.objstore, devices)
return self.task.lookup(taskid)
def create(self, params):
file_loc = ''
if 'file_loc' not in params or not params['file_loc']:
raise InvalidParameter('GINSP00001E')
if 'type' not in params:
raise InvalidParameter('GINSP00002E')
else:
if params['type'] == 'file' and 'size' not in params:
raise InvalidParameter('GINSP00003E')
if params['type'] == 'device' or params['type'] == 'file':
taskid = add_task(u'/swaps/file_loc/%s' % (file_loc),
self._create_task, self.objstore, params)
return self.task.lookup(taskid)
else:
raise InvalidParameter('GINSP00004E')
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})
task_params = {'vmid': vmid,
'dev_name': dev_name,
'dom': dom,
'hostdev': hostdev}
task_uri = u'/plugins/kimchi/vms/%s/hostdevs/%s' % \
(VMModel.get_vm(vmid, self.conn).name(), dev_name)
taskid = add_task(task_uri, self._detach_device, self.objstore,
task_params)
return self.task.lookup(taskid)
def create(self, vm_name, params=None):
"""Create a snapshot with the current domain state.
The VM must be stopped and contain only disks with format 'qcow2';
otherwise an exception will be raised.
Parameters:
vm_name -- the name of the VM where the snapshot will be created.
params -- a dict with the following values:
"name": The snapshot name (optional). If omitted, a default value
based on the current time will be used.
Return:
A Task running the operation.
"""
if params is None:
params = {}
vir_dom = VMModel.get_vm(vm_name, self.conn)
if DOM_STATE_MAP[vir_dom.info()[0]] != u'shutoff':
raise InvalidOperation('KCHSNAP0001E', {'vm': vm_name})
# if the VM has a non-CDROM disk with type 'raw', abort.
for storage_name in self.vmstorages.get_list(vm_name):
storage = self.vmstorage.lookup(vm_name, storage_name)
type = storage['type']
format = storage['format']
if type != u'cdrom' and format != u'qcow2':
raise InvalidOperation('KCHSNAP0010E', {
'vm': vm_name,
'format': format
})
name = params.get('name', unicode(int(time.time())))
task_params = {'vm_name': vm_name, 'name': name}
taskid = add_task(
u'/plugins/kimchi/vms/%s/snapshots/%s' % (vm_name, name),
self._create_task, self.objstore, task_params)
return self.task.lookup(taskid)
def format(self, bus_id, blk_size):
tasks = []
dasd_utils.validate_bus_id(bus_id)
woklock = threading.Lock()
name = self.dev_details['name']
dasd_name_list = dasd_utils._get_dasd_names()
if name not in dasd_name_list:
raise NotFoundError('GINDASD0007E')
task_params = {'blk_size': blk_size, 'name': name}
try:
woklock.acquire()
with self.objstore as session:
tasks = session.get_list('task')
running_tasks = []
for task in tasks:
with self.objstore as session:
current_task = session.get('task', str(task))
if (current_task['target_uri'].startswith('/dasddevs') and
current_task['status']) == 'running':
running_tasks.append(current_task)
# Limit the number of concurrent DASD format operations to
# MAX_DASD_FMT.
if len(running_tasks) > MAX_DASD_FMT:
raise InvalidOperation(
"GINDASD0014E", {
'max_dasd_fmt': str(MAX_DASD_FMT)})
taskid = add_task(u'/dasddevs/%s/blksize/%s' % (name, blk_size),
self._format_task, self.objstore, task_params)
except OperationFailed:
woklock.release()
wok_log.error("Formatting of DASD device %s failed" % bus_id)
raise OperationFailed("GINDASD0008E", {'name': name})
finally:
woklock.release()
return self.task.lookup(taskid)
def create(self, params):
file_loc = ''
if 'file_loc' not in params or not params['file_loc']:
wok_log.error("File location required for creating a swap device.")
raise InvalidParameter('GINSP00001E')
if 'type' not in params:
wok_log.error("Type required for creating a swap device.")
raise InvalidParameter('GINSP00002E')
else:
if params['type'] == 'file' and 'size' not in params:
wok_log.error("Size is required file type swap device.")
raise InvalidParameter('GINSP00003E')
if params['type'] == 'device' or params['type'] == 'file':
taskid = add_task(u'/swaps/file_loc/%s' % (file_loc),
self._create_task, self.objstore, params)
return self.task.lookup(taskid)
else:
wok_log.error("Incorrect swap type.")
raise InvalidParameter('GINSP00004E')
scan_params['scan_path'] = params['path']
params['type'] = 'dir'
for pool in self.get_list():
try:
res = StoragePoolModel(conn=self.conn,
objstore=self.objstore).lookup(pool)
if res['state'] == 'active':
scan_params['ignore_list'].append(res['path'])
except Exception, e:
err = "Exception %s occured when get ignore path"
wok_log.debug(err % e.message)
params['path'] = self.scanner.scan_dir_prepare(params['name'])
scan_params['pool_path'] = params['path']
task_id = add_task('/plugins/kimchi/storagepools/%s' % ISO_POOL_NAME,
self.scanner.start_scan, self.objstore, scan_params)
# Record scanning-task/storagepool mapping for future querying
try:
with self.objstore as session:
session.store('scanning', params['name'], task_id)
return task_id
except Exception as e:
raise OperationFailed('KCHPOOL0037E', {'err': e.message})
class StoragePoolModel(object):
def __init__(self, **kargs):
self.conn = kargs['conn']
self.objstore = kargs['objstore']
@staticmethod
def _gen_debugreport_file(self, name):
return add_task('/plugins/gingerbase/debugreports/%s' % name,
self._create_log, self.objstore, name)
def _gen_debugreport_file(self, name):
return add_task("/plugins/gingerbase/debugreports/%s" % name, self._create_log, self.objstore, name)
def create(self, pool_name, params):
vol_source = ['url', 'capacity']
name = params.get('name')
index_list = list(i for i in range(len(vol_source))
if vol_source[i] in params)
if len(index_list) != 1:
raise InvalidParameter("KCHVOL0018E",
{'param': ",".join(vol_source)})
create_param = vol_source[index_list[0]]
# Verify if the URL is valid
if create_param == 'url':
url = params['url']
try:
urllib2.urlopen(url).close()
except:
raise InvalidParameter('KCHVOL0022E', {'url': url})
all_vol_names = self.get_list(pool_name)
if name is None:
# the methods listed in 'REQUIRE_NAME_PARAMS' cannot have
# 'name' == None
if create_param in REQUIRE_NAME_PARAMS:
raise InvalidParameter('KCHVOL0016E')
# if 'name' is omitted - except for the methods listed in
# 'REQUIRE_NAME_PARAMS' - the default volume name will be the
# file/URL basename.
if create_param == 'url':
name = os.path.basename(params['url'])
else:
name = 'upload-%s' % int(time.time())
name = get_unique_file_name(all_vol_names, name)
params['name'] = name
try:
create_func = getattr(self, '_create_volume_with_%s' %
create_param)
except AttributeError:
raise InvalidParameter("KCHVOL0019E", {'param': create_param})
pool_info = StoragePoolModel(conn=self.conn,
objstore=self.objstore).lookup(pool_name)
if pool_info['type'] in READONLY_POOL_TYPE:
raise InvalidParameter("KCHVOL0012E", {'type': pool_info['type']})
if pool_info['state'] == 'inactive':
raise InvalidParameter('KCHVOL0003E', {'pool': pool_name,
'volume': name})
if name in all_vol_names:
raise InvalidParameter('KCHVOL0001E', {'name': name})
params['pool'] = pool_name
targeturi = '/plugins/kimchi/storagepools/%s/storagevolumes/%s' \
% (pool_name, name)
taskid = add_task(targeturi, create_func, self.objstore, params)
return self.task.lookup(taskid)
def _mock_softwareupdateprogress_lookup(self, *name):
task_id = add_task('/plugins/gingerbase/host/swupdateprogress',
self._mock_swupdate.doSlowUpdate, self.objstore)
return self.task_lookup(task_id)
def _mock_host_swupdate(self, args=None):
task_id = add_task('/plugins/gingerbase/host/swupdate',
self._mock_swupdate.doUpdate, self.objstore)
return self.task_lookup(task_id)
scan_params['scan_path'] = params['path']
params['type'] = 'dir'
for pool in self.get_list():
try:
res = StoragePoolModel(conn=self.conn,
objstore=self.objstore).lookup(pool)
if res['state'] == 'active':
scan_params['ignore_list'].append(res['path'])
except Exception, e:
err = "Exception %s occured when get ignore path"
wok_log.debug(err % e.message)
params['path'] = self.scanner.scan_dir_prepare(params['name'])
scan_params['pool_path'] = params['path']
task_id = add_task('/plugins/kimchi/storagepools/%s' % ISO_POOL_NAME,
self.scanner.start_scan, self.objstore, scan_params)
# Record scanning-task/storagepool mapping for future querying
try:
with self.objstore as session:
session.store('scanning', params['name'], task_id,
get_kimchi_version())
return task_id
except Exception as e:
raise OperationFailed('KCHPOOL0037E', {'err': e.message})
class StoragePoolModel(object):
def __init__(self, **kargs):
self.conn = kargs['conn']
self.objstore = kargs['objstore']
