tracdap-runtime 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

tracdap/rt/_exec/server.py

@@ -12,57 +12,334 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import asyncio
+import threading
 import typing as tp
-import concurrent.futures as futures
+
+import tracdap.rt.config as config
+import tracdap.rt.exceptions as ex
+import tracdap.rt._exec.actors as actors
+import tracdap.rt._impl.grpc.codec as codec  # noqa
+import tracdap.rt._impl.util as util  # noqa
+
+# Check whether gRPC is installed before trying to load any of the generated modules
+try:
+    import grpc.aio  # noqa
+    import google.protobuf.message as _msg  # noqa
+except ImportError:
+    raise ex.EStartup("The runtime API server cannot be enabled because gRPC libraries are not installed")
 
 # Imports for gRPC generated code, these are managed by build_runtime.py for distribution
 import tracdap.rt._impl.grpc.tracdap.api.internal.runtime_pb2 as runtime_pb2
 import tracdap.rt._impl.grpc.tracdap.api.internal.runtime_pb2_grpc as runtime_grpc
-import grpc
 
 
 class RuntimeApiServer(runtime_grpc.TracRuntimeApiServicer):
 
-    __THREAD_POOL_DEFAULT_SIZE = 2
-    __THREAD_NAME_PREFIX = "server-"
-    __DEFAULT_SHUTDOWN_TIMEOUT = 10.0  # seconds
+    # Default timeout values in seconds
+    __DEFAULT_STARTUP_TIMEOUT = 5.0
+    __DEFAULT_SHUTDOWN_TIMEOUT = 10.0
+    __DEFAULT_REQUEST_TIMEOUT = 10.0
+
+    def __init__(self, system: actors.ActorSystem, port: int):
+
+        self.__log = util.logger_for_object(self)
+
+        self.__system = system
+        self.__engine_id = system.main_id()
+        self.__agent: tp.Optional[ApiAgent] = None
 
-    def __init__(self, port: int, n_workers: int = None):
         self.__port = port
-        self.__n_workers = n_workers or self.__THREAD_POOL_DEFAULT_SIZE
-        self.__server: tp.Optional[grpc.Server] = None
-        self.__thread_pool: tp.Optional[futures.ThreadPoolExecutor] = None
+        self.__request_timeout = self.__DEFAULT_REQUEST_TIMEOUT  # Not configurable atm
+        self.__server: tp.Optional[grpc.aio.Server] = None
+        self.__server_thread: tp.Optional[threading.Thread] = None
+        self.__event_loop: tp.Optional[asyncio.AbstractEventLoop] = None
+
+        self.__start_signal: tp.Optional[threading.Event] = None
+        self.__stop_signal: tp.Optional[asyncio.Event] = None
+
+    def start(self, startup_timeout: float = None):
+
+        if self.__start_signal is not None:
+            return
+
+        timeout = startup_timeout or self.__DEFAULT_SHUTDOWN_TIMEOUT
+
+        self.__start_signal = threading.Event()
+        self.__server_thread = threading.Thread(target=self.__server_main, name="api_server", daemon=True)
+        self.__server_thread.start()
+
+        try:
+            self.__start_signal.wait(timeout)
+        except TimeoutError as e:
+            raise ex.EStartup("Runtime API failed to start") from e
+
+    def stop(self, shutdown_timeout: float = None):
+
+        if self.__server is None:
+            return
+
+        timeout = shutdown_timeout or self.__DEFAULT_SHUTDOWN_TIMEOUT
 
-    def listJobs(self, request, context):
-        return super().listJobs(request, context)
+        self.__event_loop.call_soon_threadsafe(lambda: self.__stop_signal.set())
+        self.__server_thread.join(timeout)
 
-    def getJobStatus(self, request: runtime_pb2.BatchJobStatusRequest, context: grpc.ServicerContext):
-        return super().getJobStatus(request, context)
+        if self.__server_thread.is_alive():
+            self.__log.warning("Runtime API server did not go down cleanly")
 
