Merge pull request #77 from didx-xyz/improvement-controller-session

Improvement controller session

Author: wip-abramson

libs/aries-basic-controller/aries_basic_controller/aries_controller.py

@@ -3,6 +3,7 @@
     ClientSession,
     ClientRequest,
 )
+from dataclasses import dataclass
 from pubsub import pub
 import sys
 
@@ -26,51 +27,84 @@
 
 logger = logging.getLogger("aries_controller")
 
-class AriesAgentController:
 
+@dataclass
+class AriesAgentController:
+    """The Aries Agent Controller class
+    
+    This class allows you to interact with Aries by exposing the aca-py API. 
+    
+    Attributes
+    ----------
+    webhook_host : str
+        The url of the webhook host 
+    webhook_port : int 
+        The exposed port for webhooks on the host
+    admin_url : str
+        The URL for the Admin API
+    webhook_base : str
+        The base url for webhooks (default is "")
+    connections : bool
+        Specify whether to create connecitons (default is True)
+    messaging : bool
+        Initialise the messaging interface (default is True)
+    multitenant : bool
+        Initialise the multitenant interface (default is False)
+    mediation : bool
+        Initialise the mediation interface (default is False)
+    issuer : bool
+        Initialise the issuer interface (defautl is True)
+    action_menu : bool
+        Initialise the action menu interface (default is True)
+    revocations : bool
+        Initialise revocation interface for credentials (default is True)
+    api_key : str 
+        The API key (default is None)
+    tenant_jwt: str
+        The tenant JW token (default is None)
+    """
+    
     ## TODO rethink how to initialise. Too many args?
     ## is it important to let users config connections/issuer etc
-    def __init__(
-        self,
-        webhook_host: str,
-        webhook_port: int,
-        admin_url: str,
-        webhook_base: str = "",
-        connections: bool = True,
-        messaging: bool = True,
-        multitenant: bool = False,
-        mediation: bool = False,
-        issuer: bool = True,
-        action_menu: bool = True,
-        revocations: bool = True,
-        api_key: str = None,
-        tennant_jwt: str = None,
-    ):
-
+    webhook_host: str
+    webhook_port: int
+    admin_url: str
+    webhook_base: str = ""
+    connections: bool = True
+    messaging: bool = True
+    multitenant: bool = False
+    mediation: bool = False
+    issuer: bool = True
+    action_menu: bool = True
+    revocations: bool = True
+    api_key: str = None
+    tenant_jwt: str = None
+
+
+    def __post_init__(self):
+        """Constructs additional attributes, 
+        and logic defined by attributes set during initial instantiation
+        """
+        
         self.webhook_site = None
-        self.admin_url = admin_url
-        if webhook_base:
-            self.webhook_base = webhook_base
-        else:
-            self.webhook_base = ""
-        self.webhook_host = webhook_host
-        self.webhook_port = webhook_port
         self.connections_controller = None
-
-        headers = {}
-
-        if api_key:
-            headers.update({"X-API-Key": api_key})
-
-        if tennant_jwt:
-            headers.update({'Authorization': 'Bearer ' + tennant_jwt, 'content-type': "application/json"})
-
-        self.client_session: ClientSession = ClientSession(headers=headers)
 
+        # Construct headers for Client Session and the session itself
+        self.headers = {}
+        
+        if self.api_key:
+            self.headers.update({"X-API-Key": self.api_key})
+
+        if self.tenant_jwt:
+            self.headers.update({'Authorization': 'Bearer ' + self.tenant_jwt, 'content-type': "application/json"})
 
-        if connections:
+        self.client_session: ClientSession = ClientSession(headers=self.headers)
+    
+        # Instantiate controllers based on the provided attributes
+        if self.connections:
             self.connections = ConnectionsController(self.admin_url, self.client_session)
-        if messaging:
+            
+        if self.messaging:
             self.messaging = MessagingController(self.admin_url, self.client_session)
 
         self.proofs = ProofController(self.admin_url, self.client_session)
