Refactored

Author: rohe

src/oidcrp/client_auth.py

@@ -92,15 +92,15 @@ def _get_passwd(request, service, **kwargs):
             try:
                 passwd = request["client_secret"]
             except KeyError:
-                passwd = service.get_service_context().client_secret
+                passwd = service.entity_get("service_context").client_secret
         return passwd
 
     @staticmethod
     def _get_user(service, **kwargs):
         try:
             user = kwargs["user"]
         except KeyError:
-            user = service.get_service_context().client_id
+            user = service.entity_get("service_context").client_id
         return user
 
     def _get_authentication_token(self, request, service, **kwargs):
@@ -133,7 +133,7 @@ def _with_or_without_client_id(request, service):
             'grant_type'] == 'authorization_code':
             if 'client_id' not in request:
                 try:
-                    request['client_id'] = service.get_service_context().client_id
+                    request['client_id'] = service.entity_get("service_context").client_id
                 except AttributeError:
                     pass
         else:
@@ -210,7 +210,7 @@ def modify_request(self, request, service, **kwargs):
         :param request: The request
         :param service: The service that is using this authentication method
         """
-        _context = service.get_service_context()
+        _context = service.entity_get("service_context")
         if "client_secret" not in request:
             try:
                 request["client_secret"] = kwargs["client_secret"]
@@ -268,7 +268,7 @@ def find_token(request, token_type, service, **kwargs):
     except KeyError:
         # I should pick the latest acquired token, this should be the right
         # order for that.
-        _arg = service.get_service_context().state.multiple_extend_request_args(
+        _arg = service.entity_get("service_context").state.multiple_extend_request_args(
             {}, kwargs['key'], ['access_token'],
             ['auth_response', 'token_response', 'refresh_token_response'])
         return _arg['access_token']
@@ -481,7 +481,7 @@ def _get_audience_and_algorithm(self, context, **kwargs):
         return audience, algorithm
 
     def _construct_client_assertion(self, service, **kwargs):
-        _context = service.get_service_context()
+        _context = service.entity_get("service_context")
 
         audience, algorithm = self._get_audience_and_algorithm(_context, **kwargs)
 

src/oidcrp/entity.py

@@ -51,15 +51,30 @@ def __init__(self,
         _srvs = services or DEFAULT_SERVICES
 
         self._service = init_services(service_definitions=_srvs,
-                                      get_service_context=self.get_service_context,
-                                      get_services=self.get_services,
+                                      entity_get=self.entity_get,
                                       client_authn_factory=_cam)
 
-    def get_services(self):
+    def entity_get(self, what, *arg):
+        _func = getattr(self, "get_{}".format(what), None)
+        if _func:
+            return _func(*arg)
+        return None
+
+    def get_services(self, *arg):
         return self._service
 
-    def get_service_context(self):
+    def get_service_context(self, *arg):
         return self._service_context
 
-    def get_service(self, service_name):
-        return self._service[service_name]
+    def get_service(self, service_name, *arg):
+        try:
+            return self._service[service_name]
+        except KeyError:
+            return None
+
+    def get_service_by_endpoint_name(self, endpoint_name, *arg):
+        for service in self._service.values():
+            if service.endpoint_name == endpoint_name:
+                return service
+
+        return None

src/oidcrp/oauth2/__init__.py

@@ -118,7 +118,7 @@ def get_response(self, service, url, method="GET", body=None, response_body_type
 
         if resp.status_code < 300:
             if "keyjar" not in kwargs:
-                kwargs["keyjar"] = service.get_service_context().keyjar
+                kwargs["keyjar"] = service.entity_get("service_context").keyjar
             if not response_body_type:
                 response_body_type = service.response_body_type
 

src/oidcrp/oauth2/access_token.py

@@ -24,15 +24,15 @@ class AccessToken(Service):
     request_body_type = 'urlencoded'
     response_body_type = 'json'
 
-    def __init__(self, get_service_context, get_services, client_authn_factory=None, conf=None):
-        Service.__init__(self, get_service_context, get_services,
+    def __init__(self, entity_get, client_authn_factory=None, conf=None):
+        Service.__init__(self, entity_get,
                          client_authn_factory=client_authn_factory, conf=conf)
         self.pre_construct.append(self.oauth_pre_construct)
 
     def update_service_context(self, resp, key='', **kwargs):
         if 'expires_in' in resp:
             resp['__expires_at'] = time_sans_frac() + int(resp['expires_in'])
-        self.get_service_context().state.store_item(resp, 'token_response', key)
+        self.entity_get("service_context").state.store_item(resp, 'token_response', key)
 
     def oauth_pre_construct(self, request_args=None, post_args=None, **kwargs):
         """
