def run_vm_state(body):
try:
records = body.get("records", {})
result = {}
for vm_id in records.keys():
try:
compute = yield get_server(vm_id=vm_id)
except Exception as e:
LOG.error("compute run_vm_state get_server %s error is %s",
vm_id, e)
compute = {}
state = compute.get("state") if compute else "quit"
result[vm_id] = state
response = {}
for k, v in result.items():
response[k] = v
if not records or (k in records and v == records.get(k)):
response.pop(k)
body = {
"total": 0,
"records": result,
"response": response,
"type": "state"
}
except Exception, e:
LOG.error("vm detail state handler push message error is %s", e)
def attach_volume(self, attachment):
volume_id = attachment['volume_id']
server_id = attachment['vm_id']
volume = yield get_volume(volume_id, detailed=True)
server = yield compute.get_server(vm_id=server_id)
if not volume or not server:
raise InvalidateParam(args=['vm_id', 'volume_id'])
volume_project = unicode(volume['tenant'].get("id", None))
server_project = unicode(server['tenant'].get("id", None))
if volume_project and server_project and server_project != volume_project:
raise AttachBeyondDomainError
volume_user = unicode(volume['user'].get("id", None))
server_user = unicode(server['user'].get("id", None))
if volume_user and server_user and volume_user != server_user:
raise AttachBeyondDomainError
yield compute.attach_server_volume(volume_id=volume_id,
server_id=server_id)
optLog.write(
self.request, optLog.Type.VDISK, volume['name'],
optLog.Operator.ATTACH,
volume['metadata']['displayname'] + ">>" + server['name'] + " " +
gen_network_comment(server['network'].values()))
self.response(Response())
def list_snapshots(self, name):
"""
:param name:
:return:
"""
if name.startswith("vm-"):
vm = yield get_server(name=name)
status = vm["state"]
r_status = vm["recover-status"]
id = vm['id']
elif name.startswith("vd-"):
source = yield get_volume(name=name)
status = source["status"]
r_status = source["recover-status"]
id = source['id']
else:
raise InvalidateParam()
out_snapshots = yield snapshot_package.list_snapshot(name)
result = {
"snapshots": out_snapshots,
"status": status,
"id": id,
"recover-status": enum_recover_status(status, r_status)
}
self.response(Response(result=result, total=len(out_snapshots)))
def resize_server(self, vm_id, body):
""" extend vm setting: cores and memory
:param vm_id: id of vm
:param body: extend setting：
{
"cores": 1,
"memory": 1,
}
"""
vm = yield compute.get_server(vm_id=vm_id)
if not vm:
raise VmNotExist
cores = body['cores']
memory = body['memory']
if vm_id and memory and cores:
yield compute.resize(vm, cores, memory)
else:
raise InvalidateParam(args=['cores', 'memory'])
optLog.write(
self.request, Type.VM, vm['name'], Operator.MODIFY_SETTING,
vm['displayname'] + " " +
gen_network_comment(vm['network'].values()))
self.response(Response())
def list_attach_volume(self, vm_id):
vm = yield compute.get_server(vm_id=vm_id)
if not vm:
raise VmNotExist
attach_volumes = yield compute.list_server_attach_volume(vm_id,
vd_type=0)
self.response(
Response(result=attach_volumes, total=len(attach_volumes)))
def get_server(self, vm_id=None, name=None):
"""
:param vm_id:
:param name:
:return:
"""
out_server = yield compute.get_server(vm_id=vm_id, name=name)
self.response(Response(result=out_server))
def del_vm_nic(self, vm_id, port_id):
vm = yield compute.get_server(vm_id, detailed=False)
port = yield compute.get_port(port_id)
if not vm or not port:
raise InvalidateParam(args=['vm_id'])
yield compute.del_vm_nic(vm, port_id)
log.write(self.request, log.Type.VM, vm['name'], log.Operator.DEL_NIC,
port.get("name") + " " + port.get("ip"))
self.response(Response())
def vm_user(self, body):
"""
:param body:
{
"vm-user": [{
"user_id": "83d546cc-3975-4890-8c31-e8c859203d9b",
"vm_id": "e603b2a7-4854-4368-8bfb-e68d0ac6c170"
}]
}
:return:
"""
vm_u = body.get("vm-user")
if not vm_u:
raise InvalidateParam(args=['vm-user'])
for v_u in vm_u:
vm_id = v_u.get("vm_id")
u_id = v_u.get("user_id")
vm = yield compute.get_server(vm_id)
if not vm:
raise VmNotExist(args=["vm_id"])
vm_tenant_id = vm["tenant"]["id"]
users = yield list_tenant_users(vm_tenant_id)
user_ids = [user_item["id"] for user_item in users]
if not user_ids or u_id not in user_ids:
raise VmTenantUserUnmatch(args=[{"user_id": u_id}])
for v_u in vm_u:
vm_id = v_u.get("vm_id")
u_id = v_u.get("user_id")
vm = yield compute.get_server(vm_id)
user = yield get_user_by_id(u_id)
attch_vol = yield compute.list_server_attach_volume(vm_id)
for vol_item in attch_vol:
vol_id = vol_item["volume_id"]
yield set_volume_user(vol_id, u_id)
yield compute.set_vm_user(vm_id, u_id)
log.write(
self.request, log.Type.VM, vm['name'], log.Operator.SET_USER,
vm['displayname'] + " " +
gen_network_comment(vm['network'].values()) + " " +
user['displayname'])
self.response(Response())
def get_instance_vnc(self, vm_id):
""" list instances of tenant
:param vm_id: id of vm
:return: vm 's vnc url
"""
vm = yield compute.get_server(vm_id=vm_id)
if not vm:
raise VmNotExist
result = {}
console = yield compute.vnc(vm_id)
result["url"] = console
self.response(Response(result=result))
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 add_vm_nic(self, vm_id, body):
vlan_id = body.get("vlan_id")
subnet_id = body.get("subnet_id")
ip = body.get("ip")
mac = body.get("mac")
vlan = yield get_network(vlan_id)
vm = yield compute.get_server(vm_id, detailed=False)
if not vm or not vlan:
raise InvalidateParam(args=['vm_id'])
fixed_ip = yield compute.add_vm_nic(vm, vlan_id, subnet_id, ip, mac)
log.write(self.request, log.Type.VM, vm['name'], log.Operator.ADD_NIC,
vlan.get("name") + " " + fixed_ip)
self.response(Response())
def detach_volume(self, attachment):
volume_id = attachment['volume_id']
server_id = attachment['vm_id']
volume = yield get_volume(volume_id, detailed=True)
server = yield compute.get_server(vm_id=server_id, detailed=True)
if not volume or not server:
raise InvalidateParam(args=['vm_id', 'volume_id'])
yield compute.detach_server_volume(server_id=server_id,
volume_id=volume_id)
optLog.write(
self.request, optLog.Type.VDISK, volume['name'],
optLog.Operator.DETACH,
volume['metadata']['displayname'] + ">>" + server['name'] + " " +
gen_network_comment(server['network'].values()))
self.response(Response())
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 _vm_meter(meter_name, vm_id, limit):
compute = yield get_server(vm_id=vm_id)
rst_data = {}
if compute and compute.get("state") == "active":
data = yield SampleQuery().meters_query(
meter_name, **{
'vm': vm_id,
'limit': limit
})
res = gen_host_chart_rst(meter_name, data)
rst_data = {
"type": meter_name,
"records": res[0] if limit == 1 and res else res,
"limit": str(limit)
}
raise gen.Return(rst_data)
def upload_image_template(self, vm_id, vm_template):
""" generate vm templates from exist vm
:param vm_id: the id of vm
:param vm_template: the params of create vm templates
:return:
"""
vm_template = compute.VMTemplate(**vm_template)
vm = yield compute.get_server(vm_id=vm_id)
if VM_STATUS_STOP != vm['state']:
raise InvalidVMStatusError
vm_temp = yield compute.template(vm_id, vm_template)
optLog.write(
self.request, Type.VM, vm['name'], Operator.CREATE_TEMPLATE,
vm['displayname'] + " " +
gen_network_comment(vm['network'].values()) + " " +
vm_template.name)
self.response(Response(result={"id": vm_temp}))
def migrate_server(self, vm_id, body):
""" migrate instance required instance status if shutoff.
:param vm_id: id of vm
:param body: params of migrate instance
"""
body = compute.VMMigrate(**body)
destination_host = body.destination_host
old_vm = yield compute.get_server(vm_id=vm_id)
if not old_vm:
raise VmNotExist
vm_status = old_vm['state']
if vm_status == compute.VM_STATUS_STOP:
yield compute.cold_migrate(vm_id, destination_host)
elif vm_status == compute.VM_STATUS_ACTIVE:
yield compute.live_migrate(vm_id, destination_host)
optLog.write(
self.request, Type.VM, old_vm['name'], Operator.MIGRATE,
old_vm['displayname'] + " " +
gen_network_comment(old_vm['network'].values()))
self.response(Response())
def update_server(self, vm_id, vm_metadata):
""" update vm metadata's extend info
:param vm_id: id of vm
:param vm_metadata: the metadata extend info of vm,
{"vm_id":"uuid",
"extend": {"displayname": "sec", "des": "desc", "keepalive": 0}}
"""
vm_metadata = compute.Metadata(**vm_metadata)
if vm_id and vm_metadata.extend:
vm = yield compute.get_server(vm_id=vm_id)
if not vm:
raise VmNotExist
yield compute.update_server(vm_id, vm_metadata)
optLog.write(
self.request, Type.VM, vm['name'], Operator.UPDATE,
str(vm_metadata.extend.get("displayname")) + " " +
gen_network_comment(vm['network'].values()))
else:
raise InvalidateParam("Miss Required Params: vm_id and extend")
self.response(Response())
def create_volume_snapshot(self, params):
"""
:param params:
{
'type':'snapshot_type', 0:vm;1:vd
'id':"source_id",
'name':'name',
'description':'description',
'volume_ids':[id1,id2...]
}
:return:
"""
snapshot_type = params.get("type")
source_id = params.get("id")
name = params.get("name")
description = params.get("des", "")
volume_ids = params.get("volume_ids", [])
if snapshot_type not in [0, 1]:
raise SnapshotTypeNotStandard
if snapshot_type == 0:
info = yield get_server(vm_id=source_id)
if not info:
raise VmNotExist()
else:
info = yield get_volume(volume_id=source_id)
if not info:
raise VolumeNotExist()
yield snapshot_create(source_id, snapshot_type, name, description,
volume_ids)
if snapshot_type == 0:
for volume in volume_ids:
volume_info = yield volume_package.get_volume(volume_id=volume)
optLog.write(self.request, Type.SNAPSHOT,
volume_info.get("name"), Operator.CREATE, name)
optLog.write(self.request, Type.SNAPSHOT, info.get("name"),
Operator.CREATE, name)
self.response(Response())
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",
attach_status="detached")
yield volume.delete_volume(vol.get("id"))
except Exception, e:
pass
try:
"""deleting status clean nova"""
db_nova = dbpools.get_nova()
sql_nova = "update instance_metadata set value = '' where deleted = 0 and `key` = 'status'"
row_nova = yield dbpools.update(db_nova, sql_nova)
LOG.debug("clean nova metadata status sql is %s affect row %s",
sql_nova, row_nova)
"""deleting status clean cinder"""
def list_vm_nics(self, vm_id):
vm = yield compute.get_server(vm_id, detailed=False)
if not vm:
raise InvalidateParam(args=['vm_id'])
nics = yield compute.list_vm_nics(vm)
self.response(Response(result=nics, total=len(nics)))
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)
def get_migrate_available_host(self, vm_id):
vm = yield get_server(vm_id)
if not vm:
raise InvalidateParam()
hosts = yield get_migrate_available_host(vm)
self.response(Response(result=hosts))