def resolve_commissions(self, token, accept_serials, reject_serials):
"""Resolve multiple commissions at once
Keyword arguments:
token -- service's token (string)
accept_serials -- commissions to accept (list of ints)
reject_serials -- commissions to reject (list of ints)
In case of success return a dict of dicts describing which
commissions accepted, which rejected and which failed to
resolved.
"""
check_input("resolve_commissions",
self.logger,
accept_serials=accept_serials,
reject_serials=reject_serials)
path = copy(API_COMMISSIONS_ACTION)
req_headers = {'content-type': 'application/json'}
req_body = parse_request(
{
"accept": accept_serials,
"reject": reject_serials
}, self.logger)
return self._call_astakos(token, path, req_headers, req_body, "POST")
def issue_one_commission(self, holder, provisions,
name="", force=False, auto_accept=False):
"""Issue one commission (with specific holder and source)
keyword arguments:
holder -- user's id (string)
provisions -- (source, resource) mapping to quantity
name -- description of the commission (string)
force -- force this commission (boolean)
auto_accept -- auto accept this commission (boolean)
In case of success return commission's id (int).
Otherwise raise an AstakosClientException.
"""
check_input("issue_one_commission", self.logger,
holder=holder, provisions=provisions)
request = {}
request["force"] = force
request["auto_accept"] = auto_accept
request["name"] = name
try:
request["provisions"] = []
for (source, resource), quantity in provisions.iteritems():
ps = self.mk_provisions(holder, source, resource, quantity)
request["provisions"].extend(ps)
except Exception as err:
self.logger.error(str(err))
raise BadValue(str(err))
return self._issue_commission(request)
def resolve_commissions(self, accept_serials, reject_serials):
"""Resolve multiple commissions at once
Keyword arguments:
accept_serials -- commissions to accept (list of ints)
reject_serials -- commissions to reject (list of ints)
In case of success return a dict of dicts describing which
commissions accepted, which rejected and which failed to
resolved.
"""
check_input("resolve_commissions",
self.logger,
accept_serials=accept_serials,
reject_serials=reject_serials)
req_headers = {'content-type': 'application/json'}
req_body = parse_request(
{
"accept": accept_serials,
"reject": reject_serials
}, self.logger)
return self._call_astakos(self.api_commissions_action,
headers=req_headers,
body=req_body,
method="POST")
def get_username(self, token, uuid):
"""Return the user name of a uuid (see get_usernames)"""
check_input("get_username", self.logger, uuid=uuid)
uuid_dict = self.get_usernames(token, [uuid])
if uuid in uuid_dict:
return uuid_dict.get(uuid)
else:
raise NoUserName(uuid)
def service_get_uuid(self, token, display_name):
"""Return the uuid of a name using a service's token"""
check_input("service_get_uuid", self.logger, display_name=display_name)
name_dict = self.service_get_uuids(token, [display_name])
if display_name in name_dict:
return name_dict.get(display_name)
else:
raise NoUUID(display_name)
def service_get_username(self, uuid):
"""Return the displayName of a uuid using a service's token"""
check_input("service_get_username", self.logger, uuid=uuid)
uuid_dict = self.service_get_usernames([uuid])
if uuid in uuid_dict:
return uuid_dict.get(uuid)
else:
raise NoUserName(uuid)
def get_username(self, uuid):
"""Return the user name of a uuid (see get_usernames)"""
check_input("get_username", self.logger, uuid=uuid)
uuid_dict = self.get_usernames([uuid])
if uuid in uuid_dict:
return uuid_dict.get(uuid)
else:
raise NoUserName(uuid)
def get_uuid(self, display_name):
"""Return the uuid of a name (see getUUIDs)"""
check_input("get_uuid", self.logger, display_name=display_name)
name_dict = self.get_uuids([display_name])
if display_name in name_dict:
return name_dict.get(display_name)
else:
raise NoUUID(display_name)
def service_get_uuid(self, display_name):
"""Return the uuid of a name using a service's token"""
check_input("service_get_uuid", self.logger, display_name=display_name)
name_dict = self.service_get_uuids([display_name])
if display_name in name_dict:
return name_dict.get(display_name)
else:
raise NoUUID(display_name)
def service_get_username(self, token, uuid):
"""Return the displayName of a uuid using a service's token"""
check_input("service_get_username", self.logger, uuid=uuid)
uuid_dict = self.service_get_usernames(token, [uuid])
if uuid in uuid_dict:
return uuid_dict.get(uuid)
else:
raise NoUserName(uuid)
def get_uuid(self, token, display_name):
"""Return the uuid of a name (see getUUIDs)"""
check_input("get_uuid", self.logger, display_name=display_name)
name_dict = self.get_uuids(token, [display_name])
if display_name in name_dict:
return name_dict.get(display_name)
else:
raise NoUUID(display_name)
def __init__(self,
token,
auth_url,
retry=0,
use_pool=False,
pool_size=8,
logger=None,
headers=None):
"""Initialize AstakosClient Class
Keyword arguments:
token -- user's/service's token (string)
auth_url -- i.e https://accounts.example.com/identity/v2.0
retry -- how many time to retry (integer)
use_pool -- use objpool for http requests (boolean)
pool_size -- if using pool, define the pool size
logger -- pass a different logger
"""
# Get logger
if logger is None:
logger = logging.getLogger("astakosclient")
logger.setLevel(logging.INFO)
logger.debug(
"Intialize AstakosClient: auth_url = %s, "
"use_pool = %s, pool_size = %s", auth_url, use_pool, pool_size)
# Check that token and auth_url (mandatory options) are given
check_input("__init__", logger, token=token, auth_url=auth_url)
# Initialize connection class
parsed_auth_url = urlparse.urlparse(auth_url)
conn_class = \
scheme_to_class(parsed_auth_url.scheme, use_pool, pool_size)
if conn_class is None:
msg = "Unsupported scheme: %s" % parsed_auth_url.scheme
logger.error(msg)
raise BadValue(msg)
# Save astakos base url, logger, connection class etc in our class
self.retry = retry
self.logger = logger
self.token = token
self.astakos_base_url = parsed_auth_url.netloc
self.scheme = parsed_auth_url.scheme
self.conn_class = conn_class
if headers is not None:
self.headers = copy(headers)
else:
self.headers = None
# Initialize astakos api prefixes
# API urls under auth_url
self.auth_prefix = parsed_auth_url.path
self.api_tokens = join_urls(self.auth_prefix, "tokens")
def get_commission_info(self, serial):
"""Get Description of a Commission
Keyword arguments:
serial -- commission's id (int)
In case of success return a dict of dicts containing
informations (details) about the requested commission
"""
check_input("get_commission_info", self.logger, serial=serial)
path = self.api_commissions.rstrip('/') + "/" + str(serial)
return self._call_astakos(path)
def get_commission_info(self, serial):
"""Get Description of a Commission
Keyword arguments:
serial -- commission's id (int)
In case of success return a dict of dicts containing
informations (details) about the requested commission
"""
check_input("get_commission_info", self.logger, serial=serial)
path = self.api_commissions.rstrip('/') + "/" + str(serial)
return self._call_astakos(path)
def issue_one_commission(self,
token,
holder,
source,
provisions,
name="",
force=False,
auto_accept=False):
"""Issue one commission (with specific holder and source)
keyword arguments:
token -- service's token (string)
holder -- user's id (string)
source -- commission's source (ex system) (string)
provisions -- resources with their quantity (dict from string to int)
name -- description of the commission (string)
force -- force this commission (boolean)
auto_accept -- auto accept this commission (boolean)
In case of success return commission's id (int).
Otherwise raise an AstakosClientException.
(See also issue_commission)
"""
check_input("issue_one_commission",
self.logger,
holder=holder,
source=source,
provisions=provisions)
request = {}
request["force"] = force
request["auto_accept"] = auto_accept
request["name"] = name
try:
request["provisions"] = []
for resource, quantity in provisions.iteritems():
t = {
"holder": holder,
"source": source,
"resource": resource,
"quantity": quantity
}
request["provisions"].append(t)
except Exception as err:
self.logger.error(str(err))
raise BadValue(str(err))
return self.issue_commission(token, request)
def get_commission_info(self, token, serial):
"""Get Description of a Commission
Keyword arguments:
token -- service's token (string)
serial -- commission's id (int)
In case of success return a dict of dicts containing
informations (details) about the requested commission
"""
check_input("get_commission_info", self.logger, serial=serial)
path = API_COMMISSIONS + "/" + str(serial)
return self._call_astakos(token, path)
def get_commission_info(self, token, serial):
"""Get Description of a Commission
Keyword arguments:
token -- service's token (string)
serial -- commission's id (int)
In case of success return a dict of dicts containing
informations (details) about the requested commission
"""
check_input("get_commission_info", self.logger, serial=serial)
path = API_COMMISSIONS + "/" + str(serial)
return self._call_astakos(token, path)
def send_feedback(self, message, data):
"""Send feedback to astakos service
keyword arguments:
message -- Feedback message
data -- Additional information about service client status
In case of success return nothing.
Otherwise raise an AstakosClientException
"""
check_input("send_feedback", self.logger, message=message, data=data)
req_body = urllib.urlencode(
{'feedback_msg': message, 'feedback_data': data})
self._call_astakos(self.api_feedback, headers=None,
body=req_body, method="POST")
def send_feedback(self, message, data):
"""Send feedback to astakos service
keyword arguments:
message -- Feedback message
data -- Additional information about service client status
In case of success return nothing.
Otherwise raise an AstakosClientException
"""
check_input("send_feedback", self.logger, message=message, data=data)
req_body = urllib.urlencode(
{'feedback_msg': message, 'feedback_data': data})
self._call_astakos(self.api_feedback, headers=None,
body=req_body, method="POST")
def send_feedback(self, token, message, data):
"""Send feedback to astakos service
keyword arguments:
token -- user's token (string)
message -- Feedback message
data -- Additional information about service client status
In case of success return nothing.
Otherwise raise an AstakosClientException
"""
check_input("send_feedback", self.logger, message=message, data=data)
path = copy(API_FEEDBACK)
req_body = urllib.urlencode(
{'feedback_msg': message, 'feedback_data': data})
self._call_astakos(token, path, None, req_body, "POST")
def __init__(self, token, auth_url,
retry=0, use_pool=False, pool_size=8, logger=None):
"""Initialize AstakosClient Class
Keyword arguments:
token -- user's/service's token (string)
auth_url -- i.e https://accounts.example.com/identity/v2.0
retry -- how many time to retry (integer)
use_pool -- use objpool for http requests (boolean)
pool_size -- if using pool, define the pool size
logger -- pass a different logger
"""
# Get logger
if logger is None:
logger = logging.getLogger("astakosclient")
logger.setLevel(logging.INFO)
logger.debug("Intialize AstakosClient: auth_url = %s, "
"use_pool = %s, pool_size = %s",
auth_url, use_pool, pool_size)
# Check that token and auth_url (mandatory options) are given
check_input("__init__", logger, token=token, auth_url=auth_url)
# Initialize connection class
parsed_auth_url = urlparse.urlparse(auth_url)
conn_class = \
scheme_to_class(parsed_auth_url.scheme, use_pool, pool_size)
if conn_class is None:
msg = "Unsupported scheme: %s" % parsed_auth_url.scheme
logger.error(msg)
raise BadValue(msg)
# Save astakos base url, logger, connection class etc in our class
self.retry = retry
self.logger = logger
self.token = token
self.astakos_base_url = parsed_auth_url.netloc
self.scheme = parsed_auth_url.scheme
self.conn_class = conn_class
# Initialize astakos api prefixes
# API urls under auth_url
self.auth_prefix = parsed_auth_url.path
self.api_tokens = join_urls(self.auth_prefix, "tokens")
def commission_action(self, token, serial, action):
"""Perform a commission action
Keyword arguments:
token -- service's token (string)
serial -- commission's id (int)
action -- action to perform, currently accept/reject (string)
In case of success return nothing.
"""
check_input("commission_action", self.logger,
serial=serial, action=action)
path = API_COMMISSIONS + "/" + str(serial) + "/action"
req_headers = {'content-type': 'application/json'}
req_body = parse_request({str(action): ""}, self.logger)
self._call_astakos(token, path, req_headers, req_body, "POST")
def commission_action(self, serial, action):
"""Perform a commission action
Keyword arguments:
serial -- commission's id (int)
action -- action to perform, currently accept/reject (string)
In case of success return nothing.
"""
check_input("commission_action", self.logger,
serial=serial, action=action)
path = self.api_commissions.rstrip('/') + "/" + str(serial) + "/action"
req_headers = {'content-type': 'application/json'}
req_body = parse_request({str(action): ""}, self.logger)
self._call_astakos(path, headers=req_headers,
body=req_body, method="POST")
def commission_action(self, serial, action):
"""Perform a commission action
Keyword arguments:
serial -- commission's id (int)
action -- action to perform, currently accept/reject (string)
In case of success return nothing.
"""
check_input("commission_action", self.logger,
serial=serial, action=action)
path = self.api_commissions.rstrip('/') + "/" + str(serial) + "/action"
req_headers = {'content-type': 'application/json'}
req_body = parse_request({str(action): ""}, self.logger)
self._call_astakos(path, headers=req_headers,
body=req_body, method="POST")
def send_feedback(self, token, message, data):
"""Send feedback to astakos service
keyword arguments:
token -- user's token (string)
message -- Feedback message
data -- Additional information about service client status
In case of success return nothing.
Otherwise raise an AstakosClientException
"""
check_input("send_feedback", self.logger, message=message, data=data)
path = copy(API_FEEDBACK)
req_body = urllib.urlencode({
'feedback_msg': message,
'feedback_data': data
})
self._call_astakos(token, path, None, req_body, "POST")
def commission_action(self, token, serial, action):
"""Perform a commission action
Keyword arguments:
token -- service's token (string)
serial -- commission's id (int)
action -- action to perform, currently accept/reject (string)
In case of success return nothing.
"""
check_input("commission_action",
self.logger,
serial=serial,
action=action)
path = API_COMMISSIONS + "/" + str(serial) + "/action"
req_headers = {'content-type': 'application/json'}
req_body = parse_request({str(action): ""}, self.logger)
self._call_astakos(token, path, req_headers, req_body, "POST")
def __init__(self,
astakos_url,
retry=0,
use_pool=False,
pool_size=8,
logger=None):
"""Initialize AstakosClient Class
Keyword arguments:
astakos_url -- i.e https://accounts.example.com (string)
use_pool -- use objpool for http requests (boolean)
retry -- how many time to retry (integer)
logger -- pass a different logger
"""
if logger is None:
logging.basicConfig(
format='%(asctime)s [%(levelname)s] %(name)s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
level=logging.INFO)
logger = logging.getLogger("astakosclient")
logger.debug("Intialize AstakosClient: astakos_url = %s, "
"use_pool = %s" % (astakos_url, use_pool))
check_input("__init__", logger, astakos_url=astakos_url)
# Check for supported scheme
p = urlparse.urlparse(astakos_url)
conn_class = scheme_to_class(p.scheme, use_pool, pool_size)
if conn_class is None:
m = "Unsupported scheme: %s" % p.scheme
logger.error(m)
raise BadValue(m)
# Save astakos_url etc. in our class
self.retry = retry
self.logger = logger
self.netloc = p.netloc
self.scheme = p.scheme
self.path = p.path.rstrip('/')
self.conn_class = conn_class
def resolve_commissions(self, accept_serials, reject_serials):
"""Resolve multiple commissions at once
Keyword arguments:
accept_serials -- commissions to accept (list of ints)
reject_serials -- commissions to reject (list of ints)
In case of success return a dict of dicts describing which
commissions accepted, which rejected and which failed to
resolved.
"""
check_input("resolve_commissions", self.logger,
accept_serials=accept_serials,
reject_serials=reject_serials)
req_headers = {'content-type': 'application/json'}
req_body = parse_request({"accept": accept_serials,
"reject": reject_serials},
self.logger)
return self._call_astakos(self.api_commissions_action,
headers=req_headers, body=req_body,
method="POST")
def resolve_commissions(self, token, accept_serials, reject_serials):
"""Resolve multiple commissions at once
Keyword arguments:
token -- service's token (string)
accept_serials -- commissions to accept (list of ints)
reject_serials -- commissions to reject (list of ints)
In case of success return a dict of dicts describing which
commissions accepted, which rejected and which failed to
resolved.
"""
check_input("resolve_commissions", self.logger,
accept_serials=accept_serials,
reject_serials=reject_serials)
path = copy(API_COMMISSIONS_ACTION)
req_headers = {'content-type': 'application/json'}
req_body = parse_request({"accept": accept_serials,
"reject": reject_serials},
self.logger)
return self._call_astakos(token, path, req_headers, req_body, "POST")
def __init__(self, astakos_url, retry=0,
use_pool=False, pool_size=8, logger=None):
"""Initialize AstakosClient Class
Keyword arguments:
astakos_url -- i.e https://accounts.example.com (string)
use_pool -- use objpool for http requests (boolean)
retry -- how many time to retry (integer)
logger -- pass a different logger
"""
if logger is None:
logging.basicConfig(
format='%(asctime)s [%(levelname)s] %(name)s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
level=logging.INFO)
logger = logging.getLogger("astakosclient")
logger.debug("Intialize AstakosClient: astakos_url = %s, "
"use_pool = %s" % (astakos_url, use_pool))
check_input("__init__", logger, astakos_url=astakos_url)
# Check for supported scheme
p = urlparse.urlparse(astakos_url)
conn_class = scheme_to_class(p.scheme, use_pool, pool_size)
if conn_class is None:
m = "Unsupported scheme: %s" % p.scheme
logger.error(m)
raise BadValue(m)
# Save astakos_url etc. in our class
self.retry = retry
self.logger = logger
self.netloc = p.netloc
self.scheme = p.scheme
self.path = p.path.rstrip('/')
self.conn_class = conn_class
def issue_one_commission(self, token, holder, source, provisions,
name="", force=False, auto_accept=False):
"""Issue one commission (with specific holder and source)
keyword arguments:
token -- service's token (string)
holder -- user's id (string)
source -- commission's source (ex system) (string)
provisions -- resources with their quantity (dict from string to int)
name -- description of the commission (string)
force -- force this commission (boolean)
auto_accept -- auto accept this commission (boolean)
In case of success return commission's id (int).
Otherwise raise an AstakosClientException.
(See also issue_commission)
"""
check_input("issue_one_commission", self.logger,
holder=holder, source=source,
provisions=provisions)
request = {}
request["force"] = force
request["auto_accept"] = auto_accept
request["name"] = name
try:
request["provisions"] = []
for resource, quantity in provisions.iteritems():
t = {"holder": holder, "source": source,
"resource": resource, "quantity": quantity}
request["provisions"].append(t)
except Exception as err:
self.logger.error(str(err))
raise BadValue(str(err))
return self.issue_commission(token, request)
