def clone(cls, dbg, sr, key, mode):
log.debug("%s: librbd.Volume.clone: SR: %s Key: %s Mode: %s"
% (dbg, sr, key, mode))
orig_uri = "%s/%s" % (sr, key)
try:
orig_meta = meta.RBDMetadataHandler.load(dbg, orig_uri)
except Exception:
raise Volume_does_not_exist(key)
if meta.SNAPSHOT_OF_TAG in orig_meta:
base_uri = "%s/%s" % (sr, orig_meta[meta.SNAPSHOT_OF_TAG])
try:
base_meta = meta.RBDMetadataHandler.load(dbg, base_uri)
except Exception:
raise Volume_does_not_exist(key)
else:
base_meta = copy.deepcopy(orig_meta)
if meta.ACTIVE_ON_TAG in base_meta:
current_host = get_current_host_uuid()
if base_meta[meta.ACTIVE_ON_TAG] != current_host:
log.debug("%s: librbd.Volume.clone: SR: %s Key: %s Can not snapshot on %s as VDI already active on %s"
% (dbg, sr, base_meta[meta.UUID_TAG],
current_host, base_meta[meta.ACTIVE_ON_TAG]))
raise Activated_on_another_host(base_meta[meta.ACTIVE_ON_TAG])
return cls._clone(dbg, sr, key, mode, base_meta)
def stat(cls, dbg, sr, key):
log.debug("%s: librbd.Volume.stat: SR: %s Key: %s"
% (dbg, sr, key))
ceph_cluster = ceph_utils.connect(dbg, sr)
uri = "%s/%s" % (sr, key)
image_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, uri)],
key)
try:
image_meta = meta.RBDMetadataHandler.load(dbg, uri)
image_meta[meta.PHYSICAL_UTILISATION_TAG] = rbd_utils.getPhysicalUtilisation(dbg,
ceph_cluster,
image_name)
#meta.RBDMetadataHandler.update(dbg, uri, image_meta)
log.debug("%s: librbd.Volume.stat: SR: %s Key: %s Metadata: %s"
% (dbg, sr, key, image_meta))
return cls._stat(dbg, sr, key, image_meta)
except Exception:
raise Volume_does_not_exist(key)
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
def _load(dbg, uri, use_image_prefix=True):
log.debug("%s: meta.RBDMetadataHandler._load: uri: %s" % (dbg, uri))
ceph_cluster = ceph_utils.connect(dbg, uri)
if use_image_prefix:
image_name = "%s%s/%s%s" % (
utils.RBDPOOL_PREFIX, utils.get_sr_uuid_by_uri(
dbg, uri), utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(
dbg, uri)], utils.get_vdi_uuid_by_uri(dbg, uri))
else:
image_name = "%s%s/%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, uri),
utils.get_vdi_uuid_by_uri(dbg, uri))
image_meta = {}
try:
image_meta_list = rbd_utils.retrieveImageMetadata(
dbg, ceph_cluster, image_name)
for tag, value in image_meta_list:
image_meta[tag] = TAG_TYPES[tag](value)
log.debug(
"%s: meta.RBDMetadataHandler._load: Image: %s Metadata: %s " %
(dbg, image_name, image_meta))
except Exception:
raise Volume_does_not_exist(uri)
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
return image_meta
def _resize(cls, dbg, sr, key, new_size, image_meta):
log.debug("%s: librbd.QCOW2Volume._resize: SR: %s Key: %s New_size: %s"
% (dbg, sr, key, new_size))
# TODO: Implement overhead calculation for QCOW2 format
new_size = utils.validate_and_round_vhd_size(new_size)
new_rbd_size = utils.fullSizeVHD(new_size)
ceph_cluster = ceph_utils.connect(dbg, sr)
uri = "%s/%s" % (sr, key)
image_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, uri)],
key)
try:
rbd_utils.resize(dbg, ceph_cluster, image_name, new_rbd_size)
except Exception:
raise Volume_does_not_exist(key)
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
#nbd_device = call(dbg, ["/usr/bin/rbd-nbd",
# "map",
# image_name]).rstrip('\n')
call(dbg, ["/usr/lib64/qemu-dp/bin/qemu-img",
"resize",
"rbd:%s" % image_name,
str(new_size)])
def _create(cls, dbg, sr, name, description, size, sharable, image_meta):
log.debug("%s: librbd.RAWVolume.create: SR: %s Name: %s Description: %s Size: %s"
% (dbg, sr, name, description, size))
image_meta[meta.TYPE_TAG] = utils.get_vdi_type_by_uri(dbg, image_meta[meta.URI_TAG][0])
ceph_cluster = ceph_utils.connect(dbg, sr)
image_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[image_meta[meta.TYPE_TAG]],
image_meta[meta.UUID_TAG])
try:
rbd_utils.create(dbg, ceph_cluster, image_name, image_meta[meta.VIRTUAL_SIZE_TAG])
meta.RBDMetadataHandler.update(dbg, image_meta[meta.URI_TAG][0], image_meta)
except Exception:
try:
rbd_utils.remove(dbg, ceph_cluster, image_name)
except Exception:
pass
finally:
raise Volume_does_not_exist(image_meta[meta.UUID_TAG])
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
return image_meta
def set(cls, dbg, sr, key, k, v):
log.debug("%s: librbd.Volume.set: SR: %s Key: %s Custom_key: %s Value: %s"
% (dbg, sr, key, k, v))
uri = "%s/%s" % (sr, key)
try:
image_meta = meta.RBDMetadataHandler.load(dbg, uri)
image_meta['keys'][k] = v
meta.RBDMetadataHandler.update(dbg, uri, image_meta)
cls._set(dbg, sr, key, k, v, image_meta)
except Exception:
raise Volume_does_not_exist(key)
def unset(cls, dbg, sr, key, k):
log.debug("%s: librbd.Volume.unset: SR: %s Key: %s Custom_key: %s"
% (dbg, sr, key, k))
uri = "%s/%s" % (sr, key)
try:
image_meta = meta.RBDMetadataHandler.load(dbg, uri)
image_meta['keys'].pop(k, None)
meta.RBDMetadataHandler.update(dbg, uri, image_meta)
cls._unset(dbg, sr, key, k, image_meta)
except Exception:
raise Volume_does_not_exist(key)
def ls(self, dbg, uri):
log.debug("%s: SR.ls: uri: %s" % (dbg, uri))
results = []
key = ''
ceph_cluster = ceph_utils.connect(dbg, uri)
try:
rbds = rbd_utils.list(dbg, ceph_cluster,
utils.get_pool_name_by_uri(dbg, uri))
for rbd in rbds:
if rbd.startswith(utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(
dbg, uri)]):
log.debug("%s: SR.ls: SR: %s rbd: %s" % (dbg, uri, rbd))
key = utils.get_vdi_uuid_by_name(dbg, rbd)
log.debug("%s: SR.ls: SR: %s Image: %s" % (dbg, uri, key))
image_meta = meta.RBDMetadataHandler.load(
dbg, "%s/%s" % (uri, key))
#log.debug("%s: SR.ls: SR: %s image: %s Metadata: %s" % (dbg, uri, rbd, image_meta))
results.append({
meta.UUID_TAG:
image_meta[meta.UUID_TAG],
meta.KEY_TAG:
image_meta[meta.KEY_TAG],
meta.NAME_TAG:
image_meta[meta.NAME_TAG],
meta.DESCRIPTION_TAG:
image_meta[meta.DESCRIPTION_TAG],
meta.READ_WRITE_TAG:
image_meta[meta.READ_WRITE_TAG],
meta.VIRTUAL_SIZE_TAG:
image_meta[meta.VIRTUAL_SIZE_TAG],
meta.PHYSICAL_UTILISATION_TAG:
image_meta[meta.PHYSICAL_UTILISATION_TAG],
meta.URI_TAG:
image_meta[meta.URI_TAG],
meta.CUSTOM_KEYS_TAG:
image_meta[meta.CUSTOM_KEYS_TAG],
meta.SHARABLE_TAG:
image_meta[meta.SHARABLE_TAG]
})
#log.debug("%s: SR.ls: Result: %s" % (dbg, results))
return results
except Exception:
raise Volume_does_not_exist(key)
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
def open(self, dbg):
log.debug(
"%s: qemudisk.Qemudisk.open: vdi_uuid %s pid %d qmp_sock %s" %
(dbg, self.vdi_uuid, self.pid, self.qmp_sock))
args = {
'driver': self.vdi_type,
'cache': {
'direct': True,
'no-flush': True
},
#'discard': 'unmap',
'file': {
'driver':
'rbd',
'pool':
"%s%s" % (utils.RBDPOOL_PREFIX, self.sr_uuid),
'image':
"%s%s" % (utils.VDI_PREFIXES[self.vdi_type], self.vdi_uuid)
},
#'node-name': RBD_NODE_NAME},
"node-name": ROOT_NODE_NAME
}
log.debug("%s: qemudisk.Qemudisk.open: args: %s" % (dbg, args))
_qmp_ = qmp.QEMUMonitorProtocol(self.qmp_sock)
_qmp_.connect()
try:
_qmp_.command("blockdev-add", **args)
# Start an NBD server exposing this blockdev
_qmp_.command("nbd-server-start",
addr={
'type': 'unix',
'data': {
'path': self.nbd_sock
}
})
_qmp_.command("nbd-server-add",
device=ROOT_NODE_NAME,
writable=True)
log.debug("%s: qemudisk.Qemudisk.open: RBD Image opened: %s" %
(dbg, args))
except Exception:
raise Volume_does_not_exist(self.vdi_uuid)
finally:
_qmp_.close()
def set_name(cls, dbg, sr, key, new_name):
log.debug("%s: librbd.Volume.set_name: SR: %s Key: %s New_name: %s"
% (dbg, sr, key, new_name))
uri = "%s/%s" % (sr, key)
image_meta = {
'name': new_name,
}
try:
meta.RBDMetadataHandler.update(dbg, uri, image_meta)
cls._set_name(dbg, sr, key, new_name, image_meta)
except Exception:
raise Volume_does_not_exist(key)
def resize(cls, dbg, sr, key, new_size):
log.debug("%s: librbd.Volume.resize: SR: %s Key: %s New_size: %s"
% (dbg, sr, key, new_size))
image_meta = {
'virtual_size': new_size,
}
uri = "%s/%s" % (sr, key)
try:
cls._resize(dbg, sr, key, new_size, image_meta)
meta.RBDMetadataHandler.update(dbg, uri, image_meta)
except Exception:
raise Volume_does_not_exist(key)
def resume(self, dbg):
log.debug(
"%s: qemudisk.Qemudisk.resume: vdi_uuid %s pid %d qmp_sock %s" %
(dbg, self.vdi_uuid, self.pid, self.qmp_sock))
_qmp_ = qmp.QEMUMonitorProtocol(self.qmp_sock)
_qmp_.connect()
try:
# Resume IO on blockdev
args = {"device": ROOT_NODE_NAME}
_qmp_.command("x-blockdev-resume", **args)
except Exception:
raise Volume_does_not_exist(self.vdi_uuid)
finally:
_qmp_.close()
def close(self, dbg):
log.debug(
"%s: 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)
_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()
call(dbg, ["/usr/bin/xenstore-write", line, "5"])
os.unlink(path)
except:
log.debug(
"%s: qemudisk.Qemudisk.close: There was no xenstore setup"
% dbg)
elif platform.linux_distribution()[1] == '7.6.0':
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:
log.debug(
"%s: qemudisk.Qemudisk.close: There was no xenstore setup"
% dbg)
try:
# Stop the NBD server
_qmp_.command("nbd-server-stop")
# Remove the block device
args = {"node-name": ROOT_NODE_NAME}
_qmp_.command("blockdev-del", **args)
except Exception:
raise Volume_does_not_exist(self.vdi_uuid)
finally:
_qmp_.close()
def _resize(cls, dbg, sr, key, new_size, image_meta):
log.debug("%s: librbd.RAWVolume._resize: SR: %s Key: %s New_size: %s"
% (dbg, sr, key, new_size))
ceph_cluster = ceph_utils.connect(dbg, sr)
uri = "%s/%s" % (sr, key)
image_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, uri)],
key)
try:
rbd_utils.resize(dbg, ceph_cluster, image_name, new_size)
except Exception:
raise Volume_does_not_exist(key)
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
def set_name(self, dbg, uri, new_name):
log.debug("%s: SR.set_name: SR: %s New_name: %s" %
(dbg, uri, new_name))
ceph_cluster = ceph_utils.connect(dbg, uri)
pool_meta = {
meta.NAME_TAG: new_name,
}
try:
meta.RBDMetadataHandler.update(
dbg, '%s/%s' % (uri, utils.SR_METADATA_IMAGE_NAME), pool_meta,
False)
except Exception:
raise Volume_does_not_exist(uri)
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
def destroy(cls, dbg, sr, key):
log.debug("%s: Volume.destroy: SR: %s Key: %s"
% (dbg, sr, key))
ceph_cluster = ceph_utils.connect(dbg, sr)
uri = "%s/%s" % (sr, key)
image_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, uri)],
key)
try:
rbd_utils.remove(dbg, ceph_cluster, image_name)
cls._destroy(dbg, sr, key)
except Exception:
raise Volume_does_not_exist(key)
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
def _update(dbg, uri, image_meta, use_image_prefix=True):
log.debug(
"%s: meta.RBDMetadataHandler._update_meta: uri: %s image_meta: %s"
% (dbg, uri, image_meta))
ceph_cluster = ceph_utils.connect(dbg, uri)
if use_image_prefix:
image_name = "%s%s/%s%s" % (
utils.RBDPOOL_PREFIX, utils.get_sr_uuid_by_uri(
dbg, uri), utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(
dbg, uri)], utils.get_vdi_uuid_by_uri(dbg, uri))
else:
image_name = "%s%s/%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, uri),
utils.get_vdi_uuid_by_uri(dbg, uri))
try:
rbd_utils.updateImageMetadata(dbg, ceph_cluster, image_name,
image_meta)
except Exception:
raise Volume_does_not_exist(uri)
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
def _clone(cls, dbg, sr, key, mode, base_meta):
log.debug("%s: librbd.QCOW2Volume.clone: SR: %s Key: %s Mode: %s"
% (dbg, sr, key, mode))
# TODO: Implement overhead calculation for QCOW2 format
size = utils.validate_and_round_vhd_size(base_meta[meta.VIRTUAL_SIZE_TAG])
rbd_size = utils.fullSizeVHD(size)
ceph_cluster = ceph_utils.connect(dbg, sr)
clone_uuid = str(uuid.uuid4())
clone_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, sr)],
clone_uuid)
try:
if base_meta[meta.KEY_TAG] == key:
base_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, sr)],
key)
new_base_uuid = str(uuid.uuid4())
new_base_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, sr)],
new_base_uuid)
rbd_utils.rename(dbg, ceph_cluster, base_name, new_base_name)
rbd_utils.create(dbg, ceph_cluster, base_name, rbd_size)
rbd_utils.create(dbg, ceph_cluster, clone_name, rbd_size)
base_nbd_device = call(dbg, ["/usr/bin/rbd-nbd",
"map",
base_name]).rstrip('\n')
clone_nbd_device = call(dbg, ["/usr/bin/rbd-nbd",
"map",
clone_name]).rstrip('\n')
call(dbg, ["/usr/lib64/qemu-dp/bin/qemu-img",
"create",
"-f", base_meta[meta.TYPE_TAG],
"-b", "rbd:%s" % new_base_name,
base_nbd_device])
call(dbg, ["/usr/lib64/qemu-dp/bin/qemu-img",
"create",
"-f", base_meta[meta.TYPE_TAG],
"-b", "rbd:%s" % new_base_name,
clone_nbd_device])
call(dbg, ["/usr/bin/rbd-nbd",
"unmap",
clone_nbd_device])
call(dbg, ["/usr/bin/rbd-nbd",
"unmap",
base_nbd_device])
new_base_meta = copy.deepcopy(base_meta)
new_base_meta[meta.NAME_TAG] = "(base) %s" % new_base_meta[meta.NAME_TAG]
new_base_meta[meta.KEY_TAG] = new_base_uuid
new_base_meta[meta.UUID_TAG] = new_base_uuid
new_base_meta[meta.URI_TAG] = ["%s/%s" % (sr, new_base_uuid)]
new_base_meta[meta.READ_WRITE_TAG] = False
if meta.ACTIVE_ON_TAG in new_base_meta:
Datapath.snapshot(dbg,new_base_meta[meta.URI_TAG][0], base_meta[meta.URI_TAG][0], 0)
if meta.ACTIVE_ON_TAG in new_base_meta:
new_base_meta[meta.ACTIVE_ON_TAG] = None
new_base_meta[meta.QEMU_PID_TAG] = None
new_base_meta[meta.QEMU_NBD_SOCK_TAG] = None
new_base_meta[meta.QEMU_QMP_SOCK_TAG] = None
new_base_meta[meta.QEMU_QMP_LOG_TAG] = None
meta.RBDMetadataHandler.update(dbg, new_base_meta[meta.URI_TAG][0], new_base_meta)
meta.RBDMetadataHandler.update(dbg, base_meta[meta.URI_TAG][0], base_meta)
else:
base_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, sr)],
base_meta[meta.UUID_TAG])
rbd_utils.create(dbg, ceph_cluster, clone_name, rbd_size)
clone_nbd_device = call(dbg, ["/usr/bin/rbd-nbd",
"map",
clone_name]).rstrip('\n')
call(dbg, ["/usr/lib64/qemu-dp/bin/qemu-img",
"create",
"-f", base_meta[meta.TYPE_TAG],
"-b", "rbd:%s" % base_name,
clone_nbd_device])
call(dbg, ["/usr/bin/rbd-nbd",
"unmap",
clone_nbd_device])
clone_meta = copy.deepcopy(base_meta)
clone_meta[meta.KEY_TAG] = clone_uuid
clone_meta[meta.UUID_TAG] = clone_uuid
clone_meta[meta.URI_TAG] = ["%s/%s" % (sr, clone_uuid)]
if meta.ACTIVE_ON_TAG in clone_meta:
clone_meta.pop(meta.ACTIVE_ON_TAG, None)
clone_meta.pop(meta.QEMU_PID_TAG, None)
clone_meta.pop(meta.QEMU_NBD_SOCK_TAG, None)
clone_meta.pop(meta.QEMU_QMP_SOCK_TAG, None)
clone_meta.pop(meta.QEMU_QMP_LOG_TAG, None)
if mode is 'snapshot':
clone_meta[meta.READ_WRITE_TAG] = False
clone_meta[meta.SNAPSHOT_OF_TAG] = new_base_meta[meta.UUID_TAG]
elif mode is 'clone':
clone_meta[meta.READ_WRITE_TAG] = True
meta.RBDMetadataHandler.update(dbg, clone_meta[meta.URI_TAG][0], clone_meta)
return clone_meta
except Exception:
raise Volume_does_not_exist(key)
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
def _clone(cls, dbg, sr, key, mode, base_meta):
log.debug("%s: librbd.RAWVolume.clone: SR: %s Key: %s Mode: %s"
% (dbg, sr, key, mode))
ceph_cluster = ceph_utils.connect(dbg, sr)
clone_uuid = str(uuid.uuid4())
clone_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, sr)],
clone_uuid)
try:
if base_meta[meta.KEY_TAG] == key:
base_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, sr)],
key)
new_base_uuid = str(uuid.uuid4())
new_base_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, sr)],
new_base_uuid)
if meta.ACTIVE_ON_TAG in base_meta:
Datapath.suspend(dbg,base_meta[meta.URI_TAG][0], 0)
rbd_utils.rename(dbg, ceph_cluster, base_name, new_base_name)
rbd_utils.snapshot(dbg, ceph_cluster, new_base_name, 'base')
rbd_utils.clone(dbg, ceph_cluster, new_base_name, 'base', base_name)
rbd_utils.clone(dbg, ceph_cluster, new_base_name, 'base', clone_name)
if meta.ACTIVE_ON_TAG in base_meta:
Datapath.resume(dbg,base_meta[meta.URI_TAG][0], 0)
new_base_meta = copy.deepcopy(base_meta)
new_base_meta[meta.NAME_TAG] = "(base) %s" % new_base_meta[meta.NAME_TAG]
new_base_meta[meta.KEY_TAG] = new_base_uuid
new_base_meta[meta.UUID_TAG] = new_base_uuid
new_base_meta[meta.URI_TAG] = ["%s/%s" % (sr, new_base_uuid)]
new_base_meta[meta.READ_WRITE_TAG] = False
if meta.ACTIVE_ON_TAG in new_base_meta:
new_base_meta[meta.ACTIVE_ON_TAG] = None
new_base_meta[meta.QEMU_PID_TAG] = None
new_base_meta[meta.QEMU_NBD_SOCK_TAG] = None
new_base_meta[meta.QEMU_QMP_SOCK_TAG] = None
new_base_meta[meta.QEMU_QMP_LOG_TAG] = None
meta.RBDMetadataHandler.update(dbg, new_base_meta[meta.URI_TAG][0], new_base_meta)
meta.RBDMetadataHandler.update(dbg, base_meta[meta.URI_TAG][0], base_meta)
else:
base_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[utils.get_vdi_type_by_uri(dbg, sr)],
base_meta[meta.UUID_TAG])
rbd_utils.clone(dbg, ceph_cluster, base_name, 'base', clone_name)
clone_meta = copy.deepcopy(base_meta)
clone_meta[meta.KEY_TAG] = clone_uuid
clone_meta[meta.UUID_TAG] = clone_uuid
clone_meta[meta.URI_TAG] = ["%s/%s" % (sr, clone_uuid)]
if meta.ACTIVE_ON_TAG in clone_meta:
clone_meta[meta.ACTIVE_ON_TAG] = None
clone_meta[meta.QEMU_PID_TAG] = None
clone_meta[meta.QEMU_NBD_SOCK_TAG] = None
clone_meta[meta.QEMU_QMP_SOCK_TAG] = None
clone_meta[meta.QEMU_QMP_LOG_TAG] = None
if mode is 'snapshot':
clone_meta[meta.READ_WRITE_TAG] = False
clone_meta[meta.SNAPSHOT_OF_TAG] = new_base_meta[meta.UUID_TAG]
elif mode is 'clone':
clone_meta[meta.READ_WRITE_TAG] = True
meta.RBDMetadataHandler.update(dbg, clone_meta[meta.URI_TAG][0], clone_meta)
return clone_meta
except Exception:
raise Volume_does_not_exist(key)
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
def _create(cls, dbg, sr, name, description, size, sharable, image_meta):
log.debug("%s: librbd.QCOW2Volume._create: SR: %s Name: %s Description: %s Size: %s"
% (dbg, sr, name, description, size))
image_meta[meta.TYPE_TAG] = utils.get_vdi_type_by_uri(dbg, image_meta[meta.URI_TAG][0])
ceph_cluster = ceph_utils.connect(dbg, sr)
image_name = "%s%s/%s%s" % (utils.RBDPOOL_PREFIX,
utils.get_sr_uuid_by_uri(dbg, sr),
utils.VDI_PREFIXES[image_meta[meta.TYPE_TAG]],
image_meta[meta.UUID_TAG])
# TODO: Implement overhead calculation for QCOW2 format
size = utils.validate_and_round_vhd_size(size)
rbd_size = utils.fullSizeVHD(size)
try:
rbd_utils.create(dbg, ceph_cluster, image_name, rbd_size)
meta.RBDMetadataHandler.update(dbg, image_meta[meta.URI_TAG][0], image_meta)
except Exception:
try:
rbd_utils.remove(dbg, ceph_cluster, image_name)
except Exception:
pass
finally:
raise Volume_does_not_exist(image_meta[meta.UUID_TAG])
finally:
ceph_utils.disconnect(dbg, ceph_cluster)
#Datapath.attach(dbg, image_meta[meta.URI_TAG][0], 0)
#Datapath.activate(dbg, image_meta[meta.URI_TAG][0], 0, 'raw')
#nbd_device=call(dbg, ["/opt/xensource/libexec/nbd_client_manager.py",
# "connect",
# "--path",
# utils.VAR_RUN_PREFIX + "/qemu-nbd.{}".format(image_meta[meta.UUID_TAG]),
# "--exportname",
# "qemu_node"])
nbd_device = call(dbg, ["/usr/bin/rbd-nbd",
"map",
image_name]).rstrip('\n')
call(dbg, ["/usr/lib64/qemu-dp/bin/qemu-img",
"create",
"-f", image_meta[meta.TYPE_TAG],
nbd_device,
str(size)])
call(dbg, ["/usr/bin/rbd-nbd",
"unmap",
nbd_device])
#call(dbg, ["/opt/xensource/libexec/nbd_client_manager.py",
# "disconnect",
# "--device",
# nbd_device])
#Datapath.deactivate(dbg, image_meta[meta.URI_TAG][0], 0)
#Datapath.detach(dbg, image_meta[meta.URI_TAG][0], 0)
return image_meta