def clean_vm_or_volume_snapshot(source_name):
snapshot_name = "ecloud-snapshot-%s" % source_name
vm_snapshots = yield list_volume(name=snapshot_name,
vd_type=2,
detailed=False)
for vm_snapshot_item in vm_snapshots:
yield delete_snapshot(vm_snapshot_item["id"])
def list_snapshot(name):
"""
:param name: vm or volume name
:return:
"""
try:
snapshots = yield list_volume(name="ecloud-snapshot-%s" % name,
vd_type=2)
out_snapshots = []
for snapshot in snapshots:
if snapshot.get("status") == "deleting":
continue
out_snapshots.append({
"id":
snapshot["id"],
"name":
snapshot["name"],
"displayname":
snapshot["metadata"]["displayname"],
"create_at":
snapshot['created_at'],
"des":
snapshot["metadata"]["des"],
"size":
snapshot["size_gb"],
"status":
snapshot["status"]
})
except Exception as e:
LOG.error("List Snapshots Error, msg : %s" % e)
raise e
raise gen.Return(out_snapshots)
def delete_snapshots(self):
"""
:return:
"""
snapshots = yield volume_package.list_volume(detailed=False, vd_type=2)
for snapshot_item in snapshots:
snapshot_info = yield snapshot_package.delete_snapshot(
snapshot_item["id"])
self.response(Response())
def delete_server(self, vm_id, delete_volume_ids=None):
""" delete vm and delete vm attach volumes
:param vm_id: the id of to delete vm
:param delete_volume_ids: the ids of to delete attach volume
"""
try:
vm_info = {}
if vm_id.startswith("vm-"):
server_task = yield get_task_flow(name=vm_id)
if server_task:
server_task = server_task[0]
params = server_task.get("param")
server_info = params["body"]["server"]
vm_info["network"] = server_info["networks"]
vm_info["name"] = server_info["name"]
vm_info["displayname"] = server_info["displayname"]
else:
vm_infos = yield compute.list_server(vm_ids=vm_id,
with_task=False)
if not vm_infos:
raise VmNotExist(args=['vm_id', vm_id])
vm_info = vm_infos[0]
info = vm_info
if delete_volume_ids:
delete_volume_ids = delete_volume_ids.split(",")
else:
delete_volume_ids = []
if not vm_id.startswith("vm-"):
yield snapshot.clean_vm_or_volume_snapshot(info["name"])
if delete_volume_ids:
del_volumes = yield list_volume(detailed=False,
volume_id=delete_volume_ids)
for del_volume_item in del_volumes:
yield snapshot.clean_vm_or_volume_snapshot(
del_volume_item["name"])
optLog.write(self.request, Type.VDISK,
str(del_volume_item["name"]), Operator.DELETE,
str(del_volume_item["name"]))
yield del_server(vm_id, delete_volume_ids=delete_volume_ids)
optLog.write(
self.request, Type.VM, str(info["name"]), Operator.DELETE,
str(info["displayname"]) + " " +
gen_network_comment(info['network'].values()))
self.response(Response())
except Exception as e:
LOG.error("delete_server error: %s" % e)
raise 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)
force delete a server.
:param vm_id: id of server to get
:return
"""
try:
server = yield server_action(vm_id, "forceDelete")
except Exception, e:
LOG.error("force delete server error: %s" % e)
raise ServerOperationFailed()
finally:
servers = yield server_list(server_ids=vm_id)
if servers and servers[0].get("vm_state") == VM_STATUS_ERROR:
server = servers[0]
vd_name = "ecloud-sys-volume-%s" % server["name"]
sys_vds = yield list_volume(detailed=False,
name=vd_name,
vd_type=1)
if sys_vds:
sys_vd_id = sys_vds[0]["id"]
yield delete_volume(sys_vd_id)
yield delete_instance_info(vm_id)
yield task.delete_task_flow_by_resource(server["name"])
raise gen.Return(server)
@gen.coroutine
def server_restore(vm_id):
"""
restore a server.
:param vm_id: id of server to get
__author__ = '*****@*****.**'
@gen.coroutine
def clean_rubbish():
"""clean task"""
try:
db = dbpools.get_local()
sql = "update taskflow set status=4, updated_at=now() where status=3"
yield dbpools.update(db, sql)
except Exception, e:
pass
try:
"""clean volume"""
need_del_volume = yield volume.list_volume(detailed=False, vd_type=5)
for vol in need_del_volume:
yield volume.delete_volume(vol.get("id"))
except Exception, e:
pass
try:
"""clean sys volume"""
need_del_sys_volume = yield volume.list_volume(detailed=False,
vd_type=1,
available=True)
for vol in need_del_sys_volume:
vm = yield compute.get_server(
name=vol.get("name")[len('ecloud-sys-volume-'):])
if not vm:
yield snapshot.update_volume_db(volume_id=vol.get("id"),
status="available",