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())