@@ -79,50 +113,9 @@ def __init__(
         self.server = ServerController(self.admin_url, self.client_session)
         self.oob = OOBController(self.admin_url, self.client_session)
 
-        if multitenant:
-            self.multitenant = MultitenancyController(self.admin_url, self.client_session)
-
-        if mediation:
-            self.mediation = MediationController(self.admin_url, self.client_session)
-
-        if issuer:
-            self.schema = SchemaController(self.admin_url, self.client_session)
-            self.wallet = WalletController(self.admin_url, self.client_session)
-            self.definitions = DefinitionsController(self.admin_url, self.client_session)
-            self.issuer = IssuerController(self.admin_url, self.client_session, self.connections,
-                                           self.wallet, self.definitions)
-
-        if action_menu:
-            self.action_menu = ActionMenuController(self.admin_url, self.client_session)
-
-        if revocations:
-            self.revocations = RevocationController(
-                self.admin_url,
-                self.client_session
-            )
-
-    # TODO: Determine whether we really want to essentially create a whole new ClientSession object as done below
-    # Ideally we'd just update the existing session along the lines of self.client_session(headers) 
-    # That does not work, though because it is not callable and updating cannot be achieved reliably 
-    # because headers can be of different type
-    # from https://docs.aiohttp.org/en/stable/client_reference.html :
-    # "May be either iterable of key-value pairs or Mapping (e.g. dict, CIMultiDict)."
-    # So for now let's create a new ClientSession and use all the instances current attributes 
-    # to update every attr using ClientSession
-    def update_tennant_jwt(self, tennant_jwt): 
-        self.tennant_jwt = tennant_jwt
-        headers = {'Authorization': 'Bearer ' + tennant_jwt, 'content-type': "application/json"}
-        self.client_session: ClientSession = ClientSession(headers=headers)
-
-        if self.connections:
-            self.connections = ConnectionsController(self.admin_url, self.client_session)
-
-        if self.messaging:
-            self.messaging = MessagingController(self.admin_url, self.client_session)
-
         if self.multitenant:
             self.multitenant = MultitenancyController(self.admin_url, self.client_session)
-            
+
         if self.mediation:
             self.mediation = MediationController(self.admin_url, self.client_session)
 
@@ -131,7 +124,7 @@ def update_tennant_jwt(self, tennant_jwt):
             self.wallet = WalletController(self.admin_url, self.client_session)
             self.definitions = DefinitionsController(self.admin_url, self.client_session)
             self.issuer = IssuerController(self.admin_url, self.client_session, self.connections,
-                                           self.wallet, self.definitions)
+                                            self.wallet, self.definitions)
 
         if self.action_menu:
             self.action_menu = ActionMenuController(self.admin_url, self.client_session)
@@ -142,8 +135,63 @@ def update_tennant_jwt(self, tennant_jwt):
                 self.client_session
             )
 
+    
+    def update_tenant_jwt(self, tenant_jwt: str): 
+        """Update the tenant JW token attribute and the header
+        
+        Args:
+        ----
+        tenant_jwt : str 
+            The tenant's JW token
+        """
+        self.tenant_jwt = tenant_jwt
+        self.headers.update({'Authorization': 'Bearer ' + tenant_jwt, 'content-type': "application/json"})
+        self.client_session.headers.update(self.headers)
+        
+        
+    def update_api_key(self, api_key: str):
+        """Update the API Key attribute and the header
+        
+        Args:
+        ----
+        api_key : str
+            The API Key
+        """
+        self.api_key = api_key
+        self.headers.update({"X-API-Key": api_key})
+        self.client_session.headers.update(self.headers)
+        
+        
+    def remove_api_key(self):
+        """Removes the API key attribute and corresponding headers from the Client Session"""
+        self.api_key = None
+        if 'X-API-Key' in self.client_session.headers:
+            del self.client_session.headers['X-API-Key']
+            del self.headers['X-API-Key']
+      
+      
+    def remove_tenant_jwt(self):
+        """Removes the tenant's JW Token attribute and corresponding headers from the Client Session"""
+        self.tenant_jwt = None
+        if 'Authorization' in self.client_session.headers:
+            del self.client_session.headers['Authorization']
+            del self.headers['Authorization']
+        if 'content-type' in self.client_session.headers:
+            del self.client_session.headers['content-type']
+            del self.headers['content-type']
+
 
     def register_listeners(self, listeners, defaults=True):
+        """Registers the webhook listners
+        
+        Args:
+        ----
+        listeners : [dict]
+            A collection of dictionaries comprised of a "handler": handler (fct) and a "topic":"topicname" key-value pairs
+        defaults : bool
+            Whether to connect to the default handlers for connections, basicmessage and present_proof 
+            (default is True)
+        """
         try:
             if defaults:
                 if self.connections:
@@ -160,15 +208,31 @@ def register_listeners(self, listeners, defaults=True):
             logger.warn(f"Register webhooks listeners failed! {exc!r} occurred.")
 
 
