Redesign communication client types

python/lib/communication/dmod/communication/__init__.py

@@ -1,6 +1,6 @@
 from ._version import __version__
-from .client import DataServiceClient, InternalServiceClient, ModelExecRequestClient, ExternalRequestClient, \
-    PartitionerServiceClient, SchedulerClient
+from .client import AuthClient, CachedAuthClient, DataServiceClient, ExternalRequestClient, PartitionerServiceClient, \
+    RequestClient, SchedulerClient, TransportLayerClient, WebSocketClient
 from .maas_request import get_available_models, get_available_outputs, get_distribution_types, get_parameters, \
     get_request, AbstractNgenRequest, Distribution, DmodJobRequest, ExternalRequest, ExternalRequestResponse,\
     ModelExecRequest, ModelExecRequestResponse, NWMRequest, NWMRequestResponse, Scalar, NGENRequest, \

python/lib/communication/dmod/communication/_version.py

@@ -1 +1 @@
-__version__ = '0.14.0'
+__version__ = '0.15.0'

python/lib/communication/dmod/test/test_scheduler_client.py

@@ -1,20 +1,16 @@
 import asyncio
-import json
 import logging
+import ssl
 import unittest
-from pathlib import Path
 from typing import Optional, Union
-from ..communication import NWMRequest, SchedulerClient, SchedulerRequestMessage, SchedulerRequestResponse
+from ..communication import NWMRequest, SchedulerClient, SchedulerRequestMessage, SchedulerRequestResponse, \
+    TransportLayerClient
 
 
-class MockSendTestingSchedulerClient(SchedulerClient):
-    """
-    Customized extension of ``SchedulerClient`` for testing purposes, where the :meth:`async_send` method has been
-    overridden with a mock implementation to allow for testing without actually needing a real websocket connection.
-    """
+class MockTransportLayerClient(TransportLayerClient):
 
     def __init__(self):
-        super().__init__(endpoint_uri='', ssl_directory=Path('.'))
+        super().__init__(endpoint_host='', endpoint_port=8888)
 
         self.test_responses = dict()
 
