def get_users(self, req): user_name = req.GET["name"] if "name" in req.GET else None if user_name: tenant = self.identity_service.get_user_by_name( utils.get_auth_token(req), user_name) return utils.send_result(200, req, tenant) else: marker, limit, url = self.get_marker_limit_and_url(req) users = self.identity_service.get_users(utils.get_auth_token(req), marker, limit, url) return utils.send_result(200, req, users)
def get_services(self, req): service_name = req.GET["name"] if "name" in req.GET else None if service_name: tenant = self.identity_service.get_service_by_name( utils.get_auth_token(req), service_name) return utils.send_result(200, req, tenant) else: marker, limit, url = self.get_marker_limit_and_url(req) services = self.identity_service.get_services( utils.get_auth_token(req), marker, limit, url) return utils.send_result(200, req, services)
def get_endpoint_templates(self, req): marker, limit, url = self.get_marker_limit_and_url(req) service_id = req.GET["serviceId"] if "serviceId" in req.GET else None if service_id: endpoint_templates = self.identity_service.\ get_endpoint_templates_by_service( utils.get_auth_token(req), service_id, marker, limit, url) else: endpoint_templates = self.identity_service.get_endpoint_templates( utils.get_auth_token(req), marker, limit, url) return utils.send_result(200, req, endpoint_templates)
def get_roles(self, req): role_name = req.GET["name"] if "name" in req.GET else None if role_name: tenant = config.SERVICE.get_role_by_name( utils.get_auth_token(req), role_name) return utils.send_result(200, req, tenant) else: marker, limit, url = get_marker_limit_and_url(req) roles = config.SERVICE.get_roles( utils.get_auth_token(req), marker, limit, url) return utils.send_result(200, req, roles)
def get_tenants(self, req): tenant_name = req.GET["name"] if "name" in req.GET else None if tenant_name: tenant = self.identity_service.get_tenant_by_name(utils.get_auth_token(req), tenant_name) return utils.send_result(200, req, tenant) else: marker, limit, url = self.get_marker_limit_and_url(req) tenants = self.identity_service.get_tenants( utils.get_auth_token(req), marker, limit, url, self.is_service_operation ) return utils.send_result(200, req, tenants)
def __get_all_roles(self, req): service_id = req.GET["serviceId"] if "serviceId" in req.GET else None marker, limit, url = self.get_marker_limit_and_url(req) if service_id: roles = self.identity_service.get_roles_by_service( utils.get_auth_token(req), marker, limit, url, service_id) return utils.send_result(200, req, roles) else: roles = self.identity_service.get_roles(utils.get_auth_token(req), marker, limit, url) return utils.send_result(200, req, roles)
def get_tenants(self, req): tenant_name = req.GET["name"] if "name" in req.GET else None if tenant_name: tenant = self.identity_service.get_tenant_by_name( utils.get_auth_token(req), tenant_name) return utils.send_result(200, req, tenant) else: marker, limit, url = self.get_marker_limit_and_url(req) tenants = self.identity_service.get_tenants( utils.get_auth_token(req), marker, limit, url, self.is_service_operation) return utils.send_result(200, req, tenants)
def __get_all_roles(self, req): service_id = req.GET["serviceId"] if "serviceId" in req.GET else None marker, limit, url = self.get_marker_limit_and_url(req) if service_id: roles = self.identity_service.get_roles_by_service( utils.get_auth_token(req), marker, limit, url, service_id) return utils.send_result(200, req, roles) else: roles = self.identity_service.get_roles( utils.get_auth_token(req), marker, limit, url) return utils.send_result(200, req, roles)
def modify_endpoint_template(self, req, endpoint_template_id): endpoint_template = utils.\ get_normalized_request_content(EndpointTemplate, req) return utils.send_result(201, req, self.identity_service.modify_endpoint_template(\ utils.get_auth_token(req), endpoint_template_id, endpoint_template))
def modify_endpoint_template(self, req, endpoint_template_id): endpoint_template = utils.\ get_normalized_request_content(EndpointTemplate, req) return utils.send_result(201, req, config.SERVICE.modify_endpoint_template(\ utils.get_auth_token(req), endpoint_template_id, endpoint_template))
def validate_token(self, req, token_id): belongs_to = req.GET.get("belongsTo", None) rval = config.SERVICE.validate_token( utils.get_auth_token(req), token_id, belongs_to) return utils.send_result(200, req, rval)
def add_endpoint_template(self, req): endpoint_template = utils.get_normalized_request_content( EndpointTemplate, req) return utils.send_result( 201, req, config.SERVICE.add_endpoint_template(utils.get_auth_token(req), endpoint_template))
def add_endpoint_template(self, req): endpoint_template = utils.get_normalized_request_content( EndpointTemplate, req) return utils.send_result( 201, req, self.identity_service.add_endpoint_template( utils.get_auth_token(req), endpoint_template))
def delete_token(self, req, token_id): if CONF.disable_tokens_in_url: fault.ServiceUnavailableFault() else: return utils.send_result(204, req, self.identity_service.revoke_token( utils.get_auth_token(req), token_id))
def validate_token(self, req, token_id): belongs_to = None if "belongsTo" in req.GET: belongs_to = req.GET["belongsTo"] rval = service.validate_token(utils.get_auth_token(req), token_id, belongs_to) return utils.send_result(200, req, rval)
def endpoints(self, req, token_id): if CONF.disable_tokens_in_url: fault.ServiceUnavailableFault() else: marker, limit, url = self.get_marker_limit_and_url(req) return utils.send_result(200, req, self.identity_service.get_endpoints_for_token( utils.get_auth_token(req), token_id, marker, limit, url))
def _validate_token(self, req, token_id): """Validates the token, and that it belongs to the specified tenant""" belongs_to = req.GET.get('belongsTo') service_ids = None if extension_reader.is_extension_supported(self.options, 'hpidm'): # service IDs are only relevant if hpidm extension is enabled service_ids = req.GET.get('HP-IDM-serviceId') return self.identity_service.validate_token( utils.get_auth_token(req), token_id, belongs_to, service_ids)
def _validate_token(self, req, token_id): """Validates the token, and that it belongs to the specified tenant""" belongs_to = req.GET.get('belongsTo') service_ids = None if extension_reader.is_extension_supported(self.options, 'hpidm'): # service IDs are only relevant if hpidm extension is enabled service_ids = req.GET.get('HP-IDM-serviceId') return self.identity_service.validate_token(utils.get_auth_token(req), token_id, belongs_to, service_ids)
def create_user_bill(self, req): LOG.info( 'Before get_normalization Creating creat_instance_bill (self, req,) controller.biller.py' ) u = utils.get_normalized_request_content(User_Bill, req) LOG.info( 'Creating creat_instacne (self, req,) controller.biller.py id :%s : name: %s |enable:%s cpu:%s' % (u.id, u.tenant_id, u.enabled, u.total_vcpu)) return utils.send_result( 201, req, config.SERVICE.create_user_bill(utils.get_auth_token(req), u))
def create_billunit(self, req): LOG.info( 'Before get_normalization Creating creat_billunit (self, req,) controller.biller.py' ) u = utils.get_normalized_request_content(Bill_Unit, req) LOG.info( 'Creating creat_billunit (self, req,) controller.biller.py :date: %s |enable:%s cpu:%s' % (u.date, u.enabled, u.vcpu)) return utils.send_result( 201, req, config.SERVICE.create_bill_unit(utils.get_auth_token(req), u))
def get_tenant_users(self, req, tenant_id): marker = None if "marker" in req.GET: marker = req.GET["marker"] if "limit" in req.GET: limit = req.GET["limit"] else: limit = 10 url = "%s://%s:%s%s" % ( req.environ["wsgi.url_scheme"], req.environ.get("SERVER_NAME"), req.environ.get("SERVER_PORT"), req.environ["PATH_INFO"], ) users = service.get_tenant_users(utils.get_auth_token(req), tenant_id, marker, limit, url) return utils.send_result(200, req, users)
def get_tenant_users(self, req, tenant_id): marker, limit, url = self.get_marker_limit_and_url(req) role_id = req.GET["roleId"] if "roleId" in req.GET else None users = self.identity_service.get_tenant_users( utils.get_auth_token(req), tenant_id, role_id, marker, limit, url) return utils.send_result(200, req, users)
def delete_user(self, req, user_id): rval = self.identity_service.delete_user(utils.get_auth_token(req), user_id) return utils.send_result(204, req, rval)
def remove_baseurls_from_tenant(self, req, tenant_id, baseurls_ref_id): rval = service.delete_baseurls_ref(utils.get_auth_token(req), baseurls_ref_id) return utils.send_result(204, req, rval)
def get_baseurls(self, req): marker, limit, url = get_marker_limit_and_url(req) baseURLs = service.get_baseurls(utils.get_auth_token(req), marker, limit, url) return utils.send_result(200, req, baseURLs)
def get_baseurls_for_tenant(self, req, tenant_id): marker, limit, url = get_marker_limit_and_url(req) baseURLRefs = service.get_tenant_baseURLs(utils.get_auth_token(req), marker, limit, url, tenant_id) return utils.send_result(200, req, baseURLRefs)
def __get_roles_by_name(self, req, role_name): tenant = self.identity_service.get_role_by_name( utils.get_auth_token(req), role_name) return utils.send_result(200, req, tenant)
def add_role_to_user(self, req, user_id, role_id, tenant_id=None): self.identity_service.add_role_to_user(utils.get_auth_token(req), user_id, role_id, tenant_id) return utils.send_result(201, None)
def get_tenant_users(self, req, tenant_id): marker, limit, url = get_marker_limit_and_url(req) users = config.SERVICE.get_tenant_users(utils.get_auth_token(req), tenant_id, marker, limit, url) return utils.send_result(200, req, users)
def get_token_by_eppn(self, req, eppn): auth = config.SERVICE.get_token_by_eppn(utils.get_auth_token(req), eppn) return utils.send_result(200, req, auth)
def update_user_tenant(self, req, user_id): user = utils.get_normalized_request_content(User_Update, req) rval = config.SERVICE.set_user_tenant(utils.get_auth_token(req), user_id, user) return utils.send_result(200, req, rval)
def get_user_roles(self, req, user_id, tenant_id=None): marker, limit, url = self.get_marker_limit_and_url(req) roles = self.identity_service.get_user_roles(utils.get_auth_token(req), marker, limit, url, user_id, tenant_id) return utils.send_result(200, req, roles)
def delete_role_from_user(self, req, user_id, role_id, tenant_id=None): self.identity_service.remove_role_from_user(utils.get_auth_token(req), user_id, role_id, tenant_id) return utils.send_result(204, req, None)
def get_role(self, req, role_id): role = config.SERVICE.get_role(utils.get_auth_token(req), role_id) return utils.send_result(200, req, role)
def get_roles(self, req): marker, limit, url = get_marker_limit_and_url(req) roles = service.get_roles(utils.get_auth_token(req), marker, limit, url) return utils.send_result(200, req, roles)
def get_role_refs(self, req, user_id): marker, limit, url = get_marker_limit_and_url(req) roleRefs = config.SERVICE.get_user_roles( utils.get_auth_token(req), marker, limit, url, user_id) return utils.send_result(200, req, roleRefs)
def get_role(self, req, role_id): role = self.identity_service.get_role(utils.get_auth_token(req), role_id) return utils.send_result(200, req, role)
def create_role(self, req): role = utils.get_normalized_request_content(roles.Role, req) return utils.send_result(201, req, service.create_role(utils.get_auth_token(req), role))
def test_get_auth_token(self): self.request.headers["X-Auth-Token"] = "Test token" self.assertTrue(utils.get_auth_token(self.request), "Test Token")
def get_role(self, req, role_id): role = service.get_role(utils.get_auth_token(req), role_id) return utils.send_result(200, req, role)
def create_tenant(self, req): tenant = utils.get_normalized_request_content(Tenant, req) return utils.send_result(201, req, self.identity_service.create_tenant(utils.get_auth_token(req), tenant))
def get_baseurl(self, req, baseURLId): baseurl = service.get_baseurl(utils.get_auth_token(req), baseURLId) return utils.send_result(200, req, baseurl)
def get_tenant(self, req, tenant_id): tenant = self.identity_service.get_tenant(utils.get_auth_token(req), tenant_id) return utils.send_result(200, req, tenant)
def add_baseurls_to_tenant(self, req, tenant_id): baseurl = utils.get_normalized_request_content(baseURLs.BaseURL, req) return utils.send_result(201, req, service.create_baseurl_ref_to_tenant( utils.get_auth_token(req), tenant_id, baseurl, get_url(req)))
def update_tenant(self, req, tenant_id): tenant = utils.get_normalized_request_content(Tenant, req) rval = self.identity_service.update_tenant(utils.get_auth_token(req), tenant_id, tenant) return utils.send_result(200, req, rval)
def create_user(self, req): u = utils.get_normalized_request_content(User, req) return utils.send_result( 201, req, self.identity_service.create_user(utils.get_auth_token(req), u))
def delete_tenant(self, req, tenant_id): rval = self.identity_service.delete_tenant(utils.get_auth_token(req), tenant_id) return utils.send_result(204, req, rval)
def get_user(self, req, user_id): user = self.identity_service.get_user(utils.get_auth_token(req), user_id) return utils.send_result(200, req, user)
def update_group(self, req, group_id): group = utils.get_normalized_request_content(tenants.GlobalGroup, req) rval = service.update_global_group(utils.get_auth_token(req), group_id, group) return utils.send_result(200, req, rval)
def update_user_tenant(self, req, user_id): user = utils.get_normalized_request_content(User_Update, req) rval = self.identity_service.set_user_tenant(utils.get_auth_token(req), user_id, user) return utils.send_result(200, req, rval)
def delete_group(self, req, group_id): rval = service.delete_global_group(utils.get_auth_token(req), group_id) return utils.send_result(204, req, rval)
def create_role(self, req): role = utils.get_normalized_request_content(Role, req) return utils.send_result(201, req, config.SERVICE.create_role(utils.get_auth_token(req), role))
def get_users_global_group(self, req, group_id): marker, limit, url = get_marker_limit_and_url(req) users = service.get_users_global_group(utils.get_auth_token(req), group_id, marker, limit, url) return utils.send_result(200, req, users)
def create_role_ref(self, req, user_id): roleRef = utils.get_normalized_request_content(RoleRef, req) return utils.send_result(201, req, config.SERVICE.create_role_ref( utils.get_auth_token(req), user_id, roleRef))
def delete_user_global_group(self, req, group_id, user_id): return utils.send_result(204, req, service.delete_user_global_group(\ utils.get_auth_token(req), group_id, user_id))
def delete_role_ref(self, req, user_id, role_ref_id): rval = config.SERVICE.delete_role_ref(utils.get_auth_token(req), role_ref_id) return utils.send_result(204, req, rval)
def create_role(self, req): role = utils.get_normalized_request_content(Role, req) return utils.send_result( 201, req, self.identity_service.create_role(utils.get_auth_token(req), role))