def trinity_boot(args: Namespace, trinity_config: TrinityConfig, extra_kwargs: Dict[str, Any], listener: logging.handlers.QueueListener, logger: logging.Logger) -> Tuple[multiprocessing.Process, ...]: # start the listener thread to handle logs produced by other processes in # the local logger. listener.start() ensure_beacon_dirs(trinity_config.get_app_config(BeaconAppConfig)) # First initialize the database process. database_server_process = ctx.Process( name="DB", target=run_database_process, args=( trinity_config, LevelDB, ), kwargs=extra_kwargs, ) # start the processes database_server_process.start() logger.info("Started DB server process (pid=%d)", database_server_process.pid) try: wait_for_ipc(trinity_config.database_ipc_path) except TimeoutError as e: logger.error("Timeout waiting for database to start. Exiting...") kill_process_gracefully(database_server_process, logger) ArgumentParser().error(message="Timed out waiting for database start") return None return (database_server_process,)
def trinity_boot(boot_info: BootInfo) -> Tuple[multiprocessing.Process]: trinity_config = boot_info.trinity_config ensure_eth1_dirs(trinity_config.get_app_config(Eth1AppConfig)) logger = logging.getLogger('trinity') # First initialize the database process. database_server_process: multiprocessing.Process = ctx.Process( name="DB", target=run_database_process, args=( boot_info, LevelDB, ), ) # start the processes database_server_process.start() logger.info("Started DB server process (pid=%d)", database_server_process.pid) # networking process needs the IPC socket file provided by the database process try: wait_for_ipc(trinity_config.database_ipc_path) except TimeoutError: logger.error("Timeout waiting for database to start. Exiting...") kill_process_gracefully(database_server_process, logger) ArgumentParser().error(message="Timed out waiting for database start") return None return (database_server_process,)
async def _run(boot_info: BootInfo, get_base_db_fn: Callable[[BootInfo], LevelDB], component_manager: AsyncioManager) -> None: logger = logging.getLogger('trinity') start_new_session = True if os.getenv('TRINITY_SINGLE_PROCESS_GROUP') == "1": # This is needed because some of our integration tests rely on all processes being in # a single process group. start_new_session = False async with open_in_process( run_db_manager, boot_info, get_base_db_fn, subprocess_kwargs={'start_new_session': start_new_session}, ) as db_proc: logger.info("Started DB server process (pid=%d)", db_proc.pid) try: wait_for_ipc(boot_info.trinity_config.database_ipc_path) except TimeoutError: logger.error("Timeout waiting for database to start. Exiting...") argparse.ArgumentParser().error( message="Timed out waiting for database start") return None try: await component_manager.run() finally: try: await component_manager.stop() finally: logger.info("Terminating DB process") db_proc.send_signal(signal.SIGINT)
def database_server_ipc_path(): core_db = AtomicDB() core_db[b'key-a'] = b'value-a' chaindb = ChainDB(core_db) # TODO: use a custom chain class only for testing. chaindb.persist_header(ROPSTEN_GENESIS_HEADER) with tempfile.TemporaryDirectory() as temp_dir: trinity_config = TrinityConfig( network_id=ROPSTEN_NETWORK_ID, trinity_root_dir=temp_dir, ) trinity_config.add_app_config(Eth1AppConfig(trinity_config, None)) initialize_data_dir(trinity_config) manager = create_db_server_manager(trinity_config, core_db) chaindb_server_process = multiprocessing.Process( target=serve_chaindb, args=(manager, ), ) chaindb_server_process.start() wait_for_ipc(trinity_config.database_ipc_path) try: yield trinity_config.database_ipc_path finally: kill_process_gracefully(chaindb_server_process, logging.getLogger())
def trinity_boot(args: Namespace, trinity_config: TrinityConfig, extra_kwargs: Dict[str, Any], plugin_manager: PluginManager, listener: logging.handlers.QueueListener, event_bus: EventBus, main_endpoint: Endpoint, logger: logging.Logger) -> None: # start the listener thread to handle logs produced by other processes in # the local logger. listener.start() event_bus.start() # First initialize the database process. database_server_process = ctx.Process( name="DB", target=run_database_process, args=( trinity_config, LevelDB, ), kwargs=extra_kwargs, ) # start the processes database_server_process.start() logger.info("Started DB server process (pid=%d)", database_server_process.pid) # networking process needs the IPC socket file provided by the database process try: wait_for_ipc(trinity_config.database_ipc_path) except TimeoutError as e: logger.error("Timeout waiting for database to start. Exiting...") kill_process_gracefully(database_server_process, logger) ArgumentParser().error(message="Timed out waiting for database start") def kill_trinity_with_reason(reason: str) -> None: kill_trinity_gracefully(logger, (database_server_process, ), plugin_manager, main_endpoint, event_bus, reason=reason) main_endpoint.subscribe(ShutdownRequest, lambda ev: kill_trinity_with_reason(ev.reason)) plugin_manager.prepare(args, trinity_config, extra_kwargs) kill_trinity_with_reason("No beacon support yet. SOON!") try: loop = asyncio.get_event_loop() loop.add_signal_handler(signal.SIGTERM, lambda: kill_trinity_with_reason("SIGTERM")) loop.run_forever() loop.close() except KeyboardInterrupt: kill_trinity_with_reason("CTRL+C / Keyboard Interrupt")
def trinity_boot( args: Namespace, trinity_config: TrinityConfig, extra_kwargs: Dict[str, Any], plugin_manager: PluginManager, listener: logging.handlers.QueueListener, main_endpoint: TrinityMainEventBusEndpoint, logger: logging.Logger) -> Tuple[multiprocessing.Process, ...]: # start the listener thread to handle logs produced by other processes in # the local logger. listener.start() ensure_eth1_dirs(trinity_config.get_app_config(Eth1AppConfig)) # First initialize the database process. database_server_process: multiprocessing.Process = ctx.Process( name="DB", target=run_database_process, args=( trinity_config, LevelDB, ), kwargs=extra_kwargs, ) networking_process: multiprocessing.Process = ctx.Process( name="networking", target=launch_node, args=( args, trinity_config, ), kwargs=extra_kwargs, ) # start the processes database_server_process.start() logger.info("Started DB server process (pid=%d)", database_server_process.pid) # networking process needs the IPC socket file provided by the database process try: wait_for_ipc(trinity_config.database_ipc_path) except TimeoutError as e: logger.error("Timeout waiting for database to start. Exiting...") kill_process_gracefully(database_server_process, logger) ArgumentParser().error(message="Timed out waiting for database start") return None networking_process.start() logger.info("Started networking process (pid=%d)", networking_process.pid) return (database_server_process, networking_process)
def connect(cls: Type[THandler], path: Path) -> THandler: wait_for_ipc(path) s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) cls.logger.debug("Opened connection to %s: %s", path, s) s.connect(str(path)) return cls(s)
def connect(cls, path: pathlib.Path) -> "DBClient": wait_for_ipc(path) s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) cls.logger.debug("Opened connection to %s: %s", path, s) s.connect(str(path)) return cls(s)