-    def getJobDetails(self, request, context):
-        return super().getJobDetails(request, context)
+    def __server_main(self):
 
-    def start(self):
+        self.__event_loop = asyncio.new_event_loop()
+        self.__event_loop.run_until_complete(self.__server_main_async())
+        self.__event_loop.close()
 
-        self.__thread_pool = futures.ThreadPoolExecutor(
-            max_workers=self.__n_workers,
-            thread_name_prefix=self.__THREAD_NAME_PREFIX)
+    async def __server_main_async(self):
 
-        self.__server = grpc.server(self.__thread_pool)
+        server_address = f"[::]:{self.__port}"
 
-        socket = f"[::]:{self.__port}"
-        self.__server.add_insecure_port(socket)
+        # Asyncio events must be created inside the event loop for Python <= 3.9
+        self.__stop_signal = asyncio.Event()
 
+        # Agent using asyncio, so must be created inside the event loop
+        self.__agent = ApiAgent()
+        self.__system.spawn_agent(self.__agent)
+
+        self.__server = grpc.aio.server()
+        self.__server.add_insecure_port(server_address)
         runtime_grpc.add_TracRuntimeApiServicer_to_server(self, self.__server)
 
-        self.__server.start()
+        await self.__server.start()
+        await self.__agent.started()
 
