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)
