def unmap_vol(self, dbg, uri, chained=False):
path = self.gen_vol_path(dbg, uri)
if exists(path):
log.debug(
"%s: xcpng.datapath.DatapathOperations.unmap_vol: uri: %s" %
(dbg, uri))
try:
volume_meta = self.MetadataHandler.get_vdi_meta(dbg, uri)
if REF_COUNT_TAG in volume_meta:
new_meta = {}
if volume_meta[REF_COUNT_TAG] == 1:
new_meta[REF_COUNT_TAG] = None
call(dbg, ['unlink', path])
else:
new_meta[
REF_COUNT_TAG] = volume_meta[REF_COUNT_TAG] - 1
self.MetadataHandler.update_vdi_meta(dbg, uri, new_meta)
if chained:
if PARENT_URI_TAG in volume_meta:
self.unmap_vol(dbg, volume_meta[PARENT_URI_TAG][0],
chained)
except Exception as e:
log.error(
"%s: xcpng.datapath.DatapathOperations.unmap_vol: Failed to unmap volume: uri: %s"
% (dbg, uri))
raise Exception(e)
def _resize(self, dbg, sr, key, new_size):
log.debug("%s: xcpng.volume.QCOW2Volume._resize: SR: %s Key: %s New_size: %s"
% (dbg, sr, key, new_size))
uri = "%s/%s" % (sr, key)
datapath = get_vdi_datapath_by_uri(dbg, uri)
try:
super(QCOW2Volume, self)._resize(dbg, sr, key, new_size)
self.Datapathes[datapath].DatapathOpsHandler.map_vol(dbg, uri)
call(dbg, ["/usr/lib64/qemu-dp/bin/qemu-img",
"resize",
self.Datapathes[datapath].DatapathOpsHandler.gen_vol_path(dbg, uri),
str(new_size)])
self.Datapathes[datapath].DatapathOpsHandler.unmap_vol(dbg, uri)
except Exception as e:
log.error("%s: xcpng.volume.QCOW2Volume._resize: Failed to resize volume: key %s: SR: %s" %
(dbg, key, sr))
try:
self.Datapathes[datapath].DatapathOpsHandler.unmap_vol(dbg, uri)
except:
pass
raise Exception(e)
def attach(self, dbg, configuration):
log.debug("%s: xcpng.sr.SR.attach: configuration: %s" %
(dbg, configuration))
if IMAGE_FORMAT_TAG in configuration:
uri = "%s+%s" % (self.sr_type, configuration[IMAGE_FORMAT_TAG])
if DATAPATH_TAG in configuration:
uri = "%s+%s://" % (uri, configuration[DATAPATH_TAG])
else:
uri = "%s://" % self.sr_type
uri = self.SROpsHendler.extend_uri(dbg, uri, configuration)
uri = "%s/%s" % (uri, configuration[SR_UUID_TAG]
) if SR_UUID_TAG in configuration else uri
log.debug("%s: xcpng.sr.SR.attach: uri: %s" % (dbg, uri))
configuration['mountpoint'] = "%s/%s" % (SR_PATH_PREFIX,
get_sr_uuid_by_uri(dbg, uri))
try:
call(dbg, ['mkdir', '-p', configuration['mountpoint']])
self.SROpsHendler.sr_import(dbg, uri, configuration)
except Exception as e:
log.error(
"%s: xcpng.sr.SR.attach: Failed to attach SR - sr_uuid: %s" %
(dbg, get_sr_uuid_by_uri(dbg, uri)))
try:
self.SROpsHendler.sr_export(dbg, uri)
call(dbg, ['rm', '-rf', configuration['mountpoint']])
except:
pass
raise Exception(e)
return uri
def map_vol(self, dbg, uri, chained=False):
if self.blkdev:
log.debug(
"%s: xcpng.datapath.DatapathOperations.map_vol: uri: %s" %
(dbg, uri))
_blkdev_ = self.blkdev
try:
volume_meta = self.MetadataHandler.get_vdi_meta(dbg, uri)
if chained is True:
if PARENT_URI_TAG in volume_meta:
self.map_vol(dbg, volume_meta[PARENT_URI_TAG][0],
chained)
if REF_COUNT_TAG in volume_meta:
new_meta = {}
new_meta[REF_COUNT_TAG] = volume_meta[REF_COUNT_TAG] + 1
self.MetadataHandler.update_vdi_meta(dbg, uri, new_meta)
else:
new_meta = {}
new_meta[REF_COUNT_TAG] = 1
call(dbg,
['ln', '-s', _blkdev_,
self.gen_vol_path(dbg, uri)])
self.MetadataHandler.update_vdi_meta(dbg, uri, new_meta)
except Exception as e:
log.error(
"%s: xcpng.datapath.DatapathOperations.map_vol: Failed to map volume: uri: %s device: %s"
% (dbg, uri, _blkdev_))
raise Exception(e)
def destroy(self, dbg, uri):
log.debug("%s: xcpng.libzfs.meta.MetaDBOpeations.destroy: uri: %s" %
(dbg, uri))
call(dbg, [
'rm', '-f',
"%s/%s/__meta__" % (SR_PATH_PREFIX, get_sr_uuid_by_uri(dbg, uri))
])
def _create(self, dbg, sr, name, description, size, sharable, image_meta):
log.debug("%s: xcpng.volume.QCOW2Volume._create: SR: %s Name: %s Description: %s Size: %s"
% (dbg, sr, name, description, size))
uri = image_meta[URI_TAG][0]
datapath = get_vdi_datapath_by_uri(dbg, uri)
try:
super(QCOW2Volume, self)._create(dbg, sr, name, description, size, sharable, image_meta)
self.Datapathes[datapath].DatapathOpsHandler.map_vol(dbg, uri)
call(dbg, ["/usr/lib64/qemu-dp/bin/qemu-img",
"create",
"-f", image_meta[TYPE_TAG],
self.Datapathes[datapath].DatapathOpsHandler.gen_vol_path(dbg, uri),
str(size)])
self.Datapathes[datapath].DatapathOpsHandler.unmap_vol(dbg, uri)
return image_meta
except Exception as e:
log.error("%s: xcpng.volume.QCOW2Volume._create: Failed to create volume: key %s: SR: %s" %
(dbg, image_meta[VDI_UUID_TAG], sr))
try:
self.Datapathes[datapath].DatapathOpsHandler.unmap_vol(dbg, uri)
except:
pass
raise Exception(e)
def unmap_vol(self, dbg, uri, chained=False):
if chained is False:
super(DatapathOperations, self).unmap_vol(dbg, uri, chained=False)
volume_meta = self.MetadataHandler.get_vdi_meta(dbg, uri)
call(dbg,
['/lib64/qemu-dp/bin/qemu-nbd', '-d', volume_meta['nbd_dev']])
volume_meta = {'nbd_dev': None}
self.MetadataHandler.update_vdi_meta(dbg, uri, volume_meta)
def close(self, dbg):
log.debug(
"%s: xcpng.qemudisk.Qemudisk.close: vdi_uuid %s pid %d qmp_sock %s"
% (dbg, self.vdi_uuid, self.pid, self.qmp_sock))
_qmp_ = qmp.QEMUMonitorProtocol(self.qmp_sock)
try:
_qmp_.connect()
if platform.linux_distribution()[1] == '7.5.0':
try:
path = "{}/{}".format(utils.VAR_RUN_PREFIX, self.vdi_uuid)
with open(path, 'r') as f:
line = f.readline().strip()
utils.call(dbg, ["/usr/bin/xenstore-write", line, "5"])
os.unlink(path)
except Exception:
log.debug(
"%s: xcpng.qemudisk.Qemudisk.close: There was no xenstore setup"
% dbg)
elif platform.linux_distribution()[1] == '7.6.0' or \
platform.linux_distribution()[1] == '8.0.0' or \
platform.linux_distribution()[1] == '8.1.0' or \
platform.linux_distribution()[1] == '8.2.0' or \
platform.linux_distribution()[1] == '8.2.1':
path = "{}/{}".format(utils.VAR_RUN_PREFIX, self.vdi_uuid)
try:
with open(path, 'r') as f:
line = f.readline().strip()
os.unlink(path)
args = {
'type': 'qdisk',
'domid':
int(re.search('domain/(\d+)/', line).group(1)),
'devid': int(re.search('vbd/(\d+)/', line).group(1))
}
_qmp_.command(dbg, "xen-unwatch-device", **args)
except Exception:
log.debug(
"%s: xcpng.qemudisk.Qemudisk.close: There was no xenstore setup"
% dbg)
# Stop the NBD server
_qmp_.command("nbd-server-stop")
# Remove the block device
args = {"node-name": LEAF_NODE_NAME}
_qmp_.command("blockdev-del", **args)
except Exception as e:
log.error(
"%s: xcpng.qemudisk.Qemudisk.close: Failed to close image in qemu_dp instance: uuid: %s pid %s"
% (dbg, self.vdi_uuid, self.pid))
log.error(traceback.format_exc())
try:
_qmp_.close()
except:
pass
raise Exception(e)
def create(self, dbg, sr_uuid, configuration, name, description):
log.debug(
"%s: xcpng.sr.SR.create: sr_uuid %s configuration %s name '%s' description: '%s'"
% (dbg, sr_uuid, configuration, name, description))
if IMAGE_FORMAT_TAG in configuration:
uri = "%s+%s" % (self.sr_type, configuration[IMAGE_FORMAT_TAG])
if DATAPATH_TAG in configuration:
uri = "%s+%s://" % (uri, configuration[DATAPATH_TAG])
else:
uri = "%s://" % self.sr_type
uri = self.SROpsHendler.extend_uri(dbg, uri, configuration)
uri = "%s/%s" % (uri, sr_uuid)
log.debug("%s: xcpng.sr.SR.create: uri %s" % (dbg, uri))
configuration['mountpoint'] = "%s/%s" % (SR_PATH_PREFIX,
get_sr_uuid_by_uri(dbg, uri))
try:
call(dbg, ['mkdir', '-p', configuration['mountpoint']])
self.SROpsHendler.create(dbg, uri, configuration)
self.MetadataHandler.create(dbg, uri)
configuration['sr_uuid'] = sr_uuid
sr_meta = {
SR_UUID_TAG: sr_uuid,
NAME_TAG: name,
DESCRIPTION_TAG: description,
#CONFIGURATION_TAG: json.dumps(configuration)
CONFIGURATION_TAG: configuration
}
self.MetadataHandler.update_sr_meta(dbg, uri, sr_meta)
self.MetadataHandler.dump(dbg, uri)
except Exception as e:
log.error(
"%s: xcpng.sr.SR.create: Failed to create SR - sr_uuid: %s" %
(dbg, sr_uuid))
log.error(traceback.format_exc())
try:
self.SROpsHendler.destroy(dbg, uri)
except:
pass
raise Exception(e)
try:
self.SROpsHendler.sr_export(dbg, uri)
except Exception as e:
log.error(
"%s: xcpng.sr.SR.create: Created but failed to export SR after creation - sr_uuid: %s"
"Please check and export SR manually before attaching the SR" %
(dbg, sr_uuid))
log.error(traceback.format_exc())
return configuration
def _is_nbd_device_connected(self, dbg, nbd_device):
call(dbg, ['/usr/sbin/modprobe', 'nbd', "nbds_max=%s" % NBDS_MAX])
if not exists(nbd_device):
raise Exception('There are no more free NBD devices')
returncode = _call(dbg, ['/usr/sbin/nbd-client', '-check', nbd_device])
if returncode == 0:
return True
if returncode == 1:
return False
def dog_vdi_setattr(dbg, port, vdi_name, attr, val, exclusive=True):
log.debug(
"%s: xcpng.libsbd.sbd_utils.dog_vdi_setattr: port: %s vdi: %s attr: %s val: %s excl: %s"
% (dbg, port, vdi_name, attr, val, exclusive))
cmd = ['dog', 'vdi', 'setattr', '-p', str(port)]
if exclusive:
cmd.append('-x')
cmd.extend([vdi_name, attr, val])
call(dbg, cmd)
def map_vol(self, dbg, uri, chained=False):
if chained is False:
nbd_dev = self._find_unused_nbd_device(dbg)
call(dbg, [
'/lib64/qemu-dp/bin/qemu-nbd', '-c', nbd_dev, '-f', 'raw',
self.gen_vol_uri(dbg, uri)
])
volume_meta = {'nbd_dev': nbd_dev}
self.MetadataHandler.update_vdi_meta(dbg, uri, volume_meta)
self.blkdev = nbd_dev
super(DatapathOperations, self).map_vol(dbg, uri, chained=False)
def pool_import(dbg, pool_name, mountpoint=None):
log.debug("%s: zfs_utils.pool_import: pool_name: %s mountpoint: %s" % (dbg, pool_name, mountpoint))
cmd = ['zpool', 'import', pool_name]
call(dbg, cmd)
cmd = ['zfs', 'set']
if mountpoint is not None:
cmd.extend(["mountpoint=%s" % mountpoint])
else:
cmd.extend(['mountpoint=legacy'])
cmd.extend([pool_name])
call(dbg, cmd)
def unmap_vol(self, dbg, uri, chained=False):
if chained is False:
log.debug(
"%s: xcpng.librbd.datapath.QdiskDatapath.unmap_vol: uri: %s" %
(dbg, uri))
super(DatapathOperations, self).unmap_vol(dbg, uri, chained=False)
volume_meta = self.MetadataHandler.get_vdi_meta(dbg, uri)
call(dbg, [
'/usr/lib64/qemu-dp-xcpng/bin/qemu-nbd', '-d',
volume_meta['nbd_dev']
])
volume_meta = {'nbd_dev': None}
self.MetadataHandler.update_vdi_meta(dbg, uri, volume_meta)
def detach(self, dbg, uri):
log.debug("%s: xcpng.sr.SR.detach: uri: %s" % (dbg, uri))
try:
self.SROpsHendler.sr_export(dbg, uri)
call(dbg, [
'rm', '-rf',
"%s/%s" % (SR_PATH_PREFIX, get_sr_uuid_by_uri(dbg, uri))
])
except Exception as e:
log.error(
"%s: xcpng.sr.SR.detach: Failed to detach SR - sr_uuid: %s" %
(dbg, get_sr_uuid_by_uri(dbg, uri)))
raise Exception(e)
def destroy(self, dbg, uri):
log.debug("%s: xcpng.sr.SR.destroy: uri: %s" % (dbg, uri))
try:
self.MetadataHandler.destroy(dbg, uri)
self.SROpsHendler.destroy(dbg, uri)
call(dbg, [
'rm', '-rf',
"%s/%s" % (SR_PATH_PREFIX, get_sr_uuid_by_uri(dbg, uri))
])
except Exception as e:
log.error(
"%s: xcpng.sr.SR.destroy: Failed to destroy SR - sr_uuid: %s" %
(dbg, get_sr_uuid_by_uri(dbg, uri)))
raise Exception(e)
def map_vol(self, dbg, uri, chained=False):
if chained is False:
log.debug(
"%s: xcpng.librbd.datapath.QdiskDatapath.map_vol: uri: %s" %
(dbg, uri))
nbd_dev = self._find_unused_nbd_device(dbg)
call(dbg, [
'/usr/lib64/qemu-dp-xcpng/bin/qemu-nbd', '-c', nbd_dev, '-f',
'raw',
self.gen_vol_uri(dbg, uri)
])
volume_meta = {'nbd_dev': nbd_dev}
self.MetadataHandler.update_vdi_meta(dbg, uri, volume_meta)
self.blkdev = nbd_dev
super(DatapathOperations, self).map_vol(dbg, uri, chained=False)
def _commit_offline(self, dbg, sr, child, parent):
datapath = get_vdi_datapath_by_uri(dbg, sr)
self.Datapathes[datapath].DatapathOpsHandler.map_vol(dbg, child, chained=None)
self.Datapathes[datapath].DatapathOpsHandler.map_vol(dbg, parent, chained=None)
call(dbg, ['/usr/lib64/qemu-dp/bin/qemu-img',
'commit',
'-t', 'none'
'-b', self.Datapathes[datapath].DatapathOpsHandler.gen_vol_uri(dbg, parent),
'-d',
self.Datapathes[datapath].DatapathOpsHandler.gen_vol_uri(dbg, child)])
self.Datapathes[datapath].DatapathOpsHandler.unmap_vol(dbg, child, chained=None)
self.Datapathes[datapath].DatapathOpsHandler.unmap_vol(dbg, parent, chained=None)
def zvol_get(dbg, image_name, property):
retval = call(dbg, ['zfs', 'get', property, '-Hp', image_name])
regex = re.compile('(.*)\s+(\w+)\s+(\d+)\s+(.*)')
result = regex.match(retval)
value = result.group(3)
log.debug("%s: zfs_utils.zvol_get: image_name: %s property: %s value: %s" % (dbg, image_name, property, value))
return value
def zvol_list(dbg, pool_name):
log.debug("%s: zfs_utils.zvol_list: pool_name: %s " % (dbg, pool_name))
zvols = []
regex = re.compile('.*/(\w+-.*)\s+(\d+)\s+(\d+)\s+(\d+)\s+-')
for line in call(dbg, ['zfs', 'list', '-Hpr', pool_name]).split('\n'):
result = regex.match(line)
if result:
zvols.append(result.group(1))
return zvols
def pool_list(dbg, imported=False):
log.debug("%s: zfs_utils.pool_list: imported: %s" % (dbg, imported))
pools = []
if imported is False:
regex = re.compile('\s+pool:\s+(.*)')
for line in call(dbg, ['zpool', 'import']).split('\n'):
result = regex.match(line)
if result:
pools.append(result.group(1))
return pools
else:
return pools
def sr_import(self, dbg, uri, configuration):
log.debug(
"%s: xcpng.libsbd.sr.SROperations.sr_import: uri: %s configuration %s"
% (dbg, uri, configuration))
if 'bindnetaddr' not in configuration:
raise Exception(
'Failed to connect to Sheepdog cluster. Parameter \'bindnetaddr\' is not specified'
)
elif 'mcastaddr' not in configuration:
raise Exception(
'Failed to connect to Sheepdog cluster. Parameter \'mcastaddr\' is not specified'
)
elif 'mcastport' not in configuration:
raise Exception(
'Failed to connect to Sheepdog cluster. Parameter \'mcastport\' is not specified'
)
sr_uuid = get_sr_uuid_by_uri(dbg, uri)
create_chroot(dbg, sr_uuid)
set_chroot(dbg, sr_uuid)
write_corosync_conf(
dbg, sr_uuid,
gen_corosync_conf(dbg, configuration['bindnetaddr'],
configuration['mcastaddr'],
configuration['mcastport']))
start_sheepdog_gateway(dbg, get_sheep_port(dbg, sr_uuid), sr_uuid)
mkdir_p("%s/%s" % (SR_PATH_PREFIX, get_sr_uuid_by_uri(dbg, uri)))
call(dbg, [
'ln', '-s',
"%s/%s/var/lib/sheepdog/sock" %
(CHROOT_BASE, get_sr_uuid_by_uri(dbg, uri)),
"%s/%s/sock" % (SR_PATH_PREFIX, get_sr_uuid_by_uri(dbg, uri))
])
def pool_create(dbg, pool_name, vdevs, mountpoint=None):
log.debug("%s: zfs_utils.pool_create: pool_name: %s vdevs: %s mountpoint: %s" % (dbg, pool_name, vdevs, mountpoint))
if mountpoint is not None:
call(dbg, ['zpool', 'create', '-m', mountpoint, pool_name, vdevs])
else:
call(dbg, ['zpool', 'create', '-m', 'legacy', pool_name, vdevs])
def pool_export(dbg, pool_name):
log.debug("%s: zfs_utils.pool_export: pool_name: %s" % (dbg, pool_name))
call(dbg, ['zfs', 'set', 'mountpoint=legacy', pool_name])
call(dbg, ['zpool', 'export', pool_name])
def zvol_rename(dbg, image_name, new_image_name):
log.debug("%s: zfs_utils.zvol_rename: image_name: %s new_image_name: %s" % (dbg, image_name, new_image_name))
call(dbg, ['zfs', 'rename', image_name, new_image_name])
def zvol_set(dbg, image_name, property, value):
log.debug("%s: zfs_utils.zvol_set: image_name: %s property: %s value: %s" % (dbg, image_name, property, value))
call(dbg, ['zfs', 'set', '%s=%s' % (property, value), image_name])
def zvol_destroy(dbg, image_name):
log.debug("%s: zfs_utils.zvol_destroy: image_name %s" % (dbg, image_name))
call(dbg, ['zfs', 'destroy', image_name])
def zvol_create(dbg, image_name, vsize, volmode=VOLMODE, volblocksize=VOLBLOCKSIZE):
log.debug("%s: zfs_utils.zvol_create: image_name %s vsize: %s volmode: %s volblocksize=%s"
% (dbg, image_name, vsize, volmode, volblocksize))
call(dbg, ['zfs', 'create', '-o', "volmode=%s" % volmode, '-o', "volblocksize=%s" % volblocksize, '-V', str(vsize),
image_name])
def zfs_umount(dbg, fs_name):
log.debug("%s: zfs_utils.zfs_umount: fs_name: %s" % (dbg, fs_name))
call(dbg, ['zfs', 'umount', fs_name])
def pool_set(dbg, pool_name, property, value):
log.debug("%s: zfs_utils.pool_set: pool_name: %s property: $s value: %s" % (dbg, pool_name, value))
call(dbg, ['zpool', 'set', '%s=%s' % (property, value), pool_name])
