Application Multiplexer

go/config.py

@@ -136,6 +136,10 @@ def get_router_definition(router_type, router=None):
         'namespace': 'keyword',
         'display_name': 'Keyword',
     },
+    'go.routers.app_multiplexer': {
+        'namespace': 'application_multiplexer',
+        'display_name': 'Application Multiplexer',
+    },
 }
 
 _VUMI_OBSOLETE_ROUTERS = [

go/routers/app_multiplexer/definition.py

@@ -0,0 +1,8 @@
+from go.vumitools.router.definition import RouterDefinitionBase
+
+
+class RouterDefinition(RouterDefinitionBase):
+    router_type = 'application_multiplexer'
+
+    def configured_outbound_endpoints(self, config):
+        return list(set(config.get('keyword_endpoint_mapping', {}).values()))

go/routers/app_multiplexer/tests/test_views.py

@@ -0,0 +1,24 @@
+from go.base.tests.helpers import GoDjangoTestCase
+from go.routers.tests.view_helpers import RouterViewsHelper
+
+
+class ApplicationMultiplexerViewTests(GoDjangoTestCase):
+
+    def setUp(self):
+        self.router_helper = self.add_helper(
+            RouterViewsHelper(u'application_multiplexer')
+        )
+        self.user_helper = self.router_helper.vumi_helper.get_or_create_user()
+        self.client = self.router_helper.get_client()
+
+    def test_new_router(self):
+        router_store = self.user_helper.user_api.router_store
+        self.assertEqual([], router_store.list_routers())
+
+        response = self.client.post(self.router_helper.get_new_view_url(), {
+            'name': u"myrouter",
+            'router_type': u'application_multiplexer',
+        })
+        [router_key] = router_store.list_routers()
+        rtr_helper = self.router_helper.get_router_helper_by_key(router_key)
+        self.assertRedirects(response, rtr_helper.get_view_url('edit'))

go/routers/app_multiplexer/tests/test_vumi_app.py

@@ -0,0 +1,71 @@
+from twisted.internet.defer import inlineCallbacks
+
+from vumi.tests.helpers import VumiTestCase
+
+from go.routers.app_multiplexer.vumi_app import ApplicationMultiplexer
+from go.routers.tests.helpers import RouterWorkerHelper
+
+
+class TestApplicationMultiplexerRouter(VumiTestCase):
+
+    router_class = ApplicationMultiplexer
+
+    @inlineCallbacks
+    def setUp(self):
+        self.router_helper = self.add_helper(
+            RouterWorkerHelper(ApplicationMultiplexer)
+        )
+        self.router_worker = yield self.router_helper.get_router_worker({})
+
+    @inlineCallbacks
+    def assert_routed_inbound(self, content, router, expected_endpoint):
+        msg = yield self.router_helper.ri.make_dispatch_inbound(
+            content, router=router)
+        emsg = msg.copy()
+        emsg.set_routing_endpoint(expected_endpoint)
+        rmsg = self.router_helper.ro.get_dispatched_inbound()[-1]
+        self.assertEqual(emsg, rmsg)
+
+    @inlineCallbacks
+    def test_start(self):
+        router = yield self.router_helper.create_router()
+        self.assertTrue(router.stopped())
+        self.assertFalse(router.running())
+
+        yield self.router_helper.start_router(router)
+        router = yield self.router_helper.get_router(router.key)
+        self.assertFalse(router.stopped())
+        self.assertTrue(router.running())
+
+    @inlineCallbacks
+    def test_stop(self):
+        router = yield self.router_helper.create_router(started=True)
+        self.assertFalse(router.stopped())
+        self.assertTrue(router.running())
+
+        yield self.router_helper.stop_router(router)
+        router = yield self.router_helper.get_router(router.key)
+        self.assertTrue(router.stopped())
+        self.assertFalse(router.running())
+
+    @inlineCallbacks
+    def test_no_messages_processed_while_stopped(self):
+        router = yield self.router_helper.create_router()
+
+        yield self.router_helper.ri.make_dispatch_inbound("foo", router=router)
+        self.assertEqual([], self.router_helper.ro.get_dispatched_inbound())
+
+        yield self.router_helper.ri.make_dispatch_ack(router=router)
+        self.assertEqual([], self.router_helper.ro.get_dispatched_events())
+
+        yield self.router_helper.ro.make_dispatch_outbound(
+            "foo", router=router)
+        self.assertEqual([], self.router_helper.ri.get_dispatched_outbound())
+        [nack] = self.router_helper.ro.get_dispatched_events()
+        self.assertEqual(nack['event_type'], 'nack')
+
+    @inlineCallbacks
+    def test_inbound_no_config(self):
+        router = yield self.router_helper.create_router(started=True)
+        yield self.assert_routed_inbound("foo bar", router, 'default')
+        yield self.assert_routed_inbound("baz quux", router, 'default')

go/routers/app_multiplexer/view_definition.py

@@ -0,0 +1,42 @@
+from django import forms
+
+from go.router.view_definition import RouterViewDefinitionBase, EditRouterView
+
+
+class ApplicationMultiplexerForm(forms.Form):
+    keyword = forms.CharField()
+    target_endpoint = forms.CharField()
+
+
+class BaseApplicationMultiplexerFormSet(forms.formsets.BaseFormSet):
+    @staticmethod
+    def initial_from_config(data):
+        return [{'keyword': k, 'target_endpoint': v}
+                for k, v in sorted(data.items())]
+
+    def to_config(self):
+        keyword_endpoint_mapping = {}
+        for form in self:
+            if (not form.is_valid()) or form.cleaned_data['DELETE']:
+                continue
+            keyword = form.cleaned_data['keyword']
+            target_endpoint = form.cleaned_data['target_endpoint']
+            keyword_endpoint_mapping[keyword] = target_endpoint
+        return keyword_endpoint_mapping
+
+
+ApplicationMultiplexerFormSet = forms.formsets.formset_factory(
+    ApplicationMultiplexerForm,
+    can_delete=True,
+    extra=1,
+    formset=BaseApplicationMultiplexerFormSet)
+
+
+class EditApplicationMultiplexerView(EditRouterView):
+    edit_forms = (
+        ('keyword_endpoint_mapping', ApplicationMultiplexerFormSet),
+    )
+
+
+class RouterViewDefinition(RouterViewDefinitionBase):
+    edit_view = EditApplicationMultiplexerView

go/routers/app_multiplexer/vumi_app.py

@@ -0,0 +1,37 @@
+# -*- test-case-name: go.routers.keyword.tests.test_vumi_app -*-
+# -*- coding: utf-8 -*-
+
+from vumi import log
+from vumi.config import ConfigDict
+
+from go.vumitools.app_worker import GoRouterWorker
+
+
+class ApplicationMultiplexerConfig(GoRouterWorker.CONFIG_CLASS):
+    keyword_endpoint_mapping = ConfigDict(
+        "Mapping from case-insensitive keyword regex to endpoint name.",
+        default={})
+
+
+class ApplicationMultiplexer(GoRouterWorker):
+    """
+    Router that splits inbound messages based on keywords.
+    """
+    CONFIG_CLASS = ApplicationMultiplexerConfig
+
+    worker_name = 'application_multiplexer'
+
+    def lookup_target(self, config, msg):
+        first_word = ((msg['content'] or '').strip().split() + [''])[0]
+        for keyword, target in config.keyword_endpoint_mapping.iteritems():
+            if keyword.lower() == first_word.lower():
+                return target
+        return 'default'
+
+    def handle_inbound(self, config, msg, conn_name):
+        log.debug("Handling inbound: %s" % (msg,))
+        return self.publish_inbound(msg, self.lookup_target(config, msg))
+
+    def handle_outbound(self, config, msg, conn_name):
+        log.debug("Handling outbound: %s" % (msg,))
+        return self.publish_outbound(msg, 'default')