@@ -44,7 +44,7 @@ def oauth_pre_construct(self, request_args=None, post_args=None, **kwargs):
         _state = get_state_parameter(request_args, kwargs)
         parameters = list(self.msg_type.c_param.keys())
 
-        _context = self.get_service_context()
+        _context = self.entity_get("service_context")
         _args = _context.state.extend_request_args({}, oauth2.AuthorizationRequest,
                                                    'auth_request', _state, parameters)
 

src/oidcrp/oauth2/add_on/dpop.py

@@ -156,7 +156,7 @@ def add_support(services, signing_algorithms: Optional[list] = None):
     """
 
     _service = services["accesstoken"]
-    _service.get_service_context().add_on['dpop'] = {
+    _service.entity_get("service_context").add_on['dpop'] = {
         # "key": key_by_alg(signing_algorithm),
         "sign_algs": signing_algorithms
     }

src/oidcrp/oauth2/add_on/pkce.py

@@ -22,7 +22,7 @@ def add_code_challenge(request_args, service, **kwargs):
     :param kwargs: Extra set of keyword arguments
     :return: Updated set of request arguments
     """
-    _context = service.get_service_context()
+    _context = service.entity_get("service_context")
     _kwargs = _context.add_on["pkce"]
 
     try:
@@ -74,7 +74,7 @@ def add_code_verifier(request_args, service, **kwargs):
     _state = request_args.get('state')
     if _state is None:
         _state = kwargs.get('state')
-    _item = service.get_service_context().state.get_item(Message, 'pkce', _state)
+    _item = service.entity_get("service_context").state.get_item(Message, 'pkce', _state)
     request_args.update({'code_verifier': _item['code_verifier']})
     return request_args
 
@@ -96,7 +96,7 @@ def add_support(service, code_challenge_length, code_challenge_method):
     """
     if "authorization" in service and "accesstoken" in service:
         _service = service["authorization"]
-        _context = _service.get_service_context()
+        _context = _service.entity_get("service_context")
         _context.add_on['pkce'] = {
             "code_challenge_length": code_challenge_length,
             "code_challenge_method": code_challenge_method

src/oidcrp/oauth2/add_on/pushed_authorization.py

@@ -15,7 +15,7 @@ def push_authorization(request_args, service, **kwargs):
     :param kwargs: Extra keyword arguments.
     """
 
-    _context = service.get_service_context()
+    _context = service.entity_get("service_context")
     method_args = _context.add_on["pushed_authorization"]
 
     # construct the message body