+
     def add_listener(self, listener):
+        """Subscribe to a listeners for a topic
+        
+        Args:
+        ----
+        listener : dict
+            A dictionary comprised of a "handler": handler (fct) and a "topic":"topicname" key-value pairs
+        """
         try:
             pub.subscribe(listener["handler"], listener["topic"])
         except Exception as exc:
             print(f"Adding webhooks listener failed! {exc!r} occurred.")
             logger.warn(f"Adding webhooks listener failed! {exc!r} occurred.")
 
 
+
     def remove_listener(self, listener):
+        """Remove a listener for a topic
+        
+        Args:
+        ----
+        listener : dict
+            A dictionary comprised of a "handler": handler (fct) and a "topic":"topicname" key-value pairs
+        """
         try:
             if pub.isSubscribed(listener["handler"], listener["topic"]):
                 pub.unsubscribe(listener["handler"], listener["topic"])
@@ -179,7 +243,15 @@ def remove_listener(self, listener):
             logger.warn(f"Removing webhooks listener failed! {exc!r} occurred.")
 
 
+
     def remove_all_listeners(self, topic: str = None):
+        """Remove all listeners for one or all topics
+        
+        Args:
+        ----
+        topic : str
+            The topic to stop listening for (default is None). Default will cause unsubscribing from all topics.
+        """
         # Note advanced use of function can include both listenerFilter and topicFilter for this
         # Add when needed
         try:
@@ -189,7 +261,9 @@ def remove_all_listeners(self, topic: str = None):
             logger.warn(f"Removing all webhooks listeners failed! {exc!r} occurred.")
 
 
+
     async def listen_webhooks(self):
+        """Create a server to listen to webhooks"""
         try:
             app = web.Application()
             app.add_routes([web.post(self.webhook_base + "/topic/{topic}/", self._receive_webhook)])
@@ -202,7 +276,20 @@ async def listen_webhooks(self):
             logger.warn(f"Listening webhooks failed! {exc!r} occurred.")
 
 
+
     async def _receive_webhook(self, request: ClientRequest):
+        """Helper to receive webhooks by requesting it
+        
+        Args:
+        ----
+        request : ClientRequest
+            The client request to which the corresponding webhooks shall be received
+            
+        Returns:
+        -------
+        Response:
+            A response with status 200
+        """
         topic = request.match_info["topic"]
         try:
             payload = await request.json()
@@ -212,7 +299,17 @@ async def _receive_webhook(self, request: ClientRequest):
             logger.warn(f"Receiving webhooks failed! {exc!r} occurred.")
 
 
+
     async def _handle_webhook(self, topic, payload):
+        """Helper handling a webhook
+        
+        Args:
+        ----
+        topic : str
+            The topic to handle webhooks for
+        payload : dict
+            A JSON-like dictionary representation of the payload
+        """
         try:
             logging.debug(f"Handle Webhook - {topic}", payload)
             pub.sendMessage(topic, payload=payload)
@@ -221,7 +318,9 @@ async def _handle_webhook(self, topic, payload):
             logger.warn(f"Handling webhooks failed! {exc!r} occurred when trying to handle this topic: {topic}")
 
 
+
     async def terminate(self):
+        """Terminate the controller client session and webhook listeners"""
         try:
             await self.client_session.close()
             if self.webhook_site:

libs/aries-basic-controller/aries_basic_controller/controllers/proof.py

@@ -67,17 +67,17 @@ async def get_presentation_credentials(self, pres_ex_id, count: int = None, wql_
 
 
     # Send a problem report for presentation exchange
-    async def send_problem_report(self, request, pres_ex_id):
+    async def send_problem_report(self, pres_ex_id, request):
         return await self.admin_POST(f"{self.base_url}/records/{pres_ex_id}/problem-report", json_data=request)
 
 
     # Sends a proof presentation
-    async def send_presentation(self, request, pres_ex_id):
+    async def send_presentation(self, pres_ex_id, request):
         return await self.admin_POST(f"{self.base_url}/records/{pres_ex_id}/send-presentation", json_data=request)
 
 
     # Sends a presentation request in reference to a proposal
-    async def send_request_for_proposal(self, request, pres_ex_id):
+    async def send_request_for_proposal(self, pres_ex_id, request):
         return await self.admin_POST(f"{self.base_url}/records/{pres_ex_id}/send-request", json_data=request)