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