def launch_node(args: Namespace, trinity_config: TrinityConfig, endpoint: Endpoint) -> None:
with trinity_config.process_id_file('networking'):
endpoint.connect()
NodeClass = trinity_config.node_class
# Temporary hack: We setup a second instance of the PluginManager.
# The first instance was only to configure the ArgumentParser whereas
# for now, the second instance that lives inside the networking process
# performs the bulk of the work. In the future, the PluginManager
# should probably live in its own process and manage whether plugins
# run in the shared plugin process or spawn their own.
plugin_manager = setup_plugins(SharedProcessScope(endpoint))
plugin_manager.prepare(args, trinity_config)
plugin_manager.broadcast(TrinityStartupEvent(
args,
trinity_config
))
node = NodeClass(plugin_manager, trinity_config)
loop = node.get_event_loop()
asyncio.ensure_future(handle_networking_exit(node, plugin_manager, endpoint), loop=loop)
asyncio.ensure_future(node.run(), loop=loop)
loop.run_forever()
loop.close()
def run_database_process(trinity_config: TrinityConfig, db_class: Type[BaseDB]) -> None:
with trinity_config.process_id_file('database'):
app_config = trinity_config.get_app_config(Eth1AppConfig)
base_db = db_class(db_path=app_config.database_dir)
manager = create_db_server_manager(trinity_config, base_db)
serve_until_sigint(manager)
def run_monitoring(cls, args: argparse.Namespace,
trinity_config: TrinityConfig):
normalized_name = friendly_filename_or_url("monitoring_ui")
with trinity_config.process_id_file(normalized_name):
loop = asyncio.get_event_loop()
asyncio.ensure_future(monitoring(normalized_name, trinity_config))
loop.run_forever()
loop.close()
def launch_node(args: Namespace, trinity_config: TrinityConfig) -> None:
with trinity_config.process_id_file('networking'):
# The `networking` process creates a process pool executor to offload cpu intensive
# tasks. We should revisit that when we move the sync in its own process
ensure_global_asyncio_executor()
asyncio.ensure_future(launch_node_coro(args, trinity_config))
loop = asyncio.get_event_loop()
loop.run_forever()
loop.close()
def run_database_process(trinity_config: TrinityConfig,
db_class: Type[AtomicDatabaseAPI]) -> None:
with trinity_config.process_id_file('database'):
app_config = trinity_config.get_app_config(BeaconAppConfig)
base_db = db_class(db_path=app_config.database_dir)
manager = DBManager(base_db)
with manager.run(trinity_config.database_ipc_path):
try:
manager.wait_stopped()
except KeyboardInterrupt:
pass
def launch_node(args: Namespace, trinity_config: TrinityConfig, endpoint: Endpoint) -> None:
with trinity_config.process_id_file('networking'):
NodeClass = trinity_config.node_class
node = NodeClass(endpoint, trinity_config)
loop = node.get_event_loop()
endpoint.connect_no_wait(loop)
# This is a second PluginManager instance governing plugins in a shared process.
plugin_manager = setup_plugins(SharedProcessScope(endpoint))
plugin_manager.prepare(args, trinity_config)
asyncio.ensure_future(handle_networking_exit(node, plugin_manager, endpoint), loop=loop)
asyncio.ensure_future(node.run(), loop=loop)
loop.run_forever()
loop.close()
def run_database_process(trinity_config: TrinityConfig, db_class: Type[LevelDB]) -> None:
with trinity_config.process_id_file('database'):
app_config = trinity_config.get_app_config(BeaconAppConfig)
chain_config = app_config.get_chain_config()
base_db = db_class(db_path=app_config.database_dir)
chaindb = BeaconChainDB(base_db, chain_config.genesis_config)
if not is_beacon_database_initialized(chaindb, BeaconBlock):
initialize_beacon_database(chain_config, chaindb, base_db, BeaconBlock)
manager = DBManager(base_db)
with manager.run(trinity_config.database_ipc_path):
try:
manager.wait_stopped()
except KeyboardInterrupt:
pass
def run_database_process(trinity_config: TrinityConfig, db_class: Type[BaseDB]) -> None:
with trinity_config.process_id_file('database'):
base_db = db_class(db_path=trinity_config.database_dir)
manager = get_chaindb_manager(trinity_config, base_db)
server = manager.get_server() # type: ignore
def _sigint_handler(*args: Any) -> None:
server.stop_event.set()
signal.signal(signal.SIGINT, _sigint_handler)
try:
server.serve_forever()
except SystemExit:
server.stop_event.set()
raise
def run_database_process(trinity_config: TrinityConfig,
db_class: Type[AtomicDatabaseAPI]) -> None:
with trinity_config.process_id_file('database'):
app_config = trinity_config.get_app_config(Eth1AppConfig)
base_db = db_class(db_path=app_config.database_dir)
chaindb = ChainDB(base_db)
if not is_database_initialized(chaindb):
chain_config = app_config.get_chain_config()
initialize_database(chain_config, chaindb, base_db)
manager = DBManager(base_db)
with manager.run(trinity_config.database_ipc_path):
try:
manager.wait_stopped()
except KeyboardInterrupt:
pass
def launch_node(args: Namespace, trinity_config: TrinityConfig,
endpoint: Endpoint) -> None:
with trinity_config.process_id_file('networking'):
NodeClass = trinity_config.get_app_config(Eth1AppConfig).node_class
node = NodeClass(endpoint, trinity_config)
# The `networking` process creates a process pool executor to offload cpu intensive
# tasks. We should revisit that when we move the sync in its own process
ensure_global_asyncio_executor()
loop = node.get_event_loop()
endpoint.connect_no_wait(loop)
# This is a second PluginManager instance governing plugins in a shared process.
plugin_manager = setup_plugins(SharedProcessScope(endpoint),
get_all_plugins())
plugin_manager.prepare(args, trinity_config)
asyncio.ensure_future(handle_networking_exit(node, plugin_manager,
endpoint),
loop=loop)
asyncio.ensure_future(node.run(), loop=loop)
loop.run_forever()
loop.close()
def launch_node(args: Namespace, trinity_config: TrinityConfig) -> None:
with trinity_config.process_id_file('networking'):
endpoint = TrinityEventBusEndpoint()
NodeClass = trinity_config.get_app_config(Eth1AppConfig).node_class
node = NodeClass(endpoint, trinity_config)
# The `networking` process creates a process pool executor to offload cpu intensive
# tasks. We should revisit that when we move the sync in its own process
ensure_global_asyncio_executor()
loop = node.get_event_loop()
networking_connection_config = ConnectionConfig.from_name(
NETWORKING_EVENTBUS_ENDPOINT, trinity_config.ipc_dir)
endpoint.start_serving_nowait(
networking_connection_config,
loop,
)
endpoint.auto_connect_new_announced_endpoints()
endpoint.connect_to_endpoints_blocking(
ConnectionConfig.from_name(MAIN_EVENTBUS_ENDPOINT,
trinity_config.ipc_dir),
# Plugins that run within the networking process broadcast and receive on the
# the same endpoint
networking_connection_config,
)
endpoint.announce_endpoint()
# This is a second PluginManager instance governing plugins in a shared process.
plugin_manager = setup_plugins(SharedProcessScope(endpoint),
get_all_plugins())
plugin_manager.prepare(args, trinity_config)
asyncio.ensure_future(handle_networking_exit(node, plugin_manager,
endpoint),
loop=loop)
asyncio.ensure_future(node.run(), loop=loop)
loop.run_forever()
loop.close()
