Teach TrinityConfig to handle sub configs

This commits adds sub config handling to TrinityConfig.
This is needed to support different kinds of nodes
that are loosely related yet different enough to
demand different configurations.

This allows us to handle shared configs on a base
level as well as mixing in different sub configs
depending on the use case.

Author: cburgdorf

tests/trinity/core/configuration/test_trinity_config_object.py

@@ -15,6 +15,7 @@
 )
 from trinity.config import (
     TrinityConfig,
+    BeaconAppConfig,
     DATABASE_DIR_NAME,
 )
 from trinity.utils.filesystem import (
@@ -90,3 +91,12 @@ def test_trinity_config_explictely_provided_nodekey(nodekey_bytes, as_bytes):
     )
 
     assert trinity_config.nodekey.to_bytes() == nodekey_bytes
+
+
+def test_trinity_config_sub_configs():
+    trinity_config = TrinityConfig(network_id=1)
+    trinity_config.initialize_app_configs(None, (BeaconAppConfig,))
+
+    assert trinity_config.has_app_config(BeaconAppConfig)
+    beacon_config = trinity_config.get_app_config(BeaconAppConfig)
+    assert type(beacon_config) is BeaconAppConfig

trinity/bootstrap.py

@@ -32,6 +32,7 @@
     subparser,
 )
 from trinity.config import (
+    BaseAppConfig,
     TrinityConfig,
 )
 from trinity.constants import (
@@ -106,7 +107,9 @@
 ], None]
 
 
-def main_entry(trinity_boot: BootFn, plugins: Iterable[BasePlugin]) -> None:
+def main_entry(trinity_boot: BootFn,
+               plugins: Iterable[BasePlugin],
+               sub_configs: Iterable[Type[BaseAppConfig]]) -> None:
     event_bus = EventBus(ctx)
     main_endpoint = event_bus.create_endpoint(MAIN_EVENTBUS_ENDPOINT)
     main_endpoint.connect_no_wait()
@@ -149,7 +152,7 @@ def main_entry(trinity_boot: BootFn, plugins: Iterable[BasePlugin]) -> None:
         setup_log_levels(args.log_levels)
 
     try:
-        trinity_config = TrinityConfig.from_parser_args(args)
+        trinity_config = TrinityConfig.from_parser_args(args, sub_configs)
     except AmbigiousFileSystem:
         parser.error(TRINITY_AMBIGIOUS_FILESYSTEM_INFO)
 

trinity/config.py

@@ -1,3 +1,7 @@
+from abc import (
+    ABC,
+    abstractmethod,
+)
 import argparse
 from contextlib import contextmanager
 import json
@@ -6,9 +10,11 @@
     Any,
     cast,
     Dict,
+    Iterable,
     TYPE_CHECKING,
     Tuple,
     Type,
+    TypeVar,
     Union,
 )
 
@@ -185,6 +191,9 @@ def vm_configuration(self) -> VMConfiguration:
         return self.genesis_data.vm_configuration
 
 
+TAppConfig = TypeVar('TAppConfig', bound='BaseAppConfig')
+
+
 class TrinityConfig:
     _trinity_root_dir: Path = None
 
@@ -203,6 +212,8 @@ class TrinityConfig:
 
     _genesis_config: Dict[str, Any] = None
 