@@ -64,7 +64,7 @@ def add_support(services, body_format="jws", signing_algorithm="RS256",
         http_client = requests
 
     _service = services["authorization"]
-    _service.get_service_context().add_on['pushed_authorization'] = {
+    _service.entity_get("service_context").add_on['pushed_authorization'] = {
         "body_format": body_format,
         "signing_algorithm": signing_algorithm,
         "http_client": http_client,

src/oidcrp/oauth2/authorization.py

@@ -29,29 +29,29 @@ class Authorization(Service):
     #     "endpoint": ""
     # })
 
-    def __init__(self, get_service_context, get_services, client_authn_factory=None, conf=None):
-        Service.__init__(self, get_service_context, get_services,
+    def __init__(self, entity_get, client_authn_factory=None, conf=None):
+        Service.__init__(self, entity_get,
                          client_authn_factory=client_authn_factory, conf=conf)
         self.pre_construct.extend([pick_redirect_uris, set_state_parameter])
         self.post_construct.append(self.store_auth_request)
 
     def update_service_context(self, resp, key='', **kwargs):
         if 'expires_in' in resp:
             resp['__expires_at'] = time_sans_frac() + int(resp['expires_in'])
-        self.get_service_context().state.store_item(resp, 'auth_response', key)
+        self.entity_get("service_context").state.store_item(resp, 'auth_response', key)
 
     def store_auth_request(self, request_args=None, **kwargs):
         """Store the authorization request in the state DB."""
         _key = get_state_parameter(request_args, kwargs)
-        self.get_service_context().state.store_item(request_args, 'auth_request', _key)
+        self.entity_get("service_context").state.store_item(request_args, 'auth_request', _key)
         return request_args
 
     def gather_request_args(self, **kwargs):
         ar_args = Service.gather_request_args(self, **kwargs)
 
         if 'redirect_uri' not in ar_args:
             try:
-                ar_args['redirect_uri'] = self.get_service_context().redirect_uris[0]
+                ar_args['redirect_uri'] = self.entity_get("service_context").redirect_uris[0]
             except (KeyError, AttributeError):
                 raise MissingParameter('redirect_uri')
 
@@ -74,7 +74,7 @@ def post_parse_response(self, response, **kwargs):
                 pass
             else:
                 if _key:
-                    item = self.get_service_context().state.get_item(oauth2.AuthorizationRequest,
+                    item = self.entity_get("service_context").state.get_item(oauth2.AuthorizationRequest,
                                                                      'auth_request', _key)
                     try:
                         response["scope"] = item["scope"]

src/oidcrp/oauth2/client_credentials/cc_access_token.py

@@ -17,11 +17,11 @@ class CCAccessToken(Service):
     request_body_type = 'urlencoded'
     response_body_type = 'json'
 
-    def __init__(self, get_service_context, get_services, client_authn_factory=None, conf=None):
-        Service.__init__(self, get_service_context, get_services,
+    def __init__(self, entity_get, client_authn_factory=None, conf=None):
+        Service.__init__(self, entity_get,
                          client_authn_factory=client_authn_factory, conf=conf)
 
     def update_service_context(self, resp, key='cc', **kwargs):
         if 'expires_in' in resp:
             resp['__expires_at'] = time_sans_frac() + int(resp['expires_in'])
-        self.get_service_context().state.store_item(resp, 'token_response', key)
+        self.entity_get('service_context').state.store_item(resp, 'token_response', key)

src/oidcrp/oauth2/client_credentials/cc_refresh_access_token.py

@@ -15,16 +15,16 @@ class CCRefreshAccessToken(Service):
     default_authn_method = 'bearer_header'
     http_method = 'POST'
 
-    def __init__(self, get_service_context, get_services, client_authn_factory=None, conf=None):
-        Service.__init__(self, get_service_context, get_services,
+    def __init__(self, entity_get, client_authn_factory=None, conf=None):
+        Service.__init__(self, entity_get,
                          client_authn_factory=client_authn_factory, conf=conf)
         self.pre_construct.append(self.cc_pre_construct)
         self.post_construct.append(self.cc_post_construct)
 
     def cc_pre_construct(self, request_args=None, **kwargs):
         _state_id = kwargs.get("state", "cc")
         parameters = ['refresh_token']
-        _state_interface = self.get_service_context().state
+        _state_interface = self.entity_get("service_context").state
         _args = _state_interface.extend_request_args({}, oauth2.AccessTokenResponse,
                                                      'token_response', _state_id, parameters)
 
@@ -52,4 +52,4 @@ def cc_post_construct(self, request_args, **kwargs):
     def update_service_context(self, resp, key='cc', **kwargs):
         if 'expires_in' in resp:
             resp['__expires_at'] = time_sans_frac() + int(resp['expires_in'])
-        self.get_service_context().state.store_item(resp, 'token_response', key)
+        self.entity_get("service_context").state.store_item(resp, 'token_response', key)