def update_network_subnet(self, subnet_id, params): """ Update network :param subnet_id: :param params: json: dns, name, gateway :return: """ LOG.debug( "Enter update_network_subnet, old network_id is %s, new network params is %s" % (subnet_id, params)) change_info = {"name": "", "dns": "", "gateway": ""} for key in change_info: change_info[key] = params[key] if key in params else "" change_info["id"] = subnet_id subnet = yield get_subnet(subnet_id) if not subnet: raise SubNetNotExist network = yield get_network(subnet.get("network_id")) if not network: raise NetworkNotExist yield update_subnet(subnet, change_info) model_name = change_info["name"] if change_info["name"] else subnet[ "name"] optLog.write(self.request, Type.NETWORK, network["name"], Operator.EDIT_SUBNET, model_name) self.response(Response())
def create_server(self, body): """""" body['metadata'] = compute.Metadata(**body['metadata']) vm = compute.Server(**body) if not vm.cores: raise InvalidateParam(args=['cores']) if not vm.memory: raise InvalidateParam(args=['memory']) if not vm.image: raise InvalidateParam(args=['image']) if not vm.metadata.extend.get("displayname"): raise InvalidateParam(args=['metadata.extend.displayname']) if vm.metadata.extend.get("keepalive") not in (0, 1): raise InvalidateParam(args=['metadata.extend.keepalive']) if not vm.tenant: raise InvalidateParam(args=['tenant']) if not vm.network: for network in vm.network: if not network.vlan: raise InvalidateParam(args=['network.vlan']) server = yield compute.create_server(vm) for s in server['name_ips']: optLog.write( self.request, Type.VM, s['name'], Operator.CREATE, vm.metadata.extend.get("displayname") + " " + ",".join(s['ips'])) self.response(Response(result={"batch": server['name']}))
def create_network_subnet(self, params): """ Create network :param params: vlan params """ LOG.debug("Enter create_network_subnet, params is %s" % params) subnet = SubNet(params) network = yield get_network(subnet.network_id) if not network: raise NetworkNotExist cidr_ip_range = tuple(netaddr.IPNetwork(subnet.cidr)) cidr_start = int(cidr_ip_range[0]) cidr_end = int(cidr_ip_range[-1]) for ip in subnet.ips: start = int(netaddr.IPAddress(ip.get("start"))) end = int(netaddr.IPAddress(ip.get("end"))) if start < cidr_start or end > cidr_end: raise IpNotInCidr subnet_select = yield get_subnet_db(network_id=subnet.network_id, name=subnet.name) if subnet_select: raise SubNetNameExist subnet_select = yield get_subnet_db() subnet_cidr_ips = set( [int(ip) for ip in netaddr.IPNetwork(subnet.cidr)]) cidrs_ips = (set((int(ip) for ip in netaddr.IPNetwork(item["cidr"]))) for item in subnet_select) for item in cidrs_ips: if item.intersection(subnet_cidr_ips): raise SubNetCidrExist yield create_subnet(subnet) optLog.write(self.request, Type.NETWORK, network.get("name"), Operator.CRATE_SUBNET, subnet.name) self.response(Response())
def update_network(self, network_id, params): """ Update network :param network_id: :param params: json: dns, name, gateway :return: """ network = yield get_network(network_id) if not network: raise NetworkNotExist change_info = {"name": ""} for key in change_info: change_info[key] = params[key] if key in params else "" change_info["id"] = network_id old_network = yield get_network(network_id) if not old_network: raise NetworkNotExist yield update_network(old_network, change_info) model_name = change_info["name"] if change_info[ "name"] else old_network["name"] optLog.write(self.request, Type.NETWORK, old_network["name"], Operator.UPDATE, model_name) LOG.debug( "Leave update_network, old network_id is %s, new network params is %s" % (network_id, params)) self.response(Response())
def update_app(self, app_serial, body): try: app_name = body['name'] description = body['description'] sql = ("UPDATE manor.manor_app_instance " "SET app_name='%s',app_description='%s' " "WHERE app_serial='%s'") % (app_name, description, app_serial) execute(sql) vms = yield list_app_resources(app_serial) for vm in vms: yield update_vm_display_name(vm['vm_id'], app_name) rs = yield DBUtil().query( ("select * from manor.manor_app_instance " "where app_serial='%s'") % app_serial) seq = rs[0]['app_id'] optLog.write(self.request, optLog.Type.APP_INSTANCE, seq, Operator.UPDATE, '%s' % app_name) self.response(generals.gen_response({'result': 'ok'})) except Exception as detail: logging.getLogger('manor').error(generals.trace()) raise detail
def update_host(self, hyper_id, ipmi): new_ipmi = host_package.Host(**ipmi) yield host_package.update_host(hyper_id, new_ipmi.__dict__) host = yield host_package.query_host(id=int(hyper_id)) optLog.write(self.request, Type.HOST, host[0]['name'], Operator.UPDATE, '') self.response(Response())
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 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 add_users(self, tenant_id, body): tenant = yield identify.get_tenant_by_id(tenant_id) for user_name in body: user = yield user_mapping(user_name) yield identify.add_tenant_user(tenant_id, user.get("id")) optLog.write(self.request, Type.TENANT, tenant['name'], Operator.ADD_USER, user['displayname']) self.response(Response())
def delete_tenant_host(self, tenant_id, host_id): yield delete_tenant_host(tenant_id, int(host_id)) host_info = yield list_simple_hosts(host_id=host_id) for host in host_info: pass tenant = yield get_tenant_by_id(tenant_id) optLog.write(self.request, Type.TENANT, tenant['name'], Operator.CONFIG_TENANT_DELETE_HOST, host['name']) self.response(Response())
def set_quota(self, tenant_id, body): tenant = yield identify.get_tenant_by_id(tenant_id) for quota in body: yield identify.update_quota_limit(tenant_id, name=quota['quota_name'], limit=quota['quota_limit']) optLog.write(self.request, Type.TENANT, tenant['name'], Operator.MODIFY_QUOTA, '') self.response(Response())
def set_tenant_subnet(self, tenant_id, body): subnet_ids = body['subnet_ids'] yield set_tenant_subnet(tenant_id, subnet_ids) tenant = yield get_tenant_by_id(tenant_id) for subnet_id in subnet_ids: subnet = yield get_subnet(subnet_id) optLog.write(self.request, Type.TENANT, tenant['name'], Operator.CONFIG_NETWORK, subnet['name']) self.response(Response())
def delete_tenant(self, tenant_id, internal=False): tenant = yield identify.get_tenant_by_id(tenant_id) if not tenant: raise TenantNotExist if internal: try: for name in identify.get_quota_names(): q = yield identify.get_quota(tenant_id, name) if q and q.get("quota_used") != 0: region = yield rg.list_region( CONF.keystone.region_name) raise TenantDeleteFailed(region[0].get("displayname")) yield identify.delete_quotas(tenant_id) yield delete_tnr_from_ecloud(tenant_id) except Exception as e: LOG.error("delete tenant error:%s" % e) LOG.error(trace()) raise e else: regions = yield rg.list_region() for region in regions: if region["region"] == CONF.keystone.region_name: for name in identify.get_quota_names(): q = yield identify.get_quota(tenant_id, name) if q.get("quota_used") != 0: raise TenantDeleteFailed() continue servers_url = "%s/tenant/%s?internal=true" % \ (region['url'], tenant_id) try: res = yield async_request(url=servers_url, token=get_token(self.request), body=None, method="DELETE") if res and res.get("success") is False and res.get( "msg") == TenantDeleteFailed.msg: raise TenantDeleteFailed except Exception as e: LOG.error( "delete tenant quota from another region error:%s" % e) LOG.error(trace()) if e.message == TenantDeleteFailed.msg: raise TenantDeleteFailed(args=[region['displayname']]) raise rg.RegionException(args=[region['displayname']]) try: yield identify.delete_quotas(tenant_id) yield delete_tnr_from_ecloud(tenant_id) yield identify.delete_tenant(tenant_id) except Exception as e: LOG.error("delete tenant error:%s" % e) LOG.error(trace()) region = yield rg.list_region(CONF.keystone.region_name) raise TenantDeleteFailed(region[0].get("displayname")) optLog.write(self.request, Type.TENANT, tenant['name'], Operator.DELETE, '') self.response(Response())
def create_network(self, params): """ Create network :param params: vlan params """ LOG.debug("Enter create_network, params is %s" % params) network_obj = Network(params) yield create_network(network_obj) optLog.write(self.request, Type.NETWORK, network_obj.name, Operator.CREATE, '') self.response(Response())
def delete_template(self, name): template_path = cfgutils.getval('app', 'template_path') with open('%s/%s.yaml' % (template_path, name)) as f: tmp = f.read() t_content = yaml.safe_load(tmp) template = '%s/%s.yaml' % (template_path, name) shutil.rmtree('%s/_%s' % (template_path, name)) os.remove(template) optLog.write(self.request, optLog.Type.APP_TEMPLATE, name, Operator.DELETE, '%s' % t_content['label']) self.response(generals.gen_response('ok'))
def set_tenant_hosts(self, tenant_id, body): hosts = body.get("host_ids") if not tenant_id: raise InvalidateParam hosts_info = yield list_simple_hosts(host_id=hosts) tenant = yield get_tenant_by_id(tenant_id) yield set_tenant_hosts(tenant_id, hosts) for host in hosts_info: optLog.write(self.request, Type.TENANT, tenant['name'], Operator.CONFIG_TENANT_ADD_HOST, host['name']) self.response(Response())
def update_tenant(self, tenant_id, body): tenant = yield identify.get_tenant_by_id(tenant_id) if not tenant: raise TenantNotExist db = dbpools.get_keystone() cur = yield db.execute("select name from project where id = %s ", (tenant_id, )) old_tenant_name = cur.fetchone() t = yield identify.update_tenant(tenant_id, **body) optLog.write(self.request, Type.TENANT, old_tenant_name['name'], Operator.UPDATE, t['name']) self.response(Response(result=t))
def delete_network(self, network_id): """ Delete network by id :param network_id: network's id """ network = yield get_network(network_id) if not network: raise NetworkNotExist yield delete_network(network_id) optLog.write(self.request, Type.NETWORK, network['name'], Operator.DELETE, '') self.response(Response())
def set_tenant_subnet_ips(self, subnet_id, tenant_id, body): ips = body.get("ips") if not tenant_id: raise InvalidateParam subnet = yield get_subnet(subnet_id) if not subnet: raise SubNetNotExist tenant = yield get_tenant_by_id(tenant_id) yield set_tenant_subnet_ips(subnet_id, tenant_id, ips) optLog.write(self.request, Type.TENANT, tenant['name'], Operator.CONFIG_TENANT_IP, subnet['name']) self.response(Response())
def license_upload(self): """ 上传凭证 :return: """ private_key = self.request.arguments.get("private_key")[0] result = license.license_upload(self, private_key) optLog.write(self.request, Type.LICENSE, "license", Operator.UPLOAD, "license") if result.get("date_interval") is False: self.response(Response(msg=LicenseOverdue.msg, success=False)) self.response(Response(result=result))
def delete_server_by_batch(self, batch): vm_info = yield compute.list_server(batch=batch, detailed=True, with_task=False) if not vm_info: raise VmNotExist(args=['batch', batch]) for info in vm_info: yield del_server(info["id"], delete_volume_ids=list()) optLog.write( self.request, Type.VM, str(info["name"]), Operator.DELETE, str(info["displayname"]) + " " + gen_network_comment(info['network'].values())) self.response(Response())
def update_snapshot_snapshot(self, snapshot_id, params): try: snapshot = yield snapshot_package.get_snapshot(snapshot_id) except BaseException as e: LOG.error("snapshot is not exist %s", e) LOG.error(trace()) raise SnapShotNotExist volume_name = yield snapshot_package.update_snapshot( snapshot_id, params.get("name"), params.get("des")) name = volume_name[len("ecloud-snapshot-"):] optLog.write(self.request, Type.SNAPSHOT, name, Operator.UPDATE, params.get("name")) self.response(Response())
def control_server(self, body): """ to start\stop\reboot instance :param body: """ ids = body['ids'] action = body['action'] LOG.debug("vm control action is %s starting", action) vmnames = yield compute.control(action, ids) LOG.debug("vm control action is %s end", action) for vm in vmnames: optLog.write( self.request, Type.VM, vm['name'], action, vm['displayname'] + " " + gen_network_comment(vm['network'].values())) self.response(Response())
def delete_snapshot(self, snapshot_id): """ :param snapshot_id: :return: """ snapshot = yield snapshot_package.get_snapshot(snapshot_id) if not snapshot: raise SnapShotNotExist snapshot_info = yield snapshot_package.delete_snapshot(snapshot_id) snapshot_name = snapshot_info["name"] name = snapshot_name[len("ecloud-snapshot-"):] optLog.write(self.request, Type.SNAPSHOT, name, Operator.DELETE, snapshot_info["metadata"].get("displayname", "")) 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 change_status(self, name, body): t_path = cfgutils.getval('app', 'template_path') with open('%s/%s.yaml' % (t_path, name)) as f: tmp = f.read() t_content = yaml.safe_load(tmp) value = json.loads(self.request.body)['value'] t_content['status'] = value tmp_f = str(uuid.uuid1()) with codecs.open('%s/%s' % (t_path, tmp_f), 'w', 'utf-8') as f: f.write(yaml.safe_dump(t_content)) os.rename('%s/%s' % (t_path, tmp_f), '%s/%s.yaml' % (t_path, name)) optLog.write(self.request, optLog.Type.APP_TEMPLATE, name, Operator.ONLINE if value == 1 else Operator.OFFLINE, '%s' % t_content['label']) self.response(generals.gen_response('ok'))
def remove_users(self, tenant_id): users = self.get_argument('users').split(',') tenant = yield identify.get_tenant_by_id(tenant_id) usernames = [] for user_id in users: user = yield identify.get_user_by_id(user_id) role = yield identify.get_user_role(user_id, tenant_id) yield identify.remove_tenant_user(tenant_id, user_id, role['id']) usernames.append(user['displayname']) # clear volumes of this user yield clear_user_volumes(tenant_id, user_id) # clear vms of this user yield clear_vm_user(tenant_id, user_id) optLog.write(self.request, Type.TENANT, tenant['name'], Operator.REMOVE_USER, user['displayname']) self.response(Response())
def delete_network_subnet(self, subnet_id): """ Delete network by id :param subnet_id: subnet's id """ LOG.debug("Enter delete_network_subnet, subnet_id is %s" % subnet_id) subnet = yield get_subnet(subnet_id) if not subnet: raise SubNetNotExist network = yield get_network(subnet.get("network_id")) if not network: raise NetworkNotExist yield delete_subnet(subnet_id) optLog.write(self.request, Type.NETWORK, network['name'], Operator.DELETE_SUBNET, subnet['name']) self.response(Response())
def recover_snapshot(self, snapshot_id): """ :param snapshot_id: :param params: :return: """ snapshot_info = yield snapshot_package.get_snapshot(snapshot_id, detailed=True) if not snapshot_info: raise SnapShotNotExist name = snapshot_info["name"][len("ecloud-snapshot-"):] restore_result = yield snapshot_package.snapshot_recover(snapshot_info) optLog.write(self.request, Type.SNAPSHOT, name, Operator.RESTORE, snapshot_info["metadata"].get("displayname", "")) LOG.debug("Leave restore_volume_snapshot method, id is %s" % id) self.response(Response(result={"result": restore_result}))
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