+    _app_configs: Dict[Type['BaseAppConfig'], 'BaseAppConfig'] = None
+
     def __init__(self,
                  network_id: int,
                  genesis_config: Dict[str, Any]=None,
@@ -222,6 +233,7 @@ def __init__(self,
         self.sync_mode = sync_mode
         self.port = port
         self.use_discv5 = use_discv5
+        self._app_configs = {}
 
         if genesis_config is not None:
             self.genesis_config = genesis_config
@@ -285,14 +297,6 @@ def sync_mode(self, value: str) -> None:
             raise ValueError(f"Unknown sync mode: {value}")
         self._sync_mode = value
 
-    @property
-    def is_light_mode(self) -> bool:
-        return self.sync_mode == SYNC_LIGHT
-
-    @property
-    def is_full_mode(self) -> bool:
-        return self.sync_mode == SYNC_FULL
-
     @property
     def logfile_path(self) -> Path:
         """
@@ -440,14 +444,89 @@ def nodekey(self, value: Union[bytes, PrivateKey]) -> None:
                 f"`PrivateKey` instance: got {type(self._nodekey)}"
             )
 
+    @contextmanager
+    def process_id_file(self, process_name: str):  # type: ignore
+        with PidFile(process_name, self.data_dir):
+            yield
+
     @classmethod
-    def from_parser_args(cls, parser_args: argparse.Namespace) -> 'TrinityConfig':
+    def from_parser_args(cls,
+                         parser_args: argparse.Namespace,
+                         app_config_types: Iterable[Type['BaseAppConfig']]) -> 'TrinityConfig':
         """
         Helper function for initializing from the namespace object produced by
         an ``argparse.ArgumentParser``
         """
         constructor_kwargs = construct_trinity_config_params(parser_args)
-        return cls(**constructor_kwargs)
+        trinity_config = cls(**constructor_kwargs)
+
+        trinity_config.initialize_app_configs(parser_args, app_config_types)
+
+        return trinity_config
+
+    def initialize_app_configs(self,
+                               parser_args: argparse.Namespace,
+                               app_config_types: Iterable[Type['BaseAppConfig']]) -> None:
+        """
+        Initialize all available ``BaseAppConfig`` based on their concrete types,
+        the ``parser_args`` and the existing ``TrinityConfig`` instance.
+        """
+        for app_config_type in app_config_types:
+            self.add_app_config(app_config_type.from_parser_args(parser_args, self))
+
+    def add_app_config(self, app_config: 'BaseAppConfig') -> None:
+        """
+        Register the given ``app_config``.
+        """
+        self._app_configs[type(app_config)] = app_config
+
+    def has_app_config(self, app_config_type: Type['BaseAppConfig']) -> bool:
+        """
+        Check if a ``BaseAppConfig`` exists based on the given ``app_config_type``.
+        """
+        return app_config_type in self._app_configs.keys()
+
+    def get_app_config(self, app_config_type: Type[TAppConfig]) -> TAppConfig:
+        """
+        Return the ``BaseAppConfig`` derived instance based on the given ``app_config_type``.
+        """
+        # We want this API to return the specific type of the app config that is requested.
+        # Our backing field only knows that it is holding `BaseAppConfig`'s but not concrete types
+        return cast(TAppConfig, self._app_configs[app_config_type])
+
+
+class BaseAppConfig(ABC):
+
+    def __init__(self, trinity_config: TrinityConfig):
+        self.trinity_config = trinity_config
+
+    @classmethod
+    @abstractmethod
+    def from_parser_args(cls,
+                         args: argparse.Namespace,
+                         trinity_config: TrinityConfig) -> 'BaseAppConfig':
+        """
+        Initialize from the namespace object produced by
+        an ``argparse.ArgumentParser`` and the ``TrinityConfig``
+        """
+        pass
+
+
+class Eth1AppConfig(BaseAppConfig):
+
+    @classmethod
+    def from_parser_args(cls,
+                         args: argparse.Namespace,
+                         trinity_config: TrinityConfig) -> 'BaseAppConfig':
+        return cls(trinity_config)
+
+    @property
+    def is_light_mode(self) -> bool:
+        return self.trinity_config.sync_mode == SYNC_LIGHT
+
+    @property
+    def is_full_mode(self) -> bool:
+        return self.trinity_config.sync_mode == SYNC_FULL
 
     @property
     def node_class(self) -> Type['Node']:
@@ -464,7 +543,11 @@ def node_class(self) -> Type['Node']:
         else:
             raise NotImplementedError("Only full and light sync modes are supported")
 
-    @contextmanager
-    def process_id_file(self, process_name: str):  # type: ignore
-        with PidFile(process_name, self.data_dir):
-            yield
+
+class BeaconAppConfig(BaseAppConfig):
+
+    @classmethod
+    def from_parser_args(cls,
+                         args: argparse.Namespace,
+                         trinity_config: TrinityConfig) -> 'BaseAppConfig':
+        return cls(trinity_config)

trinity/main.py

@@ -25,6 +25,7 @@
 )
 from trinity.config import (
     TrinityConfig,
+    Eth1AppConfig,
 )
 from trinity.constants import (
     NETWORKING_EVENTBUS_ENDPOINT,
@@ -65,7 +66,7 @@ def get_all_plugins() -> Iterable[BasePlugin]:
 
 
 def main() -> None:
-    main_entry(trinity_boot, get_all_plugins())
+    main_entry(trinity_boot, get_all_plugins(), (Eth1AppConfig,))
 
 
 def trinity_boot(args: Namespace,
@@ -147,7 +148,7 @@ def kill_trinity_with_reason(reason: str) -> None:
 def launch_node(args: Namespace, trinity_config: TrinityConfig, endpoint: Endpoint) -> None:
     with trinity_config.process_id_file('networking'):
 
-        NodeClass = trinity_config.node_class
+        NodeClass = trinity_config.get_app_config(Eth1AppConfig).node_class
         node = NodeClass(endpoint, trinity_config)
         loop = node.get_event_loop()
 

trinity/main_beacon.py

@@ -21,6 +21,7 @@
 )
 from trinity.config import (
     TrinityConfig,
+    BeaconAppConfig
 )
 from trinity.events import (
     ShutdownRequest
@@ -41,7 +42,7 @@
 
 
 def main_beacon() -> None:
-    main_entry(trinity_boot, BASE_PLUGINS)
+    main_entry(trinity_boot, BASE_PLUGINS, (BeaconAppConfig,))
 
 
 def trinity_boot(args: Namespace,

trinity/plugins/builtin/json_rpc/plugin.py

@@ -4,6 +4,7 @@
 )
 import asyncio
 
+from trinity.config import Eth1AppConfig
 from trinity.chains.base import BaseAsyncChain
 from trinity.db.manager import (
     create_db_manager
@@ -47,15 +48,16 @@ def do_start(self) -> None:
         db_manager.connect()
 
         trinity_config = self.context.trinity_config
+        eth1_app_config = self.context.trinity_config.get_app_config(Eth1AppConfig)
         chain_config = trinity_config.get_chain_config()
 
         chain: BaseAsyncChain
 
-        if self.context.trinity_config.is_light_mode:
+        if eth1_app_config.is_light_mode:
             header_db = db_manager.get_headerdb()  # type: ignore
             event_bus_light_peer_chain = EventBusLightPeerChain(self.context.event_bus)
             chain = chain_config.light_chain_class(header_db, peer_chain=event_bus_light_peer_chain)
-        elif trinity_config.is_full_mode:
+        elif eth1_app_config.is_full_mode:
             db = db_manager.get_db()  # type: ignore
             chain = chain_config.full_chain_class(db)
         else: