feat: WIP Use Protocol Registry for DIDComm V2

Signed-off-by: Colton Wolkins (Laptop) <[email protected]>

Author: TheTechmage

acapy_agent/core/dispatcher.py

@@ -34,6 +34,7 @@
 from ..utils.tracing import get_timer, trace_event
 from .error import ProtocolMinorVersionNotSupported
 from .protocol_registry import ProtocolRegistry
+from ..didcomm_v2.protocol_registry import V2ProtocolRegistry
 
 
 class ProblemReportParseError(MessageParseError):
@@ -137,6 +138,24 @@ async def handle_v2_message(
     ):
         """Handle a DIDComm V2 message."""
 
+        error_result = None
+        message = None
+
+        try:
+            message = await self.make_v2_message(profile, inbound_message.payload)
+        except ProblemReportParseError:
+            pass  # avoid problem report recursion
+        except MessageParseError as e:
+            self.logger.error(f"Message parsing failed: {str(e)}, sending problem report")
+            error_result = ProblemReport(
+                description={
+                    "en": str(e),
+                    "code": "message-parse-failure",
+                }
+            )
+            if inbound_message.receipt.thread_id:
+                error_result.assign_thread_id(inbound_message.receipt.thread_id)
+
         # send a DCV2 Problem Report here for testing, and to punt procotol handling down
         # the road a bit
         context = RequestContext(profile)
@@ -150,18 +169,98 @@ async def handle_v2_message(
         )
 
         context.injector.bind_instance(BaseResponder, responder)
-        error_result = V2AgentMessage(
-            message={
-                "type": "https://didcomm.org/report-problem/2.0/problem-report",
-                "body": {
-                    "comment": "No Handlers Found",
-                    "code": "e.p.msg.not-found",
-                },
-            }
-        )
-        if inbound_message.receipt.thread_id:
-            error_result.message["pthid"] = inbound_message.receipt.thread_id
-        await responder.send_reply(error_result)
+        if not message:
+            error_result = V2AgentMessage(
+                message={
+                    "type": "https://didcomm.org/report-problem/2.0/problem-report",
+                    "body": {
+                        "comment": "No Handlers Found",
+                        "code": "e.p.msg.not-found",
+                    },
+                }
+            )
+            if inbound_message.receipt.thread_id:
+                error_result.message["pthid"] = inbound_message.receipt.thread_id
+
+        # # When processing oob attach message we supply the connection id
+        # # associated with the inbound message
+        # if inbound_message.connection_id:
+        #     async with self.profile.session() as session:
+        #         connection = await ConnRecord.retrieve_by_id(
+        #             session, inbound_message.connection_id
+        #         )
+        # else:
+        #     connection_mgr = BaseConnectionManager(profile)
+        #     connection = await connection_mgr.find_inbound_connection(
+        #         inbound_message.receipt
+        #     )
+        #     del connection_mgr
+
+        # if connection:
+        #     inbound_message.connection_id = connection.connection_id
+
+        # context.connection_ready = connection and connection.is_ready
+        # context.connection_record = connection
+        # responder.connection_id = connection and connection.connection_id
+
+        if error_result:
+            await responder.send_reply(error_result)
+        elif context.message:
+            context.injector.bind_instance(BaseResponder, responder)
+
+            handler_cls = context.message.Handler
+            handler = handler_cls().handle
+            if self.collector:
+                handler = self.collector.wrap_coro(handler, [handler.__qualname__])
+            await handler(context, responder)
+
+    async def make_v2_message(self, profile: Profile, parsed_msg: dict) -> BaseMessage:
+        """Deserialize a message dict into the appropriate message instance.
+
+        Given a dict describing a message, this method
+        returns an instance of the related message class.
+
+        Args:
+            parsed_msg: The parsed message
+            profile: Profile
+
+        Returns:
+            An instance of the corresponding message class for this message
+
+        Raises:
+            MessageParseError: If the message doesn't specify @type
+            MessageParseError: If there is no message class registered to handle
+            the given type
+
+        """
+        if not isinstance(parsed_msg, dict):
+            raise MessageParseError("Expected a JSON object")
+        message_type = parsed_msg.get("type")
+
+        if not message_type:
+            raise MessageParseError("Message does not contain 'type' parameter")
+
+        registry: V2ProtocolRegistry = self.profile.inject(V2ProtocolRegistry)
+        try:
+            #message_cls = registry.resolve_message_class(message_type)
+            #if isinstance(message_cls, DeferLoad):
+            #    message_cls = message_cls.resolved
+            message_cls = V2ProtocolRegistry.protocols_matching_query(message_type)
+        except ProtocolMinorVersionNotSupported as e:
+            raise MessageParseError(f"Problem parsing message type. {e}")
+
+        if not message_cls:
+            raise MessageParseError(f"Unrecognized message type {message_type}")
+
+        try:
+            instance = message_cls[0] #message_cls.deserialize(parsed_msg)
+        except BaseModelError as e:
+            if "/problem-report" in message_type:
+                raise ProblemReportParseError("Error parsing problem report message")
+            raise MessageParseError(f"Error deserializing message: {e}") from e
+
+        return instance
+
 
     async def handle_v1_message(
         self,