def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
chain = self.chain_for_config(trinity_config)
if trinity_config.has_app_config(Eth1AppConfig):
modules = initialize_eth1_modules(chain, self.event_bus)
elif trinity_config.has_app_config(BeaconAppConfig):
modules = initialize_beacon_modules(chain, self.event_bus)
else:
raise Exception("Unsupported Node Type")
rpc = RPCServer(modules, chain, self.event_bus)
# Run IPC Server
ipc_server = IPCServer(rpc,
self.boot_info.trinity_config.jsonrpc_ipc_path)
asyncio.ensure_future(
exit_with_services(
ipc_server,
self._event_bus_service,
))
asyncio.ensure_future(ipc_server.run())
# Run HTTP Server
if self.boot_info.args.enable_http:
http_server = HTTPServer(rpc, port=self.boot_info.args.rpcport)
asyncio.ensure_future(
exit_with_services(
http_server,
self._event_bus_service,
))
asyncio.ensure_future(http_server.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
db = DBClient.connect(trinity_config.database_ipc_path)
app_config = trinity_config.get_app_config(Eth1AppConfig)
chain_config = app_config.get_chain_config()
chain = chain_config.full_chain_class(db)
if self.boot_info.trinity_config.network_id == MAINNET_NETWORK_ID:
validator = DefaultTransactionValidator(chain,
PETERSBURG_MAINNET_BLOCK)
elif self.boot_info.trinity_config.network_id == ROPSTEN_NETWORK_ID:
validator = DefaultTransactionValidator(chain,
PETERSBURG_ROPSTEN_BLOCK)
else:
raise ValueError(
"The TxPool component only supports MainnetChain or RopstenChain"
)
proxy_peer_pool = ETHProxyPeerPool(self.event_bus,
TO_NETWORKING_BROADCAST_CONFIG)
self.tx_pool = TxPool(self.event_bus, proxy_peer_pool, validator)
asyncio.ensure_future(
exit_with_services(self.tx_pool, self._event_bus_service))
asyncio.ensure_future(self.tx_pool.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
if trinity_config.has_app_config(Eth1AppConfig):
db_manager = create_db_consumer_manager(
trinity_config.database_ipc_path)
server = self.make_eth1_request_server(
trinity_config.get_app_config(Eth1AppConfig),
db_manager,
)
elif trinity_config.has_app_config(BeaconAppConfig):
db_manager = create_beacon_db_consumer_manager(
trinity_config.database_ipc_path)
server = self.make_beacon_request_server(
trinity_config.get_app_config(BeaconAppConfig),
db_manager,
)
else:
raise Exception(
"Trinity config must have either eth1 or beacon chain config")
asyncio.ensure_future(
exit_with_services(server, self._event_bus_service))
asyncio.ensure_future(server.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
db = DBClient.connect(trinity_config.database_ipc_path)
app_config = trinity_config.get_app_config(Eth1AppConfig)
chain_config = app_config.get_chain_config()
chain = chain_config.full_chain_class(db)
if self.boot_info.trinity_config.network_id == MAINNET_NETWORK_ID:
validator = DefaultTransactionValidator(chain,
BYZANTIUM_MAINNET_BLOCK)
elif self.boot_info.trinity_config.network_id == ROPSTEN_NETWORK_ID:
validator = DefaultTransactionValidator(chain,
BYZANTIUM_ROPSTEN_BLOCK)
else:
# TODO: We could hint the user about e.g. a --tx-pool-no-validation flag to run the
# tx pool without tx validation in this case
raise ValueError(
"The TxPool plugin only supports MainnetChain or RopstenChain")
proxy_peer_pool = ETHProxyPeerPool(self.event_bus,
TO_NETWORKING_BROADCAST_CONFIG)
self.tx_pool = TxPool(self.event_bus, proxy_peer_pool, validator)
asyncio.ensure_future(
exit_with_services(self.tx_pool, self._event_bus_service))
asyncio.ensure_future(self.tx_pool.run())
def do_start(self) -> None:
port = self.boot_info.trinity_config.port
self.upnp_service = UPnPService(port)
asyncio.ensure_future(exit_with_services(
self.upnp_service,
self._event_bus_service,
))
asyncio.ensure_future(self.upnp_service.run())
def do_start(self) -> None:
discovery_bootstrap = DiscoveryBootstrapService(
self.boot_info.args.disable_discovery, self.event_bus,
self.boot_info.trinity_config)
asyncio.ensure_future(
exit_with_services(
discovery_bootstrap,
self._event_bus_service,
))
asyncio.ensure_future(discovery_bootstrap.run())
def run_service(ready_to_kill_event):
loop = asyncio.get_event_loop()
service = SimpleService(ready_to_kill_event, loop=loop)
asyncio.ensure_future(service.run())
asyncio.ensure_future(exit_with_services(service))
loop.run_forever()
loop.close()
assert service.is_cancelled
def do_start(self) -> None:
try:
tracker_services = self._get_services()
except BadDatabaseError as err:
self.logger.exception(f"Unrecoverable error in Network Component: {err}")
else:
asyncio.ensure_future(exit_with_services(
self._event_bus_service,
*tracker_services,
))
for service in tracker_services:
asyncio.ensure_future(service.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
NodeClass = trinity_config.get_app_config(Eth1AppConfig).node_class
node = NodeClass(self.event_bus, trinity_config)
asyncio.ensure_future(self.launch_sync(node))
asyncio.ensure_future(
exit_with_services(
node,
self._event_bus_service,
))
asyncio.ensure_future(node.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
base_db = DBClient.connect(trinity_config.database_ipc_path)
if trinity_config.has_app_config(Eth1AppConfig):
server = self.make_eth1_request_server(
trinity_config.get_app_config(Eth1AppConfig),
base_db,
)
else:
raise Exception("Trinity config must have eth1 config")
asyncio.ensure_future(exit_with_services(server, self._event_bus_service))
asyncio.ensure_future(server.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
app_config = trinity_config.get_app_config(Eth1AppConfig)
chain_config = app_config.get_chain_config()
self._beam_chain = make_pausing_beam_chain(
chain_config.vm_configuration,
chain_config.chain_id,
DBClient.connect(trinity_config.database_ipc_path),
self.event_bus,
self._loop,
)
import_server = BlockImportServer(self.event_bus, self._beam_chain)
asyncio.ensure_future(exit_with_services(import_server, self._event_bus_service))
asyncio.ensure_future(import_server.run())
def do_start(self) -> None:
service = EthstatsService(
self.boot_info,
self.event_bus,
self.server_url,
self.server_secret,
self.node_id,
self.node_contact,
self.stats_interval,
)
asyncio.ensure_future(
exit_with_services(
service,
self._event_bus_service,
))
asyncio.ensure_future(service.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
app_config = trinity_config.get_app_config(Eth1AppConfig)
chain_config = app_config.get_chain_config()
db_manager = create_db_consumer_manager(trinity_config.database_ipc_path)
self._beam_chain = make_pausing_beam_chain(
chain_config.vm_configuration,
chain_config.chain_id,
db_manager.get_db(), # type: ignore
self.event_bus,
self._loop,
)
import_server = BlockImportServer(self.event_bus, self._beam_chain)
asyncio.ensure_future(exit_with_services(import_server, self._event_bus_service))
asyncio.ensure_future(import_server.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
app_config = trinity_config.get_app_config(Eth1AppConfig)
chain_config = app_config.get_chain_config()
base_db = DBClient.connect(trinity_config.database_ipc_path)
self._beam_chain = make_pausing_beam_chain(
chain_config.vm_configuration,
chain_config.chain_id,
base_db,
self.event_bus,
self._loop,
# these preview executions are lower priority than the primary block import
urgent=False,
)
import_server = BlockPreviewServer(self.event_bus, self._beam_chain, self.shard_num)
asyncio.ensure_future(exit_with_services(import_server, self._event_bus_service))
asyncio.ensure_future(import_server.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
if trinity_config.has_app_config(Eth1AppConfig):
modules = self.setup_eth1_modules(trinity_config)
elif trinity_config.has_app_config(BeaconAppConfig):
modules = self.setup_beacon_modules()
else:
raise Exception("Unsupported Node Type")
rpc = RPCServer(modules, self.event_bus)
ipc_server = IPCServer(rpc,
self.boot_info.trinity_config.jsonrpc_ipc_path)
asyncio.ensure_future(
exit_with_services(
ipc_server,
self._event_bus_service,
))
asyncio.ensure_future(ipc_server.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
key_pair = self._load_or_create_node_key()
beacon_app_config = trinity_config.get_app_config(BeaconAppConfig)
base_db = DBClient.connect(trinity_config.database_ipc_path)
chain_config = beacon_app_config.get_chain_config()
attestation_pool = AttestationPool()
chain = chain_config.beacon_chain_class(
base_db,
attestation_pool,
chain_config.genesis_config
)
# TODO: Handle `bootstrap_nodes`.
libp2p_node = Node(
key_pair=key_pair,
listen_ip="127.0.0.1", # FIXME: Should be configurable
listen_port=self.boot_info.args.port,
preferred_nodes=trinity_config.preferred_nodes,
chain=chain,
)
receive_server = BCCReceiveServer(
chain=chain,
p2p_node=libp2p_node,
topic_msg_queues=libp2p_node.pubsub.my_topics,
cancel_token=libp2p_node.cancel_token,
)
state = chain.get_state_by_slot(chain_config.genesis_config.GENESIS_SLOT)
registry_pubkeys = [v_record.pubkey for v_record in state.validators]
validator_privkeys = {}
validator_keymap = chain_config.genesis_data.validator_keymap
for pubkey in validator_keymap:
try:
validator_index = cast(ValidatorIndex, registry_pubkeys.index(pubkey))
except ValueError:
self.logger.error(f'Could not find pubkey {pubkey.hex()} in genesis state')
raise
validator_privkeys[validator_index] = validator_keymap[pubkey]
validator = Validator(
chain=chain,
p2p_node=libp2p_node,
validator_privkeys=validator_privkeys,
event_bus=self.event_bus,
token=libp2p_node.cancel_token,
get_ready_attestations_fn=receive_server.get_ready_attestations,
)
slot_ticker = SlotTicker(
genesis_slot=chain_config.genesis_config.GENESIS_SLOT,
genesis_time=chain_config.genesis_data.genesis_time,
seconds_per_slot=chain_config.genesis_config.SECONDS_PER_SLOT,
event_bus=self.event_bus,
token=libp2p_node.cancel_token,
)
syncer = BeaconChainSyncer(
chain_db=AsyncBeaconChainDB(
base_db,
chain_config.genesis_config,
),
peer_pool=libp2p_node.handshaked_peers,
block_importer=SyncBlockImporter(chain),
genesis_config=chain_config.genesis_config,
token=libp2p_node.cancel_token,
)
asyncio.ensure_future(exit_with_services(
self._event_bus_service,
libp2p_node,
receive_server,
slot_ticker,
validator,
syncer,
))
asyncio.ensure_future(libp2p_node.run())
asyncio.ensure_future(receive_server.run())
asyncio.ensure_future(slot_ticker.run())
asyncio.ensure_future(validator.run())
asyncio.ensure_future(syncer.run())
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
beacon_app_config = trinity_config.get_app_config(BeaconAppConfig)
db_manager = create_db_consumer_manager(
trinity_config.database_ipc_path)
base_db = db_manager.get_db() # type: ignore
chain_config = beacon_app_config.get_chain_config()
attestation_pool = AttestationPool()
chain = chain_config.beacon_chain_class(base_db, attestation_pool,
chain_config.genesis_config)
if self.boot_info.args.beacon_nodekey:
privkey = PrivateKey(
bytes.fromhex(self.boot_info.args.beacon_nodekey))
else:
privkey = ecies.generate_privkey()
# TODO: Handle `bootstrap_nodes`.
libp2p_node = Node(
privkey=privkey,
listen_ip="127.0.0.1", # FIXME: Should be configurable
listen_port=self.boot_info.args.port,
security_protocol_ops={
SECURITY_PROTOCOL_ID: InsecureTransport("plaintext")
},
muxer_protocol_ids=(MULTIPLEXING_PROTOCOL_ID, ),
preferred_nodes=trinity_config.preferred_nodes,
)
state = chain.get_state_by_slot(
chain_config.genesis_config.GENESIS_SLOT)
registry_pubkeys = [v_record.pubkey for v_record in state.validators]
validator_privkeys = {}
validator_keymap = chain_config.genesis_data.validator_keymap
for pubkey in validator_keymap:
validator_index = cast(ValidatorIndex,
registry_pubkeys.index(pubkey))
validator_privkeys[validator_index] = validator_keymap[pubkey]
def fake_get_ready_attestations_fn() -> Tuple[Attestation, ...]:
return tuple()
validator = Validator(
chain=chain,
p2p_node=libp2p_node,
validator_privkeys=validator_privkeys,
event_bus=self.event_bus,
token=libp2p_node.cancel_token,
get_ready_attestations_fn=
fake_get_ready_attestations_fn, # FIXME: BCCReceiveServer.get_ready_attestations # noqa: E501
)
slot_ticker = SlotTicker(
genesis_slot=chain_config.genesis_config.GENESIS_SLOT,
genesis_time=chain_config.genesis_data.genesis_time,
seconds_per_slot=chain_config.genesis_config.SECONDS_PER_SLOT,
event_bus=self.event_bus,
token=libp2p_node.cancel_token,
)
asyncio.ensure_future(
exit_with_services(
self._event_bus_service,
libp2p_node,
slot_ticker,
validator,
))
asyncio.ensure_future(libp2p_node.run())
asyncio.ensure_future(slot_ticker.run())
asyncio.ensure_future(validator.run())
def main_entry(trinity_boot: BootFn, app_identifier: str,
components: Tuple[Type[BaseComponent], ...],
sub_configs: Sequence[Type[BaseAppConfig]]) -> None:
for component_type in components:
component_type.configure_parser(parser, subparser)
argcomplete.autocomplete(parser)
args = parser.parse_args()
if not args.genesis and args.network_id not in PRECONFIGURED_NETWORKS:
raise NotImplementedError(
f"Unsupported network id: {args.network_id}. To use a network besides "
"mainnet or ropsten, you must supply a genesis file with a flag, like "
"`--genesis path/to/genesis.json`, also you must specify a data "
"directory with `--data-dir path/to/data/directory`")
# The `common_log_level` is derived from `--log-level <Level>` / `-l <Level>` without
# specifying any module. If present, it is used for both `stderr` and `file` logging.
common_log_level = args.log_levels and args.log_levels.get(None)
has_ambigous_logging_config = (
(common_log_level is not None and args.stderr_log_level is not None)
or (common_log_level is not None and args.file_log_level is not None))
if has_ambigous_logging_config:
parser.error(f"""\n
Ambiguous logging configuration: The `--log-level (-l)` flag sets the
log level for both file and stderr logging.
To configure different log level for file and stderr logging,
remove the `--log-level` flag and use `--stderr-log-level` and/or
`--file-log-level` separately.
Alternatively, remove the `--stderr-log-level` and/or `--file-log-level`
flags to share one single log level across both handlers.
""")
if is_prerelease():
# this modifies the asyncio logger, but will be overridden by any custom settings below
enable_warnings_by_default()
stderr_logger, handler_stream = setup_trinity_stderr_logging(
args.stderr_log_level or common_log_level)
if args.log_levels:
setup_log_levels(args.log_levels)
try:
trinity_config = TrinityConfig.from_parser_args(
args, app_identifier, sub_configs)
except AmbigiousFileSystem:
parser.error(TRINITY_AMBIGIOUS_FILESYSTEM_INFO)
if not is_data_dir_initialized(trinity_config):
# TODO: this will only work as is for chains with known genesis
# parameters. Need to flesh out how genesis parameters for custom
# chains are defined and passed around.
try:
initialize_data_dir(trinity_config)
except AmbigiousFileSystem:
parser.error(TRINITY_AMBIGIOUS_FILESYSTEM_INFO)
except MissingPath as e:
parser.error(
"\n"
f"It appears that {e.path} does not exist. "
"Trinity does not attempt to create directories outside of its root path. "
"Either manually create the path or ensure you are using a data directory "
"inside the XDG_TRINITY_ROOT path")
file_logger, log_queue, listener = setup_trinity_file_and_queue_logging(
stderr_logger,
handler_stream,
trinity_config.logfile_path,
args.file_log_level or common_log_level,
)
display_launch_logs(trinity_config)
# compute the minimum configured log level across all configured loggers.
min_configured_log_level = min(stderr_logger.level, file_logger.level,
*(args.log_levels or {}).values())
extra_kwargs = {
'log_queue': log_queue,
'log_level': min_configured_log_level,
'log_levels': args.log_levels if args.log_levels else {},
'profile': args.profile,
}
# Components can provide a subcommand with a `func` which does then control
# the entire process from here.
if hasattr(args, 'func'):
args.func(args, trinity_config)
return
if hasattr(args, 'munge_func'):
args.munge_func(args, trinity_config)
processes = trinity_boot(
args,
trinity_config,
extra_kwargs,
listener,
stderr_logger,
)
def kill_trinity_with_reason(reason: str) -> None:
kill_trinity_gracefully(trinity_config,
stderr_logger,
processes,
component_manager_service,
reason=reason)
boot_info = TrinityBootInfo(args, trinity_config, extra_kwargs)
component_manager_service = ComponentManagerService(
boot_info, components, kill_trinity_with_reason)
try:
loop = asyncio.get_event_loop()
asyncio.ensure_future(exit_with_services(component_manager_service))
asyncio.ensure_future(component_manager_service.run())
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")
finally:
if trinity_config.trinity_tmp_root_dir:
import shutil
shutil.rmtree(trinity_config.trinity_root_dir)
def do_start(self) -> None:
trinity_config = self.boot_info.trinity_config
beacon_app_config = trinity_config.get_app_config(BeaconAppConfig)
base_db = DBClient.connect(trinity_config.database_ipc_path)
chain_config = beacon_app_config.get_chain_config()
attestation_pool = AttestationPool()
chain = chain_config.beacon_chain_class(base_db, attestation_pool,
chain_config.genesis_config)
key_pair: KeyPair
if self.boot_info.args.beacon_nodekey:
privkey = Secp256k1PrivateKey(
bytes.fromhex(self.boot_info.args.beacon_nodekey))
key_pair = KeyPair(private_key=privkey,
public_key=privkey.get_public_key())
else:
key_pair = create_new_key_pair()
# TODO: Handle `bootstrap_nodes`.
libp2p_node = Node(
key_pair=key_pair,
listen_ip="127.0.0.1", # FIXME: Should be configurable
listen_port=self.boot_info.args.port,
preferred_nodes=trinity_config.preferred_nodes,
chain=chain,
)
state = chain.get_state_by_slot(
chain_config.genesis_config.GENESIS_SLOT)
registry_pubkeys = [v_record.pubkey for v_record in state.validators]
validator_privkeys = {}
validator_keymap = chain_config.genesis_data.validator_keymap
for pubkey in validator_keymap:
validator_index = cast(ValidatorIndex,
registry_pubkeys.index(pubkey))
validator_privkeys[validator_index] = validator_keymap[pubkey]
def fake_get_ready_attestations_fn() -> Tuple[Attestation, ...]:
return tuple()
validator = Validator(
chain=chain,
p2p_node=libp2p_node,
validator_privkeys=validator_privkeys,
event_bus=self.event_bus,
token=libp2p_node.cancel_token,
get_ready_attestations_fn=
fake_get_ready_attestations_fn, # FIXME: BCCReceiveServer.get_ready_attestations # noqa: E501
)
slot_ticker = SlotTicker(
genesis_slot=chain_config.genesis_config.GENESIS_SLOT,
genesis_time=chain_config.genesis_data.genesis_time,
seconds_per_slot=chain_config.genesis_config.SECONDS_PER_SLOT,
event_bus=self.event_bus,
token=libp2p_node.cancel_token,
)
asyncio.ensure_future(
exit_with_services(
self._event_bus_service,
libp2p_node,
slot_ticker,
validator,
))
asyncio.ensure_future(libp2p_node.run())
asyncio.ensure_future(slot_ticker.run())
asyncio.ensure_future(validator.run())
def do_start(self) -> None:
service = PeerCountReporter(self.event_bus)
asyncio.ensure_future(exit_with_services(service, self._event_bus_service))
asyncio.ensure_future(service.run())
