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])