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,)
def get_chain(trinity_config: TrinityConfig) -> ChainAPI:
app_config = trinity_config.get_app_config(Eth1AppConfig)
ensure_eth1_dirs(app_config)
base_db = LevelDB(db_path=app_config.database_dir)
chain_config = app_config.get_chain_config()
chain = chain_config.full_chain_class(AtomicDB(base_db))
initialize_database(chain_config, chain.chaindb, base_db)
return chain
def _run() -> None:
from eth.db.backends.level import LevelDB
from eth.db.chain import ChainDB
from trinity.cli_parser import parser
from trinity.config import Eth1AppConfig, TrinityConfig
from trinity.constants import APP_IDENTIFIER_ETH1
from trinity.initialization import (
initialize_data_dir,
is_data_dir_initialized,
is_database_initialized,
initialize_database,
ensure_eth1_dirs,
)
# Require a root dir to be specified as we don't want to mess with the default one.
for action in parser._actions:
if action.dest == 'trinity_root_dir':
action.required = True
break
args = parser.parse_args()
# FIXME: Figure out a way to avoid having to set this.
args.sync_mode = "full"
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)s: %(message)s',
datefmt='%H:%M:%S')
for name, level in args.log_levels.items():
logging.getLogger(name).setLevel(level)
trinity_config = TrinityConfig.from_parser_args(args, APP_IDENTIFIER_ETH1,
(Eth1AppConfig, ))
trinity_config.trinity_root_dir.mkdir(exist_ok=True)
if not is_data_dir_initialized(trinity_config):
initialize_data_dir(trinity_config)
with trinity_config.process_id_file('database'):
app_config = trinity_config.get_app_config(Eth1AppConfig)
ensure_eth1_dirs(app_config)
base_db = LevelDB(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 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 eth1_app_config(trinity_config):
eth1_app_config = Eth1AppConfig(trinity_config, None)
ensure_eth1_dirs(eth1_app_config)
return eth1_app_config
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) -> None:
# 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 = ctx.Process(
name="DB",
target=run_database_process,
args=(
trinity_config,
LevelDB,
),
kwargs=extra_kwargs,
)
networking_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")
networking_process.start()
logger.info("Started networking process (pid=%d)", networking_process.pid)
def kill_trinity_with_reason(reason: str) -> None:
kill_trinity_gracefully(trinity_config,
logger,
(networking_process, database_server_process),
plugin_manager,
main_endpoint,
reason=reason)
main_endpoint.subscribe(ShutdownRequest,
lambda ev: kill_trinity_with_reason(ev.reason))
plugin_manager.prepare(args, trinity_config, extra_kwargs)
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(boot_info: BootInfo) -> None:
trinity_config = boot_info.trinity_config
ensure_eth1_dirs(trinity_config.get_app_config(Eth1AppConfig))
