async def do_run(self, event_bus: EndpointAPI) -> None:
boot_info = self._boot_info
trinity_config = boot_info.trinity_config
with chain_for_config(trinity_config, event_bus) as chain:
if trinity_config.has_app_config(Eth1AppConfig):
modules = initialize_eth1_modules(chain, event_bus,
trinity_config)
elif trinity_config.has_app_config(BeaconAppConfig):
modules = initialize_beacon_modules(chain, event_bus)
else:
raise Exception("Unsupported Node Type")
rpc = RPCServer(modules, chain, event_bus)
# Run IPC Server
ipc_server = IPCServer(rpc,
boot_info.trinity_config.jsonrpc_ipc_path)
services_to_exit: Tuple[Service, ...] = (ipc_server, )
# Run HTTP Server
if boot_info.args.enable_http:
http_server = HTTPServer(
handler=RPCHandler.handle(rpc.execute),
port=boot_info.args.rpcport,
)
services_to_exit += (http_server, )
async with contextlib.AsyncExitStack() as stack:
managers = tuple([
await stack.enter_async_context(
background_asyncio_service(service))
for service in services_to_exit
])
await managers[0].wait_finished()
async def do_run(self, event_bus: EndpointAPI) -> None:
boot_info = self._boot_info
trinity_config = boot_info.trinity_config
with chain_for_config(trinity_config, event_bus) as chain:
if trinity_config.has_app_config(Eth1AppConfig):
modules = initialize_eth1_modules(chain, event_bus,
trinity_config)
elif trinity_config.has_app_config(BeaconAppConfig):
modules = initialize_beacon_modules(chain, event_bus)
else:
raise Exception("Unsupported Node Type")
rpc = RPCServer(modules, chain, event_bus)
# Run IPC Server
ipc_server = IPCServer(rpc,
boot_info.trinity_config.jsonrpc_ipc_path)
services_to_exit: Tuple[Service, ...] = (ipc_server, )
# Run HTTP Server
if boot_info.args.enable_http:
http_server = HTTPServer(
host=boot_info.args.http_listen_address,
handler=RPCHandler.handle(rpc.execute),
port=boot_info.args.http_port,
)
services_to_exit += (http_server, )
await run_background_asyncio_services(services_to_exit)
async def do_run(self, event_bus: EndpointAPI) -> None:
boot_info = self._boot_info
trinity_config = boot_info.trinity_config
with chain_for_config(trinity_config, event_bus) as chain:
if trinity_config.has_app_config(Eth1AppConfig):
modules = initialize_eth1_modules(chain, event_bus,
trinity_config)
else:
raise Exception("Unsupported Node Type")
rpc = RPCServer(modules, chain, event_bus)
# Run IPC Server
ipc_server = IPCServer(rpc,
boot_info.trinity_config.jsonrpc_ipc_path)
services_to_exit: Tuple[Service, ...] = (ipc_server, )
try:
http_modules = get_http_enabled_modules(
boot_info.args.enable_http_apis, modules)
except ValidationError as error:
self.logger.error(error)
return
# Run HTTP Server if there are http enabled APIs
if len(http_modules) > 0:
enabled_module_names = tuple(mod.get_name()
for mod in http_modules)
self.logger.info("JSON-RPC modules exposed via HTTP: %s",
enabled_module_names)
non_http_modules = set(type(mod)
for mod in modules) - set(http_modules)
exec = rpc.execute_with_access_control(non_http_modules)
http_server = HTTPServer(
host=boot_info.args.http_listen_address,
handler=RPCHandler.handle(exec),
port=boot_info.args.http_port,
)
services_to_exit += (http_server, )
await run_background_asyncio_services(services_to_exit)
async def do_run(cls, boot_info: BootInfo, event_bus: EndpointAPI) -> None:
trinity_config = boot_info.trinity_config
key_pair = cls._load_or_create_node_key(boot_info)
beacon_app_config = trinity_config.get_app_config(BeaconAppConfig)
base_db = DBClient.connect(trinity_config.database_ipc_path)
if boot_info.args.debug_libp2p:
logging.getLogger("libp2p").setLevel(logging.DEBUG)
else:
logging.getLogger("libp2p").setLevel(logging.INFO)
with base_db:
chain_config = beacon_app_config.get_chain_config()
chain = chain_config.beacon_chain_class(
base_db, chain_config.genesis_config)
# TODO: To simplify, subsribe all subnets
subnets: Set[SubnetId] = set(
SubnetId(subnet_id)
for subnet_id in range(ATTESTATION_SUBNET_COUNT))
# TODO: Handle `bootstrap_nodes`.
libp2p_node = Node(
key_pair=key_pair,
listen_ip="0.0.0.0",
listen_port=boot_info.args.port,
preferred_nodes=trinity_config.preferred_nodes,
chain=chain,
subnets=subnets,
event_bus=event_bus,
)
receive_server = BCCReceiveServer(
chain=chain,
p2p_node=libp2p_node,
topic_msg_queues=libp2p_node.pubsub.my_topics,
subnets=subnets,
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:
cls.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=event_bus,
token=libp2p_node.cancel_token,
get_ready_attestations_fn=receive_server.
get_ready_attestations,
get_aggregatable_attestations_fn=receive_server.
get_aggregatable_attestations,
import_attestation_fn=receive_server.import_attestation,
)
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=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,
event_bus=event_bus,
token=libp2p_node.cancel_token,
)
metrics_server = HTTPServer(
handler=MetricsHandler.handle(chain)(event_bus),
port=boot_info.args.metrics_port,
)
api_server = HTTPServer(
handler=APIHandler.handle(chain)(event_bus),
port=boot_info.args.api_port,
)
services: Tuple[BaseService,
...] = (libp2p_node, receive_server, slot_ticker,
validator, syncer)
if boot_info.args.enable_metrics:
services += (metrics_server, )
if boot_info.args.enable_api:
services += (api_server, )
async with AsyncExitStack() as stack:
for service in services:
await stack.enter_async_context(run_service(service))
await asyncio.gather(*(service.cancellation()
for service in services))
async def do_run(cls, boot_info: BootInfo, event_bus: EndpointAPI) -> None:
trinity_config = boot_info.trinity_config
key_pair = _load_secp256k1_key_pair_from(trinity_config)
beacon_app_config = trinity_config.get_app_config(BeaconAppConfig)
base_db = DBClient.connect(trinity_config.database_ipc_path)
if boot_info.args.debug_libp2p:
logging.getLogger("libp2p").setLevel(logging.DEBUG)
else:
logging.getLogger("libp2p").setLevel(logging.INFO)
with base_db:
chain_config = beacon_app_config.get_chain_config()
chain = chain_config.beacon_chain_class(
base_db, chain_config.genesis_config)
# TODO: To simplify, subsribe all subnets
subnets: Set[SubnetId] = set(
SubnetId(subnet_id)
for subnet_id in range(ATTESTATION_SUBNET_COUNT))
# TODO: Handle `bootstrap_nodes`.
libp2p_node = Node(
key_pair=key_pair,
listen_ip="0.0.0.0",
listen_port=boot_info.args.port,
preferred_nodes=trinity_config.preferred_nodes,
chain=chain,
subnets=subnets,
event_bus=event_bus,
)
receive_server = BCCReceiveServer(
chain=chain,
p2p_node=libp2p_node,
topic_msg_queues=libp2p_node.pubsub.my_topics,
subnets=subnets,
cancel_token=libp2p_node.cancel_token,
)
chain_maintainer = ChainMaintainer(chain=chain,
event_bus=event_bus,
token=libp2p_node.cancel_token)
validator_handler = ValidatorHandler(
chain=chain,
p2p_node=libp2p_node,
event_bus=event_bus,
get_ready_attestations_fn=receive_server.
get_ready_attestations,
get_aggregatable_attestations_fn=receive_server.
get_aggregatable_attestations,
import_attestation_fn=receive_server.import_attestation,
token=libp2p_node.cancel_token,
)
slot_ticker = SlotTicker(
genesis_slot=chain_config.genesis_config.GENESIS_SLOT,
genesis_time=chain_config.genesis_time,
seconds_per_slot=chain_config.genesis_config.SECONDS_PER_SLOT,
event_bus=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,
event_bus=event_bus,
token=libp2p_node.cancel_token,
)
metrics_server = HTTPServer(
handler=MetricsHandler.handle(chain)(event_bus),
port=boot_info.args.metrics_port,
)
# NOTE: this API server provides an interface into the beacon node
api_server = HTTPServer(
handler=APIHandler.handle(chain)(event_bus),
port=boot_info.args.api_port,
)
# NOTE: this API server provides an interface between the beacon node and
# any connected validator clients.
validator_api_handler = ValidatorAPIHandler(
chain, event_bus, chain_config.genesis_time)
validator_api_server = HTTPAppServer(
routes=validator_api_handler.make_routes(), port=30303)
services: Tuple[BaseService, ...] = (
libp2p_node,
receive_server,
slot_ticker,
syncer,
validator_api_server,
)
if boot_info.args.enable_metrics:
services += (metrics_server, )
if boot_info.args.enable_api:
services += (api_server, )
if boot_info.args.bn_only:
services += (chain_maintainer, validator_handler)
async with AsyncExitStack() as stack:
for service in services:
await stack.enter_async_context(run_service(service))
await asyncio.gather(*(service.cancellation()
for service in services))