-    def stop(self, shutdown_timeout: float = None):
+        self.__start_signal.set()
+
+        self.__log.info(f"Runtime API server is up and listening on port [{self.__port}]")
+
+        await asyncio.create_task(self.__stop_signal.wait())
+
+        self.__log.info(f"Shutdown signal received, runtime API server is going down...")
+
+        await self.__server.stop(self.__DEFAULT_SHUTDOWN_TIMEOUT)
+        self.__server = None
+
+        self.__log.info("Runtime API server has gone down cleanly")
+
+    async def listJobs(self, request: runtime_pb2.RuntimeListJobsRequest, context: grpc.aio.ServicerContext):
+
+        request_task = ListJobsRequest(self.__engine_id, request, context)
+        self.__agent.threadsafe().spawn(request_task)
+
+        return await request_task.complete(self.__request_timeout)
+
+    async def getJobStatus(self, request: runtime_pb2.RuntimeJobInfoRequest, context: grpc.ServicerContext):
+
+        request_task = GetJobStatusRequest(self.__engine_id, request, context)
+        self.__agent.threadsafe().spawn(request_task)
+
+        return await request_task.complete(self.__request_timeout)
+
+    async def getJobResult(self, request: runtime_pb2.RuntimeJobInfoRequest, context: grpc.ServicerContext):
+
+        request_task = GetJobResultRequest(self.__engine_id, request, context)
+        self.__agent.threadsafe().spawn(request_task)
+
+        return await request_task.complete(self.__request_timeout)
+
+
+_T_REQUEST = tp.TypeVar("_T_REQUEST", bound=_msg.Message)
+_T_RESPONSE = tp.TypeVar("_T_RESPONSE", bound=_msg.Message)
+
+
+class ApiAgent(actors.ThreadsafeActor):
+
+    # API Agent is the parent actor that will be used to spawn API requests
+    # It must be created inside the asyncio event loop
+
+    def __init__(self):
+        super().__init__()
+        self._log = util.logger_for_object(self)
+        self._event_loop = asyncio.get_event_loop()
+        self.__start_signal = asyncio.Event()
+
+    def on_start(self):
+        self._event_loop.call_soon_threadsafe(lambda: self.__start_signal.set())
+
+    def on_signal(self, signal: actors.Signal) -> tp.Optional[bool]:
+
+        # Do not allow a failed request to bring down the API server
+        if signal.message == actors.SignalNames.FAILED:
+            error = signal.error if isinstance(signal, actors.ErrorSignal) else None
+            self._log.warning("Unhandled error during API request: " + str(error))
+            self._log.warning("The API agent will continue running")
+            return True
+
+        return False
+
+    async def started(self):
+        await self.__start_signal.wait()
+
+
+class ApiRequest(actors.ThreadsafeActor, tp.Generic[_T_REQUEST, _T_RESPONSE]):
+
+    # API request is the bridge between asyncio events (gRPC) and actor messages (TRAC runtime engine)
+    # Requests objects must be created inside the asyncio event loop
+
+    _log = None
+
+    def __init__(
+            self, engine_id, method: str, request: _T_REQUEST,
+            context: grpc.aio.ServicerContext):
+
+        super().__init__()
+
+        self._engine_id = engine_id
+        self._method = method
+        self._request = request
+        self._response: tp.Optional[_T_RESPONSE] = None
+        self._error: tp.Optional[Exception] = None
+        self._grpc_code = grpc.StatusCode.OK
+        self._grpc_message = ""
+
+        self._context = context
+        self._event_loop = asyncio.get_event_loop()
+        self._completion = asyncio.Event()
+
+        self._log.info("API call start: %s()", self._method)
+
+    def _mark_complete(self):
+
+        self._event_loop.call_soon_threadsafe(lambda: self._completion.set())
+
+    def on_stop(self):
+
+        if self.state() == actors.ActorState.ERROR:
+            self._error = self.error()
+
+        self._mark_complete()
+
+    async def complete(self, request_timeout: float) -> _T_RESPONSE:
+
+        try:
+
+            completion_task = asyncio.create_task(self._completion.wait())
+            await asyncio.wait_for(completion_task, request_timeout)
+
+            if self._error:
+                raise self._error
+
+            elif self._grpc_code != grpc.StatusCode.OK:
+                self._log.info("API call failed: %s() %s %s", self._method, self._grpc_code.name, self._grpc_message)
+                self._context.set_code(self._grpc_code)
+                self._context.set_details(self._grpc_message)
+
+            elif self._response is not None:
+                self._log.info("API call succeeded: %s()", self._method)
+                return self._response
+
+            else:
+                raise ex.EUnexpected()
+
+        except TimeoutError:
+            self._completion.set()
+            self._context.set_code(grpc.StatusCode.DEADLINE_EXCEEDED)
+            self._context.set_details("The TRAC runtime engine did not respond")
+            self._log.error("API call failed: %s() %s", self._method, "The TRAC runtime engine did not respond")
+            raise
+
+        except Exception as e:
+            self._context.set_code(grpc.StatusCode.INTERNAL)
+            self._context.set_details("Internal server error")
+            self._log.error("API call failed: %s() %s", self._method, str(e))
+            self._log.exception(e)
+            raise
+
+        finally:
+            self.threadsafe().stop()
+
+
+ApiRequest._log = util.logger_for_class(ApiRequest)
+
+
+class ListJobsRequest(ApiRequest[runtime_pb2.RuntimeListJobsRequest, runtime_pb2.RuntimeListJobsResponse]):
+
+    def __init__(self, engine_id, request, context):
+        super().__init__(engine_id, "get_job_list", request, context)
+
+    def on_start(self):
+        self.actors().send(self._engine_id, "get_job_list")
+
+    @actors.Message
+    def job_list(self, job_list):
+
+        self._response = runtime_pb2.RuntimeListJobsResponse(
+            jobs=codec.encode(job_list))
+
+        self._mark_complete()
+
+
+class GetJobStatusRequest(ApiRequest[runtime_pb2.RuntimeJobInfoRequest, runtime_pb2.RuntimeJobStatus]):
+
+    def __init__(self, engine_id, request, context):
+
+        super().__init__(engine_id, "get_job_status", request, context)
+
+        if request.HasField("jobKey"):
+            self._job_key = self._request.jobKey
+        elif request.HasField("jobSelector"):
+            self._job_key = util.object_key(self._request.jobSelector)
+        else:
+            raise ex.EValidation("Bad request: Neither jobKey nor jobSelector is specified")
+
+    def on_start(self):
+        self.actors().send(self._engine_id, "get_job_details", self._job_key, details=False)
+
+    @actors.Message
+    def job_details(self, job_details: tp.Optional[config.JobResult]):
+
+        if job_details is None:
+            self._grpc_code = grpc.StatusCode.NOT_FOUND
+            self._grpc_message = f"Job not found: [{self._job_key}]"
+
+        else:
+            self._response = runtime_pb2.RuntimeJobStatus(
+                jobId=codec.encode(job_details.jobId),
+                statusCode=codec.encode(job_details.statusCode),
+                statusMessage=codec.encode(job_details.statusMessage))
+
+        self._mark_complete()
+
+
+class GetJobResultRequest(ApiRequest[runtime_pb2.RuntimeJobInfoRequest, runtime_pb2.RuntimeJobResult]):
+
+    def __init__(self, engine_id, request, context):
+
+        super().__init__(engine_id, "get_job_result", request, context)
+
+        if request.HasField("jobKey"):
+            self._job_key = self._request.jobKey
+        elif request.HasField("jobSelector"):
+            self._job_key = util.object_key(self._request.jobSelector)
+        else:
+            raise ex.EValidation("Bad request: Neither jobKey nor jobSelector is specified")
+
+    def on_start(self):
+        self.actors().send(self._engine_id, "get_job_details", self._job_key, details=True)
+
+    @actors.Message
+    def job_details(self, job_details: tp.Optional[config.JobResult]):
+
+        if job_details is None:
+            self._grpc_code = grpc.StatusCode.NOT_FOUND
+            self._grpc_message = f"Job not found: [{self._job_key}]"
+
+        else:
 
