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_endpoint_and_services(self.event_bus, server))
asyncio.ensure_future(server.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_endpoint_and_services(self.event_bus,
discovery_bootstrap))
asyncio.ensure_future(discovery_bootstrap.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_endpoint_and_services(self.event_bus, node))
asyncio.ensure_future(node.run())
def do_start(self) -> None:
try:
tracker_services = self._get_services()
except BadDatabaseError as err:
self.logger.exception(
f"Unrecoverable error in Network Plugin: {err}")
else:
asyncio.ensure_future(
exit_with_endpoint_and_services(self.event_bus,
*tracker_services))
for service in tracker_services:
asyncio.ensure_future(service.run())
def do_start(self) -> None:
if self.boot_info.args.disable_blacklistdb:
# Allow this plugin to be disabled for extreme cases such as the
# user swapping in an equivalent experimental version.
self.logger.warning("Blacklist Database disabled via CLI flag")
return
else:
service = self._get_blacklist_service()
asyncio.ensure_future(
exit_with_endpoint_and_services(self.event_bus, service))
asyncio.ensure_future(service.run())
def run_service(ready_to_kill_event):
loop = asyncio.get_event_loop()
endpoint = TrinityEventBusEndpoint()
service = SimpleService(ready_to_kill_event, loop=loop)
asyncio.ensure_future(exit_with_endpoint_and_services(endpoint, service))
asyncio.ensure_future(service.run())
loop.run_forever()
loop.close()
assert service.is_cancelled
assert endpoint._running is False
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_endpoint_and_services(self.event_bus, service))
asyncio.ensure_future(service.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_endpoint_and_services(self.event_bus, ipc_server))
asyncio.ensure_future(ipc_server.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_db = db_manager.get_chaindb() # type: ignore
chain_config = beacon_app_config.get_chain_config()
chain = chain_config.beacon_chain_class(base_db,
chain_config.eth2_config)
if self.boot_info.args.beacon_nodekey:
privkey = PrivateKey(
bytes.fromhex(self.boot_info.args.beacon_nodekey))
else:
privkey = ecies.generate_privkey()
server = BCCServer(
privkey=privkey,
port=self.boot_info.args.port,
chain=chain,
chaindb=chain_db,
headerdb=None,
base_db=base_db,
network_id=trinity_config.network_id,
max_peers=DEFAULT_MAX_PEERS,
bootstrap_nodes=None,
preferred_nodes=None,
event_bus=self.event_bus,
token=None,
)
syncer = BeaconChainSyncer(
chain_db,
server.peer_pool,
SyncBlockImporter(chain),
server.cancel_token,
)
state_machine = chain.get_state_machine()
state = state_machine.state
registry_pubkeys = [
v_record.pubkey for v_record in state.validator_registry
]
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]
validator = Validator(
chain=chain,
peer_pool=server.peer_pool,
validator_privkeys=validator_privkeys,
event_bus=self.event_bus,
token=server.cancel_token,
genesis_epoch=state_machine.config.GENESIS_EPOCH,
slots_per_epoch=state_machine.config.SLOTS_PER_EPOCH,
)
slot_ticker = SlotTicker(
genesis_slot=state_machine.config.GENESIS_SLOT,
genesis_time=chain_config.genesis_data.genesis_time,
seconds_per_slot=state_machine.config.SECONDS_PER_SLOT,
event_bus=self.event_bus,
token=server.cancel_token,
)
asyncio.ensure_future(
exit_with_endpoint_and_services(self.event_bus, server))
asyncio.ensure_future(server.run())
asyncio.ensure_future(syncer.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_endpoint_and_services(self.event_bus, service))
asyncio.ensure_future(service.run())
def do_start(self) -> None:
port = self.boot_info.trinity_config.port
self.upnp_service = UPnPService(port)
asyncio.ensure_future(exit_with_endpoint_and_services(self.event_bus, self.upnp_service))
asyncio.ensure_future(self.upnp_service.run())
