Separate disco handling from backend decision

Signed-off-by: Ivan Kanakarakis <[email protected]>

Author: c00kiemon5ter

example/plugins/microservices/disco_to_target_issuer.yaml.example

@@ -0,0 +1,6 @@
+module: satosa.micro_services.disco.DiscoToTargetIssuer
+name: DiscoToTargetIssuer
+config:
+  # the regex that will intercept http requests to be handled with this microservice
+  disco_endpoints:
+    - ".*/disco"

example/plugins/microservices/target_based_routing.yaml.example

@@ -1,12 +1,8 @@
-module: satosa.micro_services.custom_routing.DecideBackendByTargetIdP
+module: satosa.micro_services.custom_routing.DecideBackendByTargetIssuer
 name: TargetRouter
 config:
   default_backend: Saml2
 
-  # the regex that will intercept http requests to be handled with this microservice
-  endpoint_paths:
-    - ".*/disco"
-
   target_mapping:
     "http://idpspid.testunical.it:8088": "spidSaml2" # map SAML entity with entity id 'target_id' to backend name
     "http://eidas.testunical.it:8081/saml2/metadata": "eidasSaml2"

src/satosa/micro_services/custom_routing.py

@@ -7,20 +7,17 @@
 from .base import RequestMicroService
 from ..exception import SATOSAConfigurationError
 from ..exception import SATOSAError
-from ..exception import SATOSAStateError
 
 
 logger = logging.getLogger(__name__)
 
 
 class CustomRoutingError(SATOSAError):
-    """
-    SATOSA exception raised by CustomRouting rules
-    """
+    """SATOSA exception raised by CustomRouting rules"""
     pass
 
 
-class DecideBackendByTargetIdP(RequestMicroService):
+class DecideBackendByTargetIssuer(RequestMicroService):
     """
     Select target backend based on the target issuer.
     """
@@ -38,14 +35,11 @@ def __init__(self, config:dict, *args, **kwargs):
         self.default_backend = config['default_backend']
 
     def process(self, context:Context, data:InternalData):
-        """
-        Set context.target_backend based on the target issuer (context.target_entity_id)
+        """Set context.target_backend based on the target issuer"""
 
-        :param context: request context
-        :param data: the internal request
-        """
         target_issuer = context.get_decoration(Context.KEY_TARGET_ENTITYID)
         if not target_issuer:
