def migrate_instance(self):
act_map_com_info = map_compute_info.MapComputeInfo(self.init)
act_net_prep = prepare_networks.PrepareNetworks(self.init,
cloud='dst_cloud')
act_deploy_instances = transport_instance.TransportInstance(self.init)
act_i_to_f = load_compute_image_to_file.LoadComputeImageToFile(
self.init, cloud='dst_cloud')
act_merge = merge_base_and_diff.MergeBaseDiff(self.init,
cloud='dst_cloud')
act_convert_image = convert_file.ConvertFile(self.init,
cloud='dst_cloud')
act_f_to_i = upload_file_to_image.UploadFileToImage(self.init,
cloud='dst_cloud')
act_transfer_file = task_transfer.TaskTransfer(
self.init,
'SSHCephToFile',
resource_name=utl.INSTANCES_TYPE,
resource_root_name=utl.DIFF_BODY)
act_f_to_i_after_transfer = upload_file_to_image.UploadFileToImage(
self.init, cloud='dst_cloud')
act_is_not_trans_image = is_not_transport_image.IsNotTransportImage(
self.init, cloud='src_cloud')
act_is_not_merge_diff = is_not_merge_diff.IsNotMergeDiff(
self.init, cloud='src_cloud')
act_post_transport_instance = post_transport_instance.PostTransportInstance(
self.init, cloud='dst_cloud')
act_transport_ephemeral = transport_ephemeral.TransportEphemeral(
self.init, cloud='dst_cloud')
trans_file_to_file = task_transfer.TaskTransfer(
self.init,
'SSHFileToFile',
resource_name=utl.INSTANCES_TYPE,
resource_root_name=utl.DIFF_BODY)
act_trans_diff_file = task_transfer.TaskTransfer(
self.init,
'SSHFileToFile',
resource_name=utl.INSTANCES_TYPE,
resource_root_name=utl.DIFF_BODY)
act_is_not_copy_diff_file = is_not_copy_diff_file.IsNotCopyDiffFile(
self.init)
process_merge_diff_and_base = act_i_to_f >> trans_file_to_file >> act_merge >> act_convert_image >> act_f_to_i
process_merge_diff_and_base = act_i_to_f
process_transport_image = act_transfer_file >> act_f_to_i_after_transfer
process_transport_image = act_transfer_file
act_pre_transport_instance = (act_is_not_trans_image | act_is_not_merge_diff) >> \
process_transport_image >> \
(act_is_not_merge_diff | act_deploy_instances) >> \
process_merge_diff_and_base
act_post_transport_instance = (
act_is_not_copy_diff_file
| act_transport_ephemeral) >> act_trans_diff_file
return act_net_prep >> \
act_map_com_info >> \
act_pre_transport_instance >> \
act_deploy_instances >> \
act_post_transport_instance >> \
act_transport_ephemeral
def copy_ephemeral_ceph_to_iscsi(self, src_cloud, dst_cloud, info):
transporter = task_transfer.TaskTransfer(
self.init,
TRANSPORTER_MAP[ISCSI][ISCSI],
resource_name=utl.INSTANCES_TYPE,
resource_root_name=utl.EPHEMERAL_BODY)
instances = info[utl.INSTANCES_TYPE]
temp_src = src_cloud.cloud_config.cloud.temp
host_dst = dst_cloud.cloud_config.cloud.ssh_host
qemu_img_dst = dst_cloud.qemu_img
qemu_img_src = src_cloud.qemu_img
temp_path_src = temp_src + "/%s" + utl.DISK_EPHEM
for inst_id, inst in instances.iteritems():
path_src_id_temp = temp_path_src % inst_id
host_compute_dst = inst[EPHEMERAL][HOST_DST]
inst[EPHEMERAL][
BACKING_FILE_DST] = qemu_img_dst.detect_backing_file(
inst[EPHEMERAL][PATH_DST], host_compute_dst)
self.delete_remote_file_on_compute(inst[EPHEMERAL][PATH_DST],
host_dst, host_compute_dst)
qemu_img_src.convert(utl.QCOW2,
'rbd:%s' % inst[EPHEMERAL][PATH_SRC],
path_src_id_temp)
inst[EPHEMERAL][PATH_SRC] = path_src_id_temp
transporter.run(info=info)
for inst_id, inst in instances.iteritems():
host_compute_dst = inst[EPHEMERAL][HOST_DST]
qemu_img_dst.diff_rebase(inst[EPHEMERAL][BACKING_FILE_DST],
inst[EPHEMERAL][PATH_DST],
host_compute_dst)
def transport_diff_and_merge(self, dst_cloud, info, instance_id):
convertor = convert_image_to_file.ConvertImageToFile(self.init, cloud='dst_cloud')
transporter = task_transfer.TaskTransfer(
self.init,
TRANSPORTER_MAP[ISCSI][ISCSI],
resource_name=utl.INSTANCES_TYPE,
resource_root_name=utl.DIFF_BODY)
image_id = info[INSTANCES][instance_id][utl.INSTANCE_BODY]['image_id']
base_file = "%s/%s" % (dst_cloud.cloud_config.cloud.temp, "temp%s_base" % instance_id)
diff_file = "%s/%s" % (dst_cloud.cloud_config.cloud.temp, "temp%s" % instance_id)
info[INSTANCES][instance_id][DIFF][PATH_DST] = diff_file
info[INSTANCES][instance_id][DIFF][HOST_DST] = dst_cloud.getIpSsh()
convertor.run(image_id=image_id,
base_filename=base_file)
transporter.run(info=info)
self.merge_file(dst_cloud, base_file, diff_file)
image_res = dst_cloud.resources[utl.IMAGE_RESOURCE]
images = image_res.read_info(image_id=image_id)
image = images[utl.IMAGE_RESOURCE][utl.IMAGES_TYPE][image_id]
disk_format = image[utl.IMAGE_BODY]['disk_format']
if image_res.config.image.convert_to_raw:
if disk_format.lower() != utl.RAW:
self.convert_file_to_raw(dst_cloud.cloud_config.cloud.host, disk_format, base_file)
disk_format = utl.RAW
converter = convert_file_to_image.ConvertFileToImage(self.init, cloud='dst_cloud')
dst_image_id = converter.run(file_path=base_file,
image_format=disk_format,
image_name="%s-image" % instance_id)
info[INSTANCES][instance_id][INSTANCE_BODY]['image_id'] = dst_image_id
def transport_available_volumes_via_ssh(self):
is_volume_snapshots = is_option.IsOption(self.init,
'keep_volume_snapshots')
final_action = fake_action.FakeAction(self.init)
act_get_info_available_volumes = get_info_volumes.GetInfoVolumes(
self.init, cloud='src_cloud', search_opts={'status': 'available'})
act_rename_vol_src = create_reference.CreateReference(
self.init, 'storage_info', 'src_storage_info')
task_get_available_vol_info = act_get_info_available_volumes >> act_rename_vol_src
act_deploy_vol = deploy_volumes.DeployVolumes(self.init,
cloud='dst_cloud')
act_rename_vol_dst = create_reference.CreateReference(
self.init, 'storage_info', 'dst_storage_info')
task_deploy_available_volumes = act_deploy_vol >> act_rename_vol_dst
act_vol_data_map = prepare_volumes_data_map.PrepareVolumesDataMap(
self.init, 'src_storage_info', 'dst_storage_info')
act_vol_transport_data = \
task_transfer.TaskTransfer(self.init,
'SSHCephToCeph',
input_info='storage_info') - final_action
act_deploy_vol_snapshots = \
deploy_snapshots.DeployVolSnapshots(self.init,cloud='dst_cloud') - final_action
return task_get_available_vol_info >> \
task_deploy_available_volumes >> \
act_vol_data_map >> \
(is_volume_snapshots | act_deploy_vol_snapshots | act_vol_transport_data) \
>> final_action
def transport_volumes_by_instance_via_ssh(self):
act_convert_c_to_v = convert_compute_to_volume.ConvertComputeToVolume(
self.init, cloud='src_cloud')
act_rename_inst_vol_src = create_reference.CreateReference(
self.init, 'storage_info', 'src_storage_info')
act_convert_v_to_c = convert_volume_to_compute.ConvertVolumeToCompute(
self.init, cloud='dst_cloud')
act_rename_inst_vol_dst = create_reference.CreateReference(
self.init, 'storage_info', 'dst_storage_info')
act_inst_vol_data_map = prepare_volumes_data_map.PrepareVolumesDataMap(
self.init, 'src_storage_info', 'dst_storage_info')
act_deploy_inst_volumes = deploy_volumes.DeployVolumes(
self.init, cloud='dst_cloud')
act_inst_vol_transport_data = task_transfer.TaskTransfer(
self.init, 'SSHCephToCeph', input_info='storage_info')
act_deploy_snapshots = deploy_snapshots.DeployVolSnapshots(
self.init, cloud='dst_cloud') - act_convert_v_to_c
is_snapshots = is_option.IsOption(self.init, 'keep_volume_snapshots')
task_get_inst_vol_info = act_convert_c_to_v >> act_rename_inst_vol_src
task_deploy_inst_vol = act_deploy_inst_volumes >> act_rename_inst_vol_dst
return task_get_inst_vol_info >> \
task_deploy_inst_vol >> act_inst_vol_data_map >> \
(is_snapshots | act_deploy_snapshots | act_inst_vol_transport_data) >> \
act_convert_v_to_c
def transport_from_src_to_dst(self, info):
transporter = task_transfer.TaskTransfer(
self.init,
TRANSPORTER_MAP[ISCSI][ISCSI],
resource_name=utl.INSTANCES_TYPE,
resource_root_name=utl.DIFF_BODY)
transporter.run(info=info)
def copy_data_via_ssh(self, src_cloud, dst_cloud, info, body, resources, types):
dst_storage = dst_cloud.resources[resources]
src_compute = src_cloud.resources[resources]
src_backend = src_compute.config.compute.backend
dst_backend = dst_storage.config.compute.backend
transporter = task_transfer.TaskTransfer(
self.init,
TRANSPORTER_MAP[src_backend][dst_backend],
resource_name=types,
resource_root_name=body)
transporter.run(info=info)
def copy_data_via_ssh(self, src_cloud, dst_cloud, info, body, resources,
types):
dst_storage = dst_cloud.resources[resources]
src_compute = src_cloud.resources[resources]
src_backend = src_compute.config.compute.backend
dst_backend = dst_storage.config.compute.backend
ssh_driver = (SSH_CHUNKS if self.cfg.migrate.direct_compute_transfer
else TRANSPORTER_MAP[src_backend][dst_backend])
transporter = task_transfer.TaskTransfer(self.init,
ssh_driver,
resource_name=types,
resource_root_name=body)
transporter.run(info=info)
def transport_image(self, dst_cloud, info, instance_id):
cloud_cfg_dst = dst_cloud.cloud_config.cloud
temp_dir_dst = cloud_cfg_dst.temp
transporter = task_transfer.TaskTransfer(
self.init,
TRANSPORTER_MAP[CEPH][ISCSI],
resource_name=utl.INSTANCES_TYPE,
resource_root_name=utl.DIFF_BODY)
path_dst = "%s/%s" % (temp_dir_dst, "temp%s" % instance_id)
info[INSTANCES][instance_id][DIFF][PATH_DST] = path_dst
info[INSTANCES][instance_id][DIFF][HOST_DST] = dst_cloud.getIpSsh()
transporter.run(info=info)
converter = convert_file_to_image.ConvertFileToImage(dst_cloud)
dst_image_id = converter.run(file_path=path_dst,
image_format='raw',
image_name="%s-image" % instance_id)
info[INSTANCES][instance_id][INSTANCE_BODY]['image_id'] = dst_image_id
def copy_ephemeral_iscsi_to_ceph(self, src_cloud, info):
instances = info[utl.INSTANCES_TYPE]
qemu_img_src = src_cloud.qemu_img
transporter = task_transfer.TaskTransfer(
self.init,
TRANSPORTER_MAP[ISCSI][CEPH],
resource_name=utl.INSTANCES_TYPE,
resource_root_name=utl.EPHEMERAL_BODY)
for inst_id, inst in instances.iteritems():
path_src = inst[EPHEMERAL][PATH_SRC]
path_src_temp_raw = path_src + "." + utl.RAW
host_src = inst[EPHEMERAL][HOST_SRC]
qemu_img_src.convert(utl.RAW, path_src, path_src_temp_raw,
host_src)
inst[EPHEMERAL][PATH_SRC] = path_src_temp_raw
transporter.run(info=info)
def transport_volumes_by_instance_via_ssh(self):
act_convert_c_to_v = convert_compute_to_volume.ConvertComputeToVolume(
self.init, cloud='src_cloud')
act_rename_inst_vol_src = create_reference.CreateReference(
'storage_info', 'src_storage_info')
act_convert_v_to_c = convert_volume_to_compute.ConvertVolumeToCompute(
self.init, cloud='dst_cloud')
act_rename_inst_vol_dst = create_reference.CreateReference(
'storage_info', 'dst_storage_info')
act_inst_vol_data_map = prepare_volumes_data_map.PrepareVolumesDataMap(
self.init, 'src_storage_info', 'dst_storage_info')
act_deploy_inst_volumes = deploy_volumes.DeployVolumes(
self.init, cloud='dst_cloud')
act_inst_vol_transport_data = task_transfer.TaskTransfer(
self.init,
ssh_ceph_to_ceph.SSHCephToCeph,
input_info='storage_info')
task_get_inst_vol_info = act_convert_c_to_v >> act_rename_inst_vol_src
task_deploy_inst_vol = act_deploy_inst_volumes >> act_rename_inst_vol_dst
task_transfer_inst_vol_data = act_inst_vol_data_map >> act_inst_vol_transport_data
return task_get_inst_vol_info \
>> task_deploy_inst_vol >> task_transfer_inst_vol_data >> act_convert_v_to_c
def run(self, storage_info=None, identity_info=None, **kwargs):
storage_info = copy.deepcopy(storage_info)
deploy_info = copy.deepcopy(storage_info)
deploy_info.update(identity_info)
storage_info.update(identity_info)
volume_resource = self.cloud.resources[utl.STORAGE_RESOURCE]
for vol_id, vol in deploy_info[utl.VOLUMES_TYPE].iteritems():
if vol['snapshots']:
vol_info = vol[utl.VOLUME_BODY]
snapshots_list = \
[snap_info for snap_info in vol['snapshots'].values()]
snapshots_list.sort(key=lambda x: x['created_at'])
for snap in snapshots_list:
if snapshots_list.index(snap) == 0:
act_snap_transfer = \
snap_transfer.SnapTransfer(
self.init,
ssh_ceph_to_ceph.SSHCephToCeph,
1)
else:
snap_num = snapshots_list.index(snap)
snap['prev_snapname'] = \
snapshots_list[snap_num - 1]['name']
act_snap_transfer = \
snap_transfer.SnapTransfer(
self.init,
ssh_ceph_to_ceph.SSHCephToCeph,
2)
act_snap_transfer.run(volume=vol_info, snapshot_info=snap)
volume_resource.create_snapshot(
volume_id=vol_id,
display_name=snap['display_name'],
display_description=snap['display_description'])
act_snap_transfer = snap_transfer.SnapTransfer(
self.init, ssh_ceph_to_ceph.SSHCephToCeph, 3)
act_snap_transfer.run(volume=vol_info,
snapshot_info=snapshots_list[-1])
for snap in snapshots_list:
if volume_resource.config.storage.host:
act_delete_redundant_snap = \
rbd_util.RbdUtil(cloud=self.cloud,
config_migrate=self.cfg.migrate,
host=vol_info[utl.HOST_DST])
act_delete_redundant_snap.snap_rm(
vol_info[utl.PATH_DST], snap['name'])
else:
act_delete_redundant_snap = \
rbd_util.RbdUtil(cloud=self.cloud,
config_migrate=self.cfg.migrate)
act_delete_redundant_snap.snap_rm(
vol_info[utl.PATH_DST], snap['name'],
vol_info[utl.HOST_DST])
else:
one_volume_info = {
'one_volume_info': {
utl.VOLUMES_TYPE: {
vol_id: vol
}
}
}
act_transport_vol_data = \
task_transfer.TaskTransfer(self.init,
'SSHCephToCeph',
input_info='one_volume_info')
act_transport_vol_data.run(**one_volume_info)
return {}