@@ -52,20 +48,56 @@ async def async_send(self, data: Union[str, bytearray], await_response: bool = F
         else:
             return str(response)
 
-    def set_scheduler_response_none(self):
+    async def async_recv(self) -> str:
+        pass
+
+    @property
+    def client_ssl_context(self) -> ssl.SSLContext:
+        pass
+
+    @property
+    def endpoint_uri(self) -> str:
+        return ''
+
+    def set_client_response_none(self):
         self.test_response_selection = 0
 
-    def set_scheduler_response_non_json_string(self):
+    def set_client_response_non_json_string(self):
         self.test_response_selection = 1
 
-    def set_scheduler_response_unrecognized_json(self):
+    def set_client_response_unrecognized_json(self):
         self.test_response_selection = 2
 
-    def set_scheduler_response_valid_obj_for_failure(self):
+    def set_client_response_valid_obj_for_failure(self):
         self.test_response_selection = 3
 
-    def set_scheduler_response_valid_obj_for_success(self):
+    def set_client_response_valid_obj_for_success(self):
         self.test_response_selection = 4
+
+
+class MockSendTestingSchedulerClient(SchedulerClient):
+    """
+    Customized extension of ``SchedulerClient`` for testing purposes, where the :meth:`async_send` method has been
+    overridden with a mock implementation to allow for testing without actually needing a real websocket connection.
+    """
+
+    def __init__(self):
+        super().__init__(transport_client=MockTransportLayerClient())
+
+    def set_scheduler_response_none(self):
+        self._transport_client.test_response_selection = 0
+
+    def set_scheduler_response_non_json_string(self):
+        self._transport_client.test_response_selection = 1
+
+    def set_scheduler_response_unrecognized_json(self):
+        self._transport_client.test_response_selection = 2
+
+    def set_scheduler_response_valid_obj_for_failure(self):
+        self._transport_client.test_response_selection = 3
+
+    def set_scheduler_response_valid_obj_for_success(self):
+        self._transport_client.test_response_selection = 4
 
 
 class TestSchedulerClient(unittest.TestCase):
@@ -103,26 +135,6 @@ def tearDown(self) -> None:
         self.loop.stop()
         self.loop.close()
 
-    def test_get_response_subtype_1_a(self):
-        """
-        Test that ``get_response_subtype`` returns the right type.
-        """
-        self.assertEqual(SchedulerRequestResponse, self.client.get_response_subtype())
-
-    def test_build_response_1_a(self):
-        """
-        Basic test to ensure this function operates correctly.
-        """
-        response = self.client.build_response(success=True, reason='Test Good', message='Test worked correctly')
-        self.assertTrue(isinstance(response, SchedulerRequestResponse))
-
-    def test_build_response_1_b(self):
-        """
-        Basic test to ensure this response has the expected ``success`` value.
-        """
-        response = self.client.build_response(success=True, reason='Test Good', message='Test worked correctly')
-        self.assertTrue(response.success)
-
     def test_async_make_request_1_a(self):
         """
         Test when function gets ``None`` returned over websocket that response object ``success`` is ``False``.

python/lib/externalrequests/dmod/externalrequests/_version.py

@@ -1 +1 @@
-__version__ = '0.4.1'
+__version__ = '0.5.0'

python/lib/externalrequests/dmod/externalrequests/maas_request_handlers.py

@@ -6,8 +6,8 @@
 
 from dmod.access import Authorizer
 from dmod.communication import AbstractRequestHandler, DataServiceClient, FullAuthSession, ExternalRequest, \
-    InitRequestResponseReason, InternalServiceClient, PartitionRequest, PartitionResponse, PartitionerServiceClient, \
-    Session, SessionManager
+    InitRequestResponseReason, RequestClient, PartitionRequest, PartitionResponse, PartitionerServiceClient, \
+    TransportLayerClient, Session, SessionManager, WebSocketClient
 from dmod.communication.dataset_management_message import MaaSDatasetManagementMessage, MaaSDatasetManagementResponse, \
     ManagementAction
 from dmod.communication.data_transmit_message import DataTransmitMessage, DataTransmitResponse
@@ -38,6 +38,7 @@ def __init__(self, session_manager: SessionManager, authorizer: Authorizer, serv
         self._service_port = service_port
         self._service_ssl_dir = service_ssl_dir
         self._service_url = None
+        self._transport_client = None
 
     async def _is_authorized(self, request: ExternalRequest, session: FullAuthSession) -> bool:
         """
@@ -129,15 +130,25 @@ async def get_authorized_session(self, request: ExternalRequest) -> Tuple[
             msg = None
         return session, is_authorized, reason, msg
 
+    @property
+    def transport_client(self) -> TransportLayerClient:
+        if self._transport_client is None:
+            # TODO: parameterize whether to, e.g., use websocket uri/protocol, as opposed to something else
+            # TODO: subsequent PR that removes this from these types (receive a service client on init) or at least has
+            #  it supplied on init.
+            self._transport_client = WebSocketClient(endpoint_host=self._service_host, endpoint_port=self._service_port,
+                                                     cafile=self.service_ssl_dir.joinpath("certificate.pem"))
+        return self._transport_client
+
     @property
     @abstractmethod
-    def service_client(self) -> InternalServiceClient:
+    def service_client(self) -> RequestClient:
         """
-        Get the client for interacting with the service, which also is a context manager for connections.
+        Get the client for interacting with the service.
 
         Returns
         -------
-        InternalServiceClient
+        RequestClient
             The client for interacting with the service.
         """
         pass
@@ -146,12 +157,6 @@ def service_client(self) -> InternalServiceClient:
     def service_ssl_dir(self) -> Path:
         return self._service_ssl_dir
 
-    @property
-    def service_url(self) -> str:
-        if self._service_url is None:
-            self._service_url = 'wss://{}:{}'.format(str(self._service_host), str(self._service_port))
-        return self._service_url
-
 
 class PartitionRequestHandler(MaaSRequestHandler):
 
@@ -202,7 +207,7 @@ async def determine_required_access_types(self, request: PartitionRequest, user)
     @property
     def service_client(self) -> PartitionerServiceClient:
         if self._service_client is None:
-            self._service_client = PartitionerServiceClient(self.service_url, self.service_ssl_dir)
+            self._service_client = PartitionerServiceClient(transport_client=self.transport_client)
         return self._service_client
 
     async def handle_request(self, request: PartitionRequest, **kwargs) -> PartitionResponse:
@@ -332,5 +337,5 @@ async def handle_request(self, request: MaaSDatasetManagementMessage, **kwargs)
     @property
     def service_client(self) -> DataServiceClient:
         if self._service_client is None:
-            self._service_client = DataServiceClient(endpoint_uri=self.service_url, ssl_directory=self.service_ssl_dir)
+            self._service_client = DataServiceClient(transport_client=self.transport_client)
         return self._service_client

python/lib/externalrequests/dmod/externalrequests/model_exec_request_handler.py

@@ -183,7 +183,7 @@ async def handle_request(self, request: ModelExecRequest, **kwargs) -> ModelExec
     @property
     def service_client(self) -> SchedulerClient:
         if self._scheduler_client is None:
-            self._scheduler_client = SchedulerClient(ssl_directory=self.service_ssl_dir, endpoint_uri=self.service_url)
+            self._scheduler_client = SchedulerClient(transport_client=self.transport_client)
         return self._scheduler_client
 
 

python/lib/externalrequests/setup.py

@@ -20,6 +20,6 @@
     author_email='',
     url='',
     license='',
-    install_requires=['websockets', 'dmod-core>=0.1.0', 'dmod-communication>=0.4.2', 'dmod-access>=0.1.1'],
+    install_requires=['websockets', 'dmod-core>=0.1.0', 'dmod-communication>=0.15.0', 'dmod-access>=0.1.1'],
     packages=find_namespace_packages(exclude=['dmod.test', 'schemas', 'ssl', 'src'])
 )