+            logger.info('skipping backend decision because no target_issuer was found')
             return super().process(context, data)
 
         target_backend = (
@@ -64,45 +58,6 @@ def process(self, context:Context, data:InternalData):
         return super().process(context, data)
 
 
-class DecideBackendByDiscoIdP(DecideBackendByTargetIdP):
-    def __init__(self, config:dict, *args, **kwargs):
-        super().__init__(config, *args, **kwargs)
-
-        self.disco_endpoints = config['disco_endpoints']
-        if not isinstance(self.disco_endpoints, list):
-            raise CustomRoutingError('disco_endpoints must be a list of str')
-
-    def register_endpoints(self):
-        """
-        URL mapping of additional endpoints this micro service needs to register for callbacks.
-
-        Example of a mapping from the url path '/callback' to the callback() method of a micro service:
-            reg_endp = [
-                ("^/callback1$", self.callback),
-            ]
-
-        :rtype List[Tuple[str, Callable[[satosa.context.Context, Any], satosa.response.Response]]]
-
-        :return: A list with functions and args bound to a specific endpoint url,
-                 [(regexp, Callable[[satosa.context.Context], satosa.response.Response]), ...]
-        """
-
-        return [
-            (path , self._handle_disco_response)
-            for path in self.disco_endpoints
-        ]
-
-    def _handle_disco_response(self, context:Context):
-        target_issuer_from_disco = context.request.get('entityID')
-        if not target_issuer_from_disco:
-            raise CustomRoutingError('no valid entity_id in the disco response')
-
-        context.decorate(Context.KEY_TARGET_ENTITYID, target_issuer_from_disco)
-        data_serialized = context.state.get(self.name, {}).get('internal', {})
-        data = InternalData.from_dict(data_serialized)
-        return self.process(context, data)
-
-
 class DecideBackendByRequester(RequestMicroService):
     """
     Select which backend should be used based on who the requester is.

src/satosa/micro_services/disco.py

@@ -0,0 +1,48 @@
+from satosa.context import Context
+from satosa.internal import InternalData
+
+from .base import RequestMicroService
+from ..exception import SATOSAError
+
+
+class DiscoToTargetIssuerError(SATOSAError):
+    """SATOSA exception raised by CustomRouting rules"""
+
+
+class DiscoToTargetIssuer(RequestMicroService):
+    def __init__(self, config:dict, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.disco_endpoints = config['disco_endpoints']
+        if not isinstance(self.disco_endpoints, list) or not self.disco_endpoints:
+            raise DiscoToTargetIssuerError('disco_endpoints must be a list of str')
+
+    def register_endpoints(self):
+        """
+        URL mapping of additional endpoints this micro service needs to register for callbacks.
+
+        Example of a mapping from the url path '/callback' to the callback() method of a micro service:
+            reg_endp = [
+                ('^/callback1$', self.callback),
+            ]
+
+        :rtype List[Tuple[str, Callable[[satosa.context.Context, Any], satosa.response.Response]]]
+
+        :return: A list with functions and args bound to a specific endpoint url,
+                 [(regexp, Callable[[satosa.context.Context], satosa.response.Response]), ...]
+        """
+
+        return [
+            (path , self._handle_disco_response)
+            for path in self.disco_endpoints
+        ]
+
+    def _handle_disco_response(self, context:Context):
+        target_issuer = context.request.get('entityID')
+        if not target_issuer:
+            raise DiscoToTargetIssuerError('no valid entity_id in the disco response')
+
+        data_serialized = context.state.get(self.name, {}).get('internal_data', {})
+        data = InternalData.from_dict(data_serialized)
+        context.decorate(Context.KEY_TARGET_ENTITYID, target_issuer)
+        return super().process(context, data)

tests/satosa/micro_services/test_custom_routing.py

@@ -8,8 +8,7 @@
 from satosa.exception import SATOSAError, SATOSAConfigurationError, SATOSAStateError
 from satosa.internal import InternalData
 from satosa.micro_services.custom_routing import DecideIfRequesterIsAllowed
-from satosa.micro_services.custom_routing import DecideBackendByDiscoIdP
-from satosa.micro_services.custom_routing import DecideBackendByTargetIdP
+from satosa.micro_services.custom_routing import DecideBackendByTargetIssuer
 from satosa.micro_services.custom_routing import CustomRoutingError
 
 
@@ -164,7 +163,7 @@ def test_missing_target_entity_id_from_context(self, context):
             decide_service.process(context, req)
 
 
-class TestDecideBackendByTargetIdP(TestCase):
+class TestDecideBackendByTargetIssuer(TestCase):
     def setUp(self):
         context = Context()
         context.state = State()
@@ -174,12 +173,9 @@ def setUp(self):
             'target_mapping': {
                 'mapped_idp.example.org': 'mapped_backend',
             },
-            'disco_endpoints': [
-                '.*/disco',
-            ],
         }
 
-        plugin = DecideBackendByTargetIdP(
+        plugin = DecideBackendByTargetIssuer(
             config=config,
             name='test_decide_service',
             base_url='https://satosa.example.org',
@@ -207,49 +203,3 @@ def test_when_target_is_mapped_choose_mapping_backend(self):
         data.requester = 'somebody else'
         newctx, newdata = self.plugin.process(self.context, data)
         assert newctx.target_backend == 'mapped_backend'
-
-
-class TestDecideBackendByDiscoIdP(TestCase):
-    def setUp(self):
-        context = Context()
-        context.state = State()
-
-        config = {
-            'default_backend': 'default_backend',
-            'target_mapping': {
-                'mapped_idp.example.org': 'mapped_backend',
-            },
-            'disco_endpoints': [
-                '.*/disco',
-            ],
-        }
-
-        plugin = DecideBackendByDiscoIdP(
-            config=config,
-            name='test_decide_service',
-            base_url='https://satosa.example.org',
-        )
-        plugin.next = lambda ctx, data: (ctx, data)
-
-        self.config = config
-        self.context = context
-        self.plugin = plugin
-
-    def test_when_target_is_not_set_raise_error(self):
-        self.context.request = {}
-        with pytest.raises(CustomRoutingError):
-            self.plugin._handle_disco_response(self.context)
-
-    def test_when_target_is_not_mapped_choose_default_backend(self):
-        self.context.request = {
-            'entityID': 'idp.example.org',
-        }
-        newctx, newdata = self.plugin._handle_disco_response(self.context)
-        assert newctx.target_backend == 'default_backend'
-
-    def test_when_target_is_mapped_choose_mapping_backend(self):
-        self.context.request = {
-            'entityID': 'mapped_idp.example.org',
-        }
-        newctx, newdata = self.plugin._handle_disco_response(self.context)
-        assert newctx.target_backend == 'mapped_backend'

tests/satosa/micro_services/test_disco.py

@@ -0,0 +1,44 @@
+from unittest import TestCase
+
+import pytest
+
+from satosa.context import Context
+from satosa.state import State
+from satosa.micro_services.disco import DiscoToTargetIssuer
+from satosa.micro_services.disco import DiscoToTargetIssuerError
+
+
+class TestDiscoToTargetIssuer(TestCase):
+    def setUp(self):
+        context = Context()
+        context.state = State()
+
+        config = {
+            'disco_endpoints': [
+                '.*/disco',
+            ],
+        }
+
+        plugin = DiscoToTargetIssuer(
+            config=config,
+            name='test_disco_to_target_issuer',
+            base_url='https://satosa.example.org',
+        )
+        plugin.next = lambda ctx, data: (ctx, data)
+
+        self.config = config
+        self.context = context
+        self.plugin = plugin
+
+    def test_when_entity_id_is_not_set_raise_error(self):
+        self.context.request = {}
+        with pytest.raises(DiscoToTargetIssuerError):
+            self.plugin._handle_disco_response(self.context)
+
+    def test_when_entity_id_is_set_target_issuer_is_set(self):
+        entity_id = 'idp.example.org'
+        self.context.request = {
+            'entityID': entity_id,
+        }
+        newctx, newdata = self.plugin._handle_disco_response(self.context)
+        assert newctx.get_decoration(Context.KEY_TARGET_ENTITYID) == entity_id