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))