Resolve conflict

Author: HawkiesZA

.DS_Store

@@ -132,4 +132,5 @@ dmypy.json
 utils/SMPPSim/
 
 # vscode
-.vscode
+.vscode
+.DS_Store

.gitignore

@@ -7,6 +7,9 @@
 - Retry messages if Turn rate limits us
 - Warning logs for config errors, including (ignored) extra keys
 - Log an error if the outbound request times out
+- Adding middleware support 
+- Adding logging and unidecoder middleware
+- Calling BaseWorker setup on all child classes
 
 ### Fixed
 - Sphinx builds now fail on warnings, and all existing warnings/errors in the docs have been fixed

CHANGELOG.md

@@ -15,6 +15,7 @@ Welcome to vumi2's documentation!
    transports
    applications
    message_caches
+   middleware
 
 
 

docs/index.rst

@@ -0,0 +1,45 @@
+Middleware
+==========
+Middleware provides additional functionality that can be attached to any existing transport, 
+application or dispatcher worker. For example, middleware could log inbound and outbound messages, decode a unicoded message,
+store delivery reports in a database or modify a message.
+
+Attaching middleware to your worker is fairly straight forward. Just extend your YAML configuration file with lines like:Attaching middleware to your worker is fairly straight forward. Just extend your YAML configuration file with lines like:
+
+ .. code-block:: YAML
+
+    middlewares:
+    - class_path: vumi2.middlewares.unidecoder.Unidecoder
+      enable_for_connectors: ["mc_qa_expressway"]
+      outbound_enabled: true
+
+The middleware section contains a list of middleware items. 
+Each item contains a :py:data:`class_path` class_path which is the full Python path to the class implementing the middleware, 
+:py:data:`enable_for_connectors` enable_for_connectors this is the list of transports that the middleware will run on, 
+and :py:data:`{type}_enabled`  fields which describes which type of message the middleware is enabled on (inbound, outbound or event)
+
+Multiple layers of middleware may be specified as follows:
+
+.. code-block:: YAML
+
+    middlewares:
+    - class_path: vumi2.middlewares.unidecoder.Unidecoder
+      enable_for_connectors: ["mc_qa_expressway"]
+      outbound_enabled: true
+    - class_path: vumi2.middlewares.logging.LoggingMiddleware
+      enable_for_connectors: ["mc_qa_expressway"]
+      outbound_enabled: true
+      inbound_enabled: true
+      event_enabled: true
+
+You can think of the layers of middleware sitting on top of the underlying transport or application worker. 
+Messages being consumed by the worker enter from the top and are processed by the middleware in the order you 
+have defined them and eventually reach the worker at the bottom. Messages published by the worker aren't handled by the middleware. 
+Middleware only applies to consumed messages, not published messages. 
+
+Adding your middleware:
+
+.. toctree::
+    :maxdepth: 2
+
+    middleware/building_your_own_middleware

docs/middleware.rst

@@ -0,0 +1,27 @@
+Implementing your own middleware
+=================================
+
+A middleware class provides three handler functions, one for processing each of the three kinds of messages transports, applications and dispatchers typically send and receive (i.e. inbound user messages, outbound user messages, event messages) and three enabled functions for each of the types of messages
+
+Although transport and application middleware potentially both provide the same sets of handlers, the two make use of them in slightly different ways. Inbound messages and events are published by transports but consumed by applications while outbound messages are opposite.
+
+A middleware is required to subclass BaseMiddleware. This is a convenient definition of and set of common functionality for middleware classes. Custom setup should be done in 
+:py:meth:`setup()` instead (if required). The config class can be overidden by replacing the :py:data:`config` variable.
+You should overwrite :py:meth:`handle_inbound(self, msg, connection)`, :py:meth:`handle_outbound(self, msg, connection)`, :py:meth:`handle_event(self, event, connection)`. :py:meth:`handle_inbound` and :py:meth:`handle_outbound` return vumi2 Messages 
+:py:meth:`handle_event` returns vumi2 Events
+
+See logging and unidecoder examples 
+
+How your middleware is used inside Vumi: 
+----------------------------------------
+
+While writing complex middleware, it may help to understand how a middleware class is used by Vumi transports and applications.
+
+When a transport or application is started a list of middleware to load is read from the configuration. 
+An instance of each piece of middleware is created and then :py:meth:`setup()` is called on each middleware object in 
+order within the :py:meth:`setup()`  of the worker
+
+:py:meth:`middleware_{type}_handler` function  (e.g., middleware_outbound_handler) of BaseWorker of each message type. This function will:
+Filter the middleware list based on connector_name and the middleware's :py:meth:`{type}_enabled` method.
+Create a decorated handler function that sequentially applies each enabled middleware's :py:meth:`handle_{type}` method to the message.
+Return the decorated handler. This decorated handler is then used in setting up the connection 

docs/middleware/building_your_own_middleware.rst

@@ -25,6 +25,7 @@ quart-trio = "^0.11.1"
 hypercorn = "^0.16.0"
 "smpp.pdu3" = "^0.6"
 httpx = "^0.26.0"
+unidecode = "^1.3.8"
 prometheus-client = "^0.22.1"
 
 [tool.poetry.group.dev.dependencies]

poetry.lock

@@ -7,7 +7,7 @@
 from quart import request
 from trio import move_on_after
 
-from vumi2.cli import class_from_string
+from vumi2.class_helpers import class_from_string
 from vumi2.messages import (
     Event,
     Message,
@@ -105,6 +105,7 @@ class JunebugMessageApi(BaseWorker):
     config: JunebugMessageApiConfig
 
     async def setup(self) -> None:
+        await super().setup()
         state_cache_class = class_from_string(self.config.state_cache_class)
         self.state_cache = state_cache_class(self.config.state_cache_config)
         self.connector = await self.setup_receive_inbound_connector(

pyproject.toml

@@ -20,6 +20,7 @@ class StaticReplyApplication(BaseWorker):
     config: StaticReplyConfig
 
     async def setup(self) -> None:
+        await super().setup()
         self.connector = await self.setup_receive_inbound_connector(
             connector_name=self.config.transport_name,
             inbound_handler=self.handle_inbound_message,