-        grace = shutdown_timeout or self.__DEFAULT_SHUTDOWN_TIMEOUT
+            encoded_results = dict((k, codec.encode(v)) for k, v in job_details.results.items())
 
-        if self.__server is not None:
-            self.__server.stop(grace)
+            self._response = runtime_pb2.RuntimeJobResult(
+                jobId=codec.encode(job_details.jobId),
+                statusCode=codec.encode(job_details.statusCode),
+                statusMessage=codec.encode(job_details.statusMessage),
+                results=encoded_results)
 
-        if self.__thread_pool is not None:
-            self.__thread_pool.shutdown()
+        self._mark_complete()

tracdap/rt/_impl/config_parser.py

@@ -14,89 +14,216 @@
 
 from __future__ import annotations
 
-import re
-import typing as tp
+import dataclasses as _dc
 import decimal
 import enum
-import uuid
+import io
 import inspect
-import dataclasses as _dc
+import json
+import os
+import pathlib
+import re
+import typing as tp
+import urllib.parse as _urlp
+import uuid
 
+import tracdap.rt.config as _config
 import tracdap.rt.exceptions as _ex
+import tracdap.rt.ext.plugins as _plugins
+import tracdap.rt.ext.config as _config_ext
 import tracdap.rt._impl.util as _util
 
-import pathlib
-import json
 import yaml
 import yaml.parser
 
-
 _T = tp.TypeVar('_T')
 
 
-class ConfigParser(tp.Generic[_T]):
+class ConfigManager:
 
