def create_empty_volume(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = AgentRsp()
install_abs_path = translate_absolute_path_from_install_path(cmd.installPath)
if cmd.backingFile:
qcow2_options = self.calc_qcow2_option(self, cmd.qcow2Options, True, cmd.provisioning)
backing_abs_path = translate_absolute_path_from_install_path(cmd.backingFile)
with lvm.RecursiveOperateLv(backing_abs_path, shared=True):
virtual_size = linux.qcow2_virtualsize(backing_abs_path)
if not lvm.lv_exists(install_abs_path):
lvm.create_lv_from_cmd(install_abs_path, virtual_size, cmd,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.OperateLv(install_abs_path, shared=False, delete_when_exception=True):
linux.qcow2_create_with_backing_file_and_option(backing_abs_path, install_abs_path, qcow2_options)
elif not lvm.lv_exists(install_abs_path):
qcow2_options = self.calc_qcow2_option(self, cmd.qcow2Options, False, cmd.provisioning)
lvm.create_lv_from_cmd(install_abs_path, cmd.size, cmd,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.OperateLv(install_abs_path, shared=False, delete_when_exception=True):
linux.qcow2_create_with_option(install_abs_path, cmd.size, qcow2_options)
linux.qcow2_fill(0, 1048576, install_abs_path)
logger.debug('successfully create empty volume[uuid:%s, size:%s] at %s' % (cmd.volumeUuid, cmd.size, cmd.installPath))
rsp.totalCapacity, rsp.availableCapacity = lvm.get_vg_size(cmd.vgUuid)
return jsonobject.dumps(rsp)
def migrate_volumes(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = AgentRsp()
for struct in cmd.migrateVolumeStructs:
target_abs_path = translate_absolute_path_from_install_path(struct.targetInstallPath)
current_abs_path = translate_absolute_path_from_install_path(struct.currentInstallPath)
with lvm.OperateLv(current_abs_path, shared=True):
virtual_size = lvm.get_lv_size(current_abs_path)
if lvm.lv_exists(target_abs_path):
target_ps_uuid = get_primary_storage_uuid_from_install_path(struct.targetInstallPath)
raise Exception("found %s already exists on ps %s" %
(target_abs_path, target_ps_uuid))
lvm.create_lv_from_absolute_path(target_abs_path, virtual_size,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
lvm.active_lv(target_abs_path, lvm.LvmlockdLockType.SHARE)
try:
for struct in cmd.migrateVolumeStructs:
target_abs_path = translate_absolute_path_from_install_path(struct.targetInstallPath)
current_abs_path = translate_absolute_path_from_install_path(struct.currentInstallPath)
with lvm.OperateLv(current_abs_path, shared=True):
bash.bash_errorout("cp %s %s" % (current_abs_path, target_abs_path))
for struct in cmd.migrateVolumeStructs:
target_abs_path = translate_absolute_path_from_install_path(struct.targetInstallPath)
current_abs_path = translate_absolute_path_from_install_path(struct.currentInstallPath)
with lvm.RecursiveOperateLv(current_abs_path, shared=True):
previous_ps_uuid = get_primary_storage_uuid_from_install_path(struct.currentInstallPath)
target_ps_uuid = get_primary_storage_uuid_from_install_path(struct.targetInstallPath)
current_backing_file = linux.qcow2_get_backing_file(current_abs_path) # type: str
target_backing_file = current_backing_file.replace(previous_ps_uuid, target_ps_uuid)
if current_backing_file is not None and current_backing_file != "":
lvm.do_active_lv(target_backing_file, lvm.LvmlockdLockType.SHARE, False)
logger.debug("rebase %s to %s" % (target_abs_path, target_backing_file))
linux.qcow2_rebase_no_check(target_backing_file, target_abs_path)
if struct.compareQcow2:
bash.bash_errorout("time qemu-img compare %s %s" % (current_abs_path, target_abs_path))
except Exception as e:
for struct in cmd.migrateVolumeStructs:
target_abs_path = translate_absolute_path_from_install_path(struct.targetInstallPath)
if struct.currentInstallPath == struct.targetInstallPath:
logger.debug("current install path %s equals target %s, skip to delete" %
(struct.currentInstallPath, struct.targetInstallPath))
else:
logger.debug("error happened, delete lv %s" % target_abs_path)
lvm.delete_lv(target_abs_path, False)
raise e
finally:
for struct in cmd.migrateVolumeStructs:
target_abs_path = translate_absolute_path_from_install_path(struct.targetInstallPath)
lvm.deactive_lv(target_abs_path)
rsp.totalCapacity, rsp.availableCapacity = lvm.get_vg_size(cmd.vgUuid)
return jsonobject.dumps(rsp)
def do_convert(args):
volume_abs_path = args[1]
raw_volume_abs_path = volume_abs_path + RAW_SUFFIX
qcow2_volume_abs_path = volume_abs_path + QCOW2_SUFFIX
check(volume_abs_path, raw_volume_abs_path)
volume_size = lvm.get_lv_size(volume_abs_path)
lvm.create_lv_from_absolute_path(raw_volume_abs_path, volume_size)
with lvm.RecursiveOperateLv(volume_abs_path,
shared=False,
delete_when_exception=False):
with lvm.OperateLv(raw_volume_abs_path,
shared=False,
delete_when_exception=False):
lvm.add_lv_tag(volume_abs_path, START_TAG)
r, o, e = qcow2_convert_to_raw(volume_abs_path,
raw_volume_abs_path)
if r != 0:
logger.warn("convert failed: %s, removing tag and raw volume")
lvm.clean_lv_tag(volume_abs_path, START_TAG)
lvm.delete_lv(raw_volume_abs_path)
return
lvm.add_lv_tag(volume_abs_path, DONE_TAG)
lvm.clean_lv_tag(volume_abs_path, START_TAG)
lvm.lv_rename(volume_abs_path,
qcow2_volume_abs_path,
overwrite=False)
lvm.lv_rename(raw_volume_abs_path,
volume_abs_path,
overwrite=False)
def offline_merge_snapshots(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = OfflineMergeSnapshotRsp()
src_abs_path = translate_absolute_path_from_install_path(cmd.srcPath)
dst_abs_path = translate_absolute_path_from_install_path(cmd.destPath)
with lvm.RecursiveOperateLv(src_abs_path, shared=True):
virtual_size = linux.qcow2_virtualsize(src_abs_path)
if not lvm.lv_exists(dst_abs_path):
lvm.create_lv_from_absolute_path(
dst_abs_path, virtual_size,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.RecursiveOperateLv(dst_abs_path, shared=False):
if not cmd.fullRebase:
linux.qcow2_rebase(src_abs_path, dst_abs_path)
else:
tmp_lv = 'tmp_%s' % uuidhelper.uuid()
tmp_abs_path = os.path.join(os.path.dirname(dst_abs_path),
tmp_lv)
tmp_abs_path = os.path.join(os.path.dirname(dst_abs_path),
tmp_lv)
logger.debug("creating temp lv %s" % tmp_abs_path)
lvm.create_lv_from_absolute_path(
tmp_abs_path, virtual_size,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.OperateLv(tmp_abs_path,
shared=False,
delete_when_exception=True):
linux.create_template(dst_abs_path, tmp_abs_path)
lvm.lv_rename(tmp_abs_path,
dst_abs_path,
overwrite=True)
rsp.totalCapacity, rsp.availableCapacity = lvm.get_vg_size(cmd.vgUuid)
return jsonobject.dumps(rsp)
def revert_volume_from_snapshot(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = RevertVolumeFromSnapshotRsp()
snapshot_abs_path = translate_absolute_path_from_install_path(
cmd.snapshotInstallPath)
qcow2_options = self.calc_qcow2_option(self, cmd.qcow2Options, True,
cmd.provisioning)
new_volume_path = cmd.installPath
if new_volume_path is None or new_volume_path == "":
new_volume_path = "/dev/%s/%s" % (cmd.vgUuid, uuidhelper.uuid())
else:
new_volume_path = translate_absolute_path_from_install_path(
new_volume_path)
with lvm.RecursiveOperateLv(snapshot_abs_path, shared=True):
size = linux.qcow2_virtualsize(snapshot_abs_path)
lvm.create_lv_from_cmd(
new_volume_path, size, cmd,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.OperateLv(new_volume_path,
shared=False,
delete_when_exception=True):
linux.qcow2_clone_with_option(snapshot_abs_path,
new_volume_path, qcow2_options)
size = linux.qcow2_virtualsize(new_volume_path)
rsp.newVolumeInstallPath = new_volume_path
rsp.size = size
return jsonobject.dumps(rsp)
def create_root_volume(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = AgentRsp()
template_abs_path_cache = translate_absolute_path_from_install_path(
cmd.templatePathInCache)
install_abs_path = translate_absolute_path_from_install_path(
cmd.installPath)
qcow2_options = self.calc_qcow2_option(self, cmd.qcow2Options, True,
cmd.provisioning)
with lvm.RecursiveOperateLv(template_abs_path_cache,
shared=True,
skip_deactivate_tags=[IMAGE_TAG]):
virtual_size = linux.qcow2_virtualsize(template_abs_path_cache)
if not lvm.lv_exists(install_abs_path):
lvm.create_lv_from_cmd(
install_abs_path, virtual_size, cmd,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.OperateLv(install_abs_path,
shared=False,
delete_when_exception=True):
linux.qcow2_clone_with_option(template_abs_path_cache,
install_abs_path, qcow2_options)
rsp.totalCapacity, rsp.availableCapacity = lvm.get_vg_size(cmd.vgUuid)
return jsonobject.dumps(rsp)
def download_from_sftp(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = AgentRsp()
install_abs_path = translate_absolute_path_from_install_path(
cmd.primaryStorageInstallPath)
size = linux.sftp_get(cmd.hostname, cmd.sshKey,
cmd.backupStorageInstallPath, install_abs_path,
cmd.username, cmd.sshPort, True)
if not lvm.lv_exists(install_abs_path):
lvm.create_lv_from_absolute_path(
install_abs_path, size,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.OperateLv(install_abs_path,
shared=False,
delete_when_exception=True):
linux.scp_download(cmd.hostname, cmd.sshKey,
cmd.backupStorageInstallPath, install_abs_path,
cmd.username, cmd.sshPort)
logger.debug('successfully download %s/%s to %s' %
(cmd.hostname, cmd.backupStorageInstallPath,
cmd.primaryStorageInstallPath))
self.do_active_lv(cmd.primaryStorageInstallPath, cmd.lockType, False)
rsp.totalCapacity, rsp.availableCapacity = lvm.get_vg_size(cmd.vgUuid)
return jsonobject.dumps(rsp)
def create_template_from_volume(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = AgentRsp()
volume_abs_path = translate_absolute_path_from_install_path(
cmd.volumePath)
install_abs_path = translate_absolute_path_from_install_path(
cmd.installPath)
if cmd.sharedVolume:
lvm.do_active_lv(volume_abs_path, lvm.LvmlockdLockType.SHARE, True)
with lvm.RecursiveOperateLv(volume_abs_path,
shared=cmd.sharedVolume,
skip_deactivate_tag=IMAGE_TAG):
virtual_size = linux.qcow2_virtualsize(volume_abs_path)
if not lvm.lv_exists(install_abs_path):
lvm.create_lv_from_absolute_path(
install_abs_path, virtual_size,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.OperateLv(install_abs_path,
shared=False,
delete_when_exception=True):
linux.create_template(volume_abs_path, install_abs_path)
logger.debug(
'successfully created template[%s] from volume[%s]' %
(cmd.installPath, cmd.volumePath))
if cmd.compareQcow2 is True:
logger.debug("comparing qcow2 between %s and %s")
bash.bash_errorout("time qemu-img compare %s %s" %
(volume_abs_path, install_abs_path))
logger.debug("confirmed qcow2 %s and %s are identical" %
(volume_abs_path, install_abs_path))
rsp.totalCapacity, rsp.availableCapacity = lvm.get_vg_size(cmd.vgUuid)
return jsonobject.dumps(rsp)
def get_volume_size(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = GetVolumeSizeRsp()
install_abs_path = translate_absolute_path_from_install_path(cmd.installPath)
with lvm.OperateLv(install_abs_path, shared=True):
rsp.size = linux.qcow2_virtualsize(install_abs_path)
rsp.actualSize = lvm.get_lv_size(install_abs_path)
rsp.totalCapacity, rsp.availableCapacity = lvm.get_vg_size(cmd.vgUuid)
return jsonobject.dumps(rsp)
def convert_image_to_volume(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = AgentRsp()
install_abs_path = translate_absolute_path_from_install_path(cmd.primaryStorageInstallPath)
with lvm.OperateLv(install_abs_path, shared=False):
lvm.clean_lv_tag(install_abs_path, IMAGE_TAG)
lvm.add_lv_tag(install_abs_path, "%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
return jsonobject.dumps(rsp)
def do_download_from_sftp(self, cmd, install_abs_path):
if not lvm.lv_exists(install_abs_path):
size = linux.sftp_get(cmd.hostname, cmd.sshKey, cmd.backupStorageInstallPath, install_abs_path, cmd.username, cmd.sshPort, True)
lvm.create_lv_from_absolute_path(install_abs_path, size,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.OperateLv(install_abs_path, shared=False, delete_when_exception=True):
linux.scp_download(cmd.hostname, cmd.sshKey, cmd.backupStorageInstallPath, install_abs_path, cmd.username, cmd.sshPort, cmd.bandWidth)
logger.debug('successfully download %s/%s to %s' % (cmd.hostname, cmd.backupStorageInstallPath, cmd.primaryStorageInstallPath))
self.do_active_lv(cmd.primaryStorageInstallPath, cmd.lockType, False)
def upload_to_sftp(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = AgentRsp()
install_abs_path = translate_absolute_path_from_install_path(cmd.primaryStorageInstallPath)
def upload():
if not os.path.exists(cmd.primaryStorageInstallPath):
raise kvmagent.KvmError('cannot find %s' % cmd.primaryStorageInstallPath)
linux.scp_upload(cmd.hostname, cmd.sshKey, cmd.primaryStorageInstallPath, cmd.backupStorageInstallPath, cmd.username, cmd.sshPort)
with lvm.OperateLv(install_abs_path, shared=True):
upload()
return jsonobject.dumps(rsp)
def merge_snapshot(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = MergeSnapshotRsp()
snapshot_abs_path = translate_absolute_path_from_install_path(cmd.snapshotInstallPath)
workspace_abs_path = translate_absolute_path_from_install_path(cmd.workspaceInstallPath)
with lvm.RecursiveOperateLv(snapshot_abs_path, shared=True):
virtual_size = linux.qcow2_virtualsize(snapshot_abs_path)
if not lvm.lv_exists(workspace_abs_path):
lvm.create_lv_from_absolute_path(workspace_abs_path, virtual_size,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.OperateLv(workspace_abs_path, shared=False, delete_when_exception=True):
linux.create_template(snapshot_abs_path, workspace_abs_path)
rsp.size, rsp.actualSize = linux.qcow2_size_and_actual_size(workspace_abs_path)
rsp.totalCapacity, rsp.availableCapacity = lvm.get_vg_size(cmd.vgUuid)
rsp.actualSize = rsp.size
return jsonobject.dumps(rsp)
def check(volume_abs_path, raw_volume_abs_path):
with lvm.OperateLv(volume_abs_path,
shared=False,
delete_when_exception=False):
if get_volume_format(volume_abs_path) == "raw":
raise Exception("volume %s is raw format, no need to convert" %
volume_abs_path)
if lvm.has_lv_tag(volume_abs_path, START_TAG):
raise Exception(
"there is tag %s on volume %s, there may other process processing, please check or wait"
% (START_TAG, volume_abs_path))
if lvm.has_lv_tag(volume_abs_path, DONE_TAG):
raise Exception(
"there is tag %s on volume %s, there may other process processing, please check or wait"
% (DONE_TAG, volume_abs_path))
if lvm.lv_exists(raw_volume_abs_path):
raise Exception(
"there is raw volume %s, there may other process processing, please check or wait"
% raw_volume_abs_path)
def create_template_from_volume(self, req):
cmd = jsonobject.loads(req[http.REQUEST_BODY])
rsp = AgentRsp()
volume_abs_path = translate_absolute_path_from_install_path(
cmd.volumePath)
install_abs_path = translate_absolute_path_from_install_path(
cmd.installPath)
with lvm.RecursiveOperateLv(volume_abs_path, shared=False):
virtual_size = linux.qcow2_virtualsize(volume_abs_path)
if not lvm.lv_exists(install_abs_path):
lvm.create_lv_from_absolute_path(
install_abs_path, virtual_size,
"%s::%s::%s" % (VOLUME_TAG, cmd.hostUuid, time.time()))
with lvm.OperateLv(install_abs_path,
shared=False,
delete_when_exception=True):
linux.create_template(volume_abs_path, install_abs_path)
logger.debug('successfully created template[%s] from volume[%s]' %
(cmd.installPath, cmd.volumePath))
rsp.totalCapacity, rsp.availableCapacity = lvm.get_vg_size(cmd.vgUuid)
return jsonobject.dumps(rsp)
