def _vm_recover(snapshot_info, name):
vm_info = yield compute.get_server(name=name)
vm_status = vm_info.get("state")
if vm_status not in ["active", "stopped", "error"]:
raise VmMustActiveOrStop()
snapshot_id = snapshot_info["id"]
snapshot_metadata = snapshot_info.get("metadata")
snapshot_metadata["status"] = "recovering"
vm_id = vm_info.get('id')
yield set_or_update_vm_meta(vm_id, "status", "recovering")
yield set_or_update_vm_meta(vm_id, "recover_status", "")
yield volume_request.update_metadata(snapshot_id, snapshot_metadata)
yield _gen_snapshot_recover_vm(vm_id, snapshot_info)
def execute(self):
try:
volume_id = self._message.get('volume_id')
volume_name = self._message.get("display_name")
vm_name = volume_name[len("ecloud-recover-"):]
LOG.debug("vm recover message is %s", self._message)
source_volume = yield get_volume(volume_id=volume_id, vd_type=4)
metadata = source_volume["metadata"]
vm_id = metadata.get("vm_id")
snapshot_id = metadata.get("snapshot_id")
volume_info = yield list_server_attach_volume(vm_id, vd_type=1)
sys_volume_id = volume_info[0]["volume_id"]
yield snapshotdao.update_block_device_mapping(vm_id, volume_id)
new_sys_volume_name = "ecloud-sys-volume-%s" % vm_name
yield volume_request.volume_update(volume_id,
name=new_sys_volume_name,
description=1)
yield snapshotdao.update_volume_db(volume_id=sys_volume_id,
status="available",
attach_status="detached")
yield volume_request.volume_update(sys_volume_id, description=5)
yield set_or_update_vm_meta(vm_id, compute.NEED_DELETE_SYS_VOLUME,
sys_volume_id)
yield compute.server_action(vm_id, "reboot", info={"type": "HARD"})
except Exception, e:
LOG.error("VM Recover When Attach Volume End Error %s" % e)
def _gen_snapshot_recover_vm(vm_id, snapshot_info):
size = snapshot_info["size_gb"]
tenant_id = snapshot_info["tenant"]["id"]
source_volid = snapshot_info["id"]
metadata = {"snapshot_id": source_volid, "vm_id": vm_id}
location = snapshot_info["location"]
volume_type = location[location.rindex("#") + 1:]
recover_name = "ecloud-recover-%s" % snapshot_info["name"][
len("ecloud-snapshot-"):]
availability_zone = location[:location.
index("@")] if "lvm" in location else None
try:
yield volume_request.volume_create(size,
tenant_id,
consistencygroup_id=None,
snapshot_id=None,
source_volid=source_volid,
name=recover_name,
description=4,
volume_type=volume_type,
user_id=None,
project_id=tenant_id,
availability_zone=availability_zone,
metadata=metadata,
image_ref=None,
scheduler_hints=None,
source_replica=None)
except Exception as e:
LOG.error("Snapshot recover error when create volume clone. msg:%s", e)
snapshot_id = snapshot_info["id"]
snapshot_metadata = snapshot_info.get("metadata")
snapshot_metadata["status"] = ""
yield set_or_update_vm_meta(vm_id, "status", "")
yield set_or_update_vm_meta(vm_id, "recover_status", "recover-error")
yield volume_request.update_metadata(snapshot_id, snapshot_metadata)
raise SnapshotRecoverCreateError()
def execute(self):
try:
success = False
if self._message.get("status") == "available":
success = True
volume_name = self._message.get("display_name")
volume_id = self._message.get("volume_id")
v_metadata = yield get_metadata(volume_id)
source_name = volume_name[len("ecloud-recover-"):]
snapshot_id = v_metadata.get("snapshot_id")
LOG.debug("recover snapshot source name is %s snapshot is %s ",
source_name, snapshot_id)
if source_name.startswith("vd-"):
source_volume = yield get_volume(name=source_name)
source_id = source_volume["id"]
if success:
if source_volume.get("attachments"):
vm_id = source_volume["attachments"][0]["vm_id"]
yield attach_server_volume(vm_id, volume_id)
else:
yield volume_request.volume_update(
volume_id,
name=volume_name[len('ecloud-recover-'):],
description=0)
yield volume_request.volume_update(source_id,
description=5)
yield volume_request.volume_delete(source_id)
LOG.debug(
"recover snapshot delete source_id [%s] success ! ",
source_id)
else:
v_metadata["recover_status"] = "recover-error"
v_metadata["status"] = ""
yield volume_request.update_metadata(volume_id, v_metadata)
yield delete_metadata(snapshot_id, ["status"])
else:
vm = yield compute.get_server(name=source_name, detailed=False)
vm_id = vm["id"]
if success:
yield attach_server_volume(vm_id, volume_id)
else:
yield set_or_update_vm_meta(vm_id, "recover_status",
"recover-error")
if not success:
yield volume_request.volume_delete(volume_id)
except Exception, e:
LOG.error("Create Recover Volume Error %s" % e)
def execute(self):
try:
volume_name = self._message.get("display_name")
volume_id = self._message.get("volume_id")
volume_metas = yield volume_request.volume_metadata([volume_id])
volume_meta = {}
for item in volume_metas:
if item["meta_key"] not in volume_meta:
volume_meta[item["meta_key"]] = {}
volume_meta[item["meta_key"]] = item["meta_value"]
old_volume_id = volume_meta.get("volume_id")
old_volume_status = volume_meta.get("source_status")
if volume_name.startswith("ecloud-snapshot-vm"):
old_volume_id = volume_meta.get("sys_volume_id")
vm_id = volume_meta.get("vm_id")
if vm_id:
yield set_or_update_vm_meta(vm_id, "status", "")
else:
yield delete_metadata(old_volume_id, ["status"])
yield volume_request.reset_state(volume_id=old_volume_id,
volume_state=old_volume_status)
except Exception, e:
LOG.error("sysvolume clone end update task status error %s" % e)
def snapshot_create(source_id,
snapshot_type,
name,
description,
volume_ids=[]):
"""
:param source_id:
:param snapshot_type:
:param name:
:param description:
:param volume_ids:
:return:
"""
snapshots = []
data_volumes = []
volume_mate = {}
if snapshot_type == SNAPSHOT_TYPE_VM: # vm
LOG.debug("Create Snapshot Type is vm")
vm_info = yield compute.get_server(vm_id=source_id)
vm_state = vm_info.get("state")
if vm_state not in ["active", "stopped"]:
raise VmMustActiveOrStop()
vm_id = vm_info["id"]
vm_name = vm_info["name"]
tenant_id = vm_info["tenant"]["id"]
sys_volumes = yield list_server_attach_volume(vm_id, vd_type=1)
if not sys_volumes:
raise InvalidVm
sys_volume = sys_volumes[0]
sys_volume_id = sys_volume["volume_id"]
sys_volume_size = sys_volume["size"]
sys_volume_type = sys_volume["type"]
sys_volume_status = sys_volume["status"]
host = sys_volume["host"]
total_size = sys_volume_size
total_count = 1
if volume_ids:
data_volumes = yield list_volume(volume_id=volume_ids)
metadatas = yield volume_request.volume_metadata(volume_ids)
for meta_item in metadatas:
if meta_item["volume_id"] in volume_mate:
volume_mate[meta_item["volume_id"]].update(
{meta_item["meta_key"]: meta_item["meta_value"]})
else:
volume_mate[meta_item["volume_id"]] = {
meta_item["meta_key"]: meta_item["meta_value"]
}
for item_vol in data_volumes:
if item_vol["status"] not in ["in-use", "available"]:
raise VolumeStatusNotAvailable(args=[item_vol["id"]])
total_size += item_vol["size_gb"]
total_count += len(data_volumes)
quota = yield check_tenant_snapshot_quota(tenant_id, total_size,
total_count)
yield update_tenant_snapshot_quotas(tenant_id,
used_size=quota.get("used_size"),
used_count=quota.get("used_count"))
yield set_or_update_vm_meta(vm_id, "status", "snapshoting")
snapshots.append({
"volume_id": sys_volume_id,
"tenant_id": tenant_id,
"name": "ecloud-snapshot-%s" % vm_name,
"size": sys_volume_size,
"volume_type": sys_volume_type,
"display_discription": TYPE_SNAPSHOT_VOLUME,
"status": sys_volume_status,
"metadata": {
"des":
description,
"displayname":
name,
"vm_id":
source_id,
"availability_zone":
host[:host.index("@")]
if "lvm" in host else CONF.storage.share_storage_access,
"sys_volume_id":
sys_volume_id,
"source_status":
sys_volume_status
}
})
else:
LOG.debug("Create Snapshot Type is vd")
volume_ids.append(source_id)
total_size = 0
data_volumes = yield list_volume(volume_id=volume_ids)
metadatas = yield volume_request.volume_metadata(volume_ids)
for meta_item in metadatas:
if meta_item["volume_id"] in volume_mate:
volume_mate[meta_item["volume_id"]].update(
{meta_item["meta_key"]: meta_item["meta_value"]})
else:
volume_mate[meta_item["volume_id"]] = {
meta_item["meta_key"]: meta_item["meta_value"]
}
for item_vol in data_volumes:
if item_vol["status"] not in ["in-use", "available"]:
raise VolumeStatusNotAvailable(args=[item_vol["id"]])
total_size += item_vol["size_gb"]
tenant_id = data_volumes[0]["tenant"]["id"]
quota = yield check_tenant_snapshot_quota(tenant_id, total_size,
len(data_volumes))
yield update_tenant_snapshot_quotas(tenant_id,
used_size=quota.get("used_size"),
used_count=quota.get("used_count"))
for volume_item in data_volumes:
volume_id = volume_item["id"]
volume_name = volume_item["name"]
volume_size = volume_item["size_gb"]
volume_tenant_id = volume_item["tenant"]["id"]
status = volume_item["status"]
host = volume_item["location"]
snapshots.append({
"volume_id": volume_id,
"tenant_id": volume_tenant_id,
"name": "ecloud-snapshot-%s" % volume_name,
"size": volume_size,
"volume_type": host[host.rindex("#") + 1:],
"display_discription": TYPE_SNAPSHOT_VOLUME,
"status": status,
"volume_matedata": volume_mate[volume_id],
"metadata": {
"des":
description,
"displayname":
name,
"availability_zone":
host[:host.index("@")]
if "lvm" in host else CONF.storage.share_storage_access,
"volume_id":
volume_id,
"source_status":
status
}
})
LOG.debug("Snapshot Info Ready. Start gen snapshot volume.")
yield _gen_snapshot_volume(snapshots)
new_sys_volume_name = "ecloud-sys-volume-%s" % vm_name
yield volume_request.volume_update(volume_id,
name=new_sys_volume_name,
description=1)
yield snapshotdao.update_volume_db(volume_id=sys_volume_id,
status="available",
attach_status="detached")
yield volume_request.volume_update(sys_volume_id, description=5)
yield set_or_update_vm_meta(vm_id, compute.NEED_DELETE_SYS_VOLUME,
sys_volume_id)
yield compute.server_action(vm_id, "reboot", info={"type": "HARD"})
except Exception, e:
LOG.error("VM Recover When Attach Volume End Error %s" % e)
else:
yield compute.set_or_update_vm_meta(vm_id, "status", "")
yield delete_metadata(snapshot_id, ["status"])
@gen.coroutine
def test_list():
try:
snapshots = yield volume_list()
except Exception as e:
LOG.error(e)
raise e
raise gen.Return(snapshots)
@gen.coroutine
def main():