-    # The metaclass for generic types varies between versions of the typing library
-    # To work around this, detect the correct metaclass by inspecting a generic type variable
-    __generic_metaclass = type(tp.List[object])
+    @classmethod
+    def for_root_config(cls, root_config_file: tp.Union[str, pathlib.Path, None]) -> ConfigManager:
+
+        if isinstance(root_config_file, pathlib.Path):
+            root_file_path = cls._resolve_scheme(root_config_file)
+            root_dir_path = cls._resolve_scheme(root_config_file.parent)
+            if root_dir_path[-1] not in ["/", "\\"]:
+                root_dir_path += os.sep
+            root_file_url = _urlp.urlparse(root_file_path, scheme="file")
+            root_dir_url = _urlp.urlparse(root_dir_path, scheme="file")
+            return ConfigManager(root_dir_url, root_file_url, )
+
+        elif isinstance(root_config_file, str):
+            root_file_with_scheme = cls._resolve_scheme(root_config_file)
+            root_file_url = _urlp.urlparse(root_file_with_scheme, scheme="file")
+            root_dir_path = str(pathlib.Path(root_file_url.path).parent)
+            if root_dir_path[-1] not in ["/", "\\"]:
+                root_dir_path += os.sep if root_file_url.scheme == "file" else "/"
+            root_dir_url = _urlp.urlparse(_urlp.urljoin(root_file_url.geturl(), root_dir_path))
+            return ConfigManager(root_dir_url, root_file_url)
 
-    __primitive_types: tp.Dict[type, callable] = {
-        bool: bool,
-        int: int,
-        float: float,
-        str: str,
-        decimal.Decimal: decimal.Decimal
-        # TODO: Date (requires type system)
-        # TODO: Datetime (requires type system)
-    }
+        else:
+            working_dir_path = str(pathlib.Path.cwd().resolve())
+            working_dir_url = _urlp.urlparse(str(working_dir_path), scheme="file")
+            return ConfigManager(working_dir_url, None)
 
-    def __init__(self, config_class: _T.__class__, dev_mode_locations: tp.List[str] = None):
+    @classmethod
+    def for_root_dir(cls, root_config_dir: tp.Union[str, pathlib.Path]) -> ConfigManager:
+
+        if isinstance(root_config_dir, pathlib.Path):
+            root_dir_path = cls._resolve_scheme(root_config_dir)
+            if root_dir_path[-1] not in ["/", "\\"]:
+                root_dir_path += os.sep
+            root_dir_url = _urlp.urlparse(root_dir_path, scheme="file")
+            return ConfigManager(root_dir_url, None)
+
+        elif isinstance(root_config_dir, str):
+            root_dir_with_scheme = cls._resolve_scheme(root_config_dir)
+            if root_dir_with_scheme[-1] not in ["/", "\\"]:
+                root_dir_with_scheme += "/"
+            root_dir_url = _urlp.urlparse(root_dir_with_scheme, scheme="file")
+            return ConfigManager(root_dir_url, None)
+
+        # Should never happen since root dir is specified explicitly
+        else:
+            raise _ex.ETracInternal("Wrong parameter type for root_config_dir")
+
+    @classmethod
+    def _resolve_scheme(cls, raw_url: tp.Union[str, pathlib.Path]) -> str:
+
+        if isinstance(raw_url, pathlib.Path):
+            return "file:" + str(raw_url.resolve())
+
+        # Look for drive letters on Windows - these can be mis-interpreted as URL scheme
+        # If there is a drive letter, explicitly set scheme = file instead
+        if len(raw_url) > 1 and raw_url[1] == ":":
+            return "file:" + raw_url
+        else:
+            return raw_url
+
+    def __init__(self, root_dir_url: _urlp.ParseResult, root_file_url: tp.Optional[_urlp.ParseResult]):
         self._log = _util.logger_for_object(self)
-        self._config_class = config_class
-        self._dev_mode_locations = dev_mode_locations or []
-        self._errors = []
+        self._root_dir_url = root_dir_url
+        self._root_file_url = root_file_url
+
+    def config_dir_path(self):
+        if self._root_dir_url.scheme == "file":
+            return pathlib.Path(self._root_dir_url.path).resolve()
+        else:
+            return None
+
+    def load_root_object(
+            self, config_class: type(_T),
+            dev_mode_locations: tp.List[str] = None,
+            config_file_name: tp.Optional[str] = None) -> _T:
 
-    def load_raw_config(self, config_file: tp.Union[str, pathlib.Path], config_file_name: str = None):
+        # Root config not available normally means you're using embedded config
+        # In which case this method should not be called
+        if self._root_file_url is None:
+            message = f"Root config file not available"
+            self._log.error(message)
+            raise _ex.EConfigLoad(message)
+
+        resolved_url = self._root_file_url
 
         if config_file_name is not None:
-            self._log.info(f"Loading {config_file_name} config: {str(config_file)}")
+            self._log.info(f"Loading {config_file_name} config: {self._url_to_str(resolved_url)}")
         else:
-            self._log.info(f"Loading config file: {str(config_file)}")
+            self._log.info(f"Loading config file: {self._url_to_str(resolved_url)}")
+
+        config_dict = self._load_config_dict(resolved_url)
 
-        # Construct a Path for config_file and make sure the file exists
-        # (For now, config must be on a locally mounted filesystem)
+        parser = ConfigParser(config_class, dev_mode_locations)
+        return parser.parse(config_dict, resolved_url.path)
 
-        if isinstance(config_file, str):
-            config_path = pathlib.Path(config_file)
+    def load_config_object(
+            self, config_url: tp.Union[str, pathlib.Path],
+            config_class: type(_T),
+            dev_mode_locations: tp.List[str] = None,
+            config_file_name: tp.Optional[str] = None) -> _T:
 
-        elif isinstance(config_file, pathlib.Path):
-            config_path = config_file
+        resolved_url = self._resolve_config_file(config_url)
 
+        if config_file_name is not None:
+            self._log.info(f"Loading {config_file_name} config: {self._url_to_str(resolved_url)}")
         else:
-            config_file_type = type(config_file) if config_file is not None else "None"
-            err = f"Attempt to load an invalid config file, expected a path, got {config_file_type}"
-            self._log.error(err)
-            raise _ex.EConfigLoad(err)
+            self._log.info(f"Loading config file: {self._url_to_str(resolved_url)}")
 
-        if not config_path.exists():
-            msg = f"Config file not found: [{config_file}]"
-            self._log.error(msg)
-            raise _ex.EConfigLoad(msg)
+        config_dict = self._load_config_dict(resolved_url)
 
-        if not config_path.is_file():
-            msg = f"Config path does not point to a regular file: [{config_file}]"
-            self._log.error(msg)
-            raise _ex.EConfigLoad(msg)
+        parser = ConfigParser(config_class, dev_mode_locations)
+        return parser.parse(config_dict, config_url)
 
-        return self._parse_raw_config(config_path)
+    def load_config_file(
+            self, config_url: tp.Union[str, pathlib.Path],
+            config_file_name: tp.Optional[str] = None) -> bytes:
 
-    def _parse_raw_config(self, config_path: pathlib.Path):
+        resolved_url = self._resolve_config_file(config_url)
+
+        if config_file_name is not None:
+            self._log.info(f"Loading {config_file_name} config: {self._url_to_str(resolved_url)}")
+        else:
+            self._log.info(f"Loading config file: {self._url_to_str(resolved_url)}")
+
+        return self._load_config_file(resolved_url)
+
+    def _resolve_config_file(self, config_url: tp.Union[str, pathlib.Path]) -> _urlp.ParseResult:
+
+        # If the config URL defines a scheme, treat it as absolute
+        # (This also works for Windows paths, C:\ is an absolute path)
+        if ":" in str(config_url):
+            absolute_url = str(config_url)
+        # If the root URL is a path, resolve using path logic (this allows for config_url to be an absolute path)
+        elif self._root_dir_url.scheme == "file":
+            absolute_url = str(pathlib.Path(self._root_dir_url.path).joinpath(str(config_url)))
+        # Otherwise resolve relative to the root URL
+        else:
+            absolute_url = _urlp.urljoin(self._root_dir_url.geturl(), str(config_url))
+
+        # Look for drive letters on Windows - these can be mis-interpreted as URL scheme
+        # If there is a drive letter, explicitly set scheme = file instead
+        if len(absolute_url) > 1 and absolute_url[1] == ":":
+            absolute_url = "file:" + absolute_url
+
+        return _urlp.urlparse(absolute_url, scheme="file")
+
+    def _load_config_file(self, resolved_url: _urlp.ParseResult) -> bytes:
+
+        loader = self._get_loader(resolved_url)
+        config_url = self._url_to_str(resolved_url)
+
+        if not loader.has_config_file(config_url):
+            message = f"Config file not found: {config_url}"
+            self._log.error(message)
+            raise _ex.EConfigLoad(message)
+
+        return loader.load_config_file(config_url)
+
+    def _load_config_dict(self, resolved_url: _urlp.ParseResult) -> dict:
+
+        loader = self._get_loader(resolved_url)
+        config_url = self._url_to_str(resolved_url)
+
+        if loader.has_config_dict(config_url):
+            return loader.load_config_dict(config_url)
+
+        elif loader.has_config_file(config_url):
+            config_bytes = loader.load_config_file(config_url)
+            config_path = pathlib.Path(resolved_url.path)
+            return self._parse_config_dict(config_bytes, config_path)
+
+        else:
+            message = f"Config file not found: {config_url}"
+            self._log.error(message)
+            raise _ex.EConfigLoad(message)
+
+    def _parse_config_dict(self, config_bytes: bytes, config_path: pathlib.Path):
 
         # Read in the raw config, use the file extension to decide which format to expect
 
         try:
 
-            with config_path.open('r') as config_stream:
+            with io.BytesIO(config_bytes) as config_stream:
 
                 extension = config_path.suffix.lower()
 
@@ -123,11 +250,54 @@ class ConfigParser(tp.Generic[_T]):
             self._log.error(err)
             raise _ex.EConfigParse(err) from e
 
-        except yaml.parser.ParserError as e:
+        except (yaml.parser.ParserError, yaml.reader.ReaderError) as e:
             err = f"Config file contains invalid YAML ({str(e)})"
             self._log.error(err)
             raise _ex.EConfigParse(err) from e
 
+    def _get_loader(self, resolved_url: _urlp.ParseResult) -> _config_ext.IConfigLoader:
+
+        protocol = resolved_url.scheme
+        loader_config = _config.PluginConfig(protocol)
+
+        if not _plugins.PluginManager.is_plugin_available(_config_ext.IConfigLoader, protocol):
+            message = f"No config loader available for protocol [{protocol}]: {self._url_to_str(resolved_url)}"
+            self._log.error(message)
+            raise _ex.EConfigLoad(message)
+
+        return _plugins.PluginManager.load_config_plugin(_config_ext.IConfigLoader, loader_config)
+
+    @staticmethod
+    def _url_to_str(url: _urlp.ParseResult) -> str:
+
+        if url.scheme == "file" and not url.netloc:
+            return url.path
+        else:
+            return url.geturl()
+
+
+class ConfigParser(tp.Generic[_T]):
+
+    # The metaclass for generic types varies between versions of the typing library
+    # To work around this, detect the correct metaclass by inspecting a generic type variable
+    __generic_metaclass = type(tp.List[object])
+
+    __primitive_types: tp.Dict[type, callable] = {
+        bool: bool,
+        int: int,
+        float: float,
+        str: str,
+        decimal.Decimal: decimal.Decimal
+        # TODO: Date (requires type system)
+        # TODO: Datetime (requires type system)
+    }
+
+    def __init__(self, config_class: _T.__class__, dev_mode_locations: tp.List[str] = None):
+        self._log = _util.logger_for_object(self)
+        self._config_class = config_class
+        self._dev_mode_locations = dev_mode_locations or []
+        self._errors = []
+
     def parse(self, config_dict: dict, config_file: tp.Union[str, pathlib.Path] = None) -> _T:
 
         # If config is empty, return a default (blank) config