def display_launch_logs(trinity_config: TrinityConfig) -> None:
logger = logging.getLogger('trinity')
logger.info(TRINITY_HEADER)
logger.info("Started main process (pid=%d)", os.getpid())
logger.info(construct_trinity_client_identifier())
logger.info("Trinity DEBUG log file is created at %s",
str(trinity_config.logfile_path))
def run_fullnode_process(chain_config: ChainConfig, port: int) -> None:
logger = logging.getLogger('trinity')
logger.info(TRINITY_HEADER)
logger.info(construct_trinity_client_identifier())
manager = create_dbmanager(chain_config.database_ipc_path)
db = manager.get_db() # type: ignore
headerdb = manager.get_headerdb() # type: ignore
chaindb = manager.get_chaindb() # type: ignore
chain = manager.get_chain() # type: ignore
peer_pool_class = HardCodedNodesPeerPool
server = Server(
chain_config.nodekey, port, chain, chaindb, headerdb, db, chain_config.network_id,
peer_pool_class=peer_pool_class)
loop = asyncio.get_event_loop()
# Use a ProcessPoolExecutor as the default so that we can offload cpu-intensive tasks from the
# main thread.
loop.set_default_executor(ProcessPoolExecutor())
sigint_received = asyncio.Event()
for sig in [signal.SIGINT, signal.SIGTERM]:
loop.add_signal_handler(sig, sigint_received.set)
async def exit_on_sigint():
await sigint_received.wait()
await server.cancel()
loop.stop()
asyncio.ensure_future(exit_on_sigint())
asyncio.ensure_future(server.run())
loop.run_forever()
loop.close()
def send_handshake(self) -> None:
# TODO: move import out once this is in the trinity codebase
from trinity.utils.version import construct_trinity_client_identifier
data = dict(version=self.version,
client_version_string=construct_trinity_client_identifier(),
capabilities=self.peer.capabilities,
listen_port=self.peer.listen_port,
remote_pubkey=self.peer.privkey.public_key.to_bytes())
header, body = Hello(self.cmd_id_offset).encode(data)
self.send(header, body)
def get_node_info(self) -> EthstatsData:
return {
'name': self.node_id,
'contact': self.node_contact,
'node': construct_trinity_client_identifier(),
'net': self.context.chain_config.network_id,
'port': self.context.chain_config.port,
'os': platform.system(),
'os_v': platform.release(),
'client': __version__,
'canUpdateHistory': False,
}
def get_node_info(self) -> EthstatsData:
'''Getter for data that should be sent once, on start-up.'''
return {
'name': self.node_id,
'contact': self.node_contact,
'node': construct_trinity_client_identifier(),
'net': self.context.trinity_config.network_id,
'port': self.context.trinity_config.port,
'os': platform.system(),
'os_v': platform.release(),
'client': __version__,
'canUpdateHistory': False,
}
def run_lightnode_process(chain_config: ChainConfig) -> None:
logger = logging.getLogger('trinity')
logger.info(TRINITY_HEADER)
logger.info(construct_trinity_client_identifier())
logger.info(
"enode://%s@%s:%s",
chain_config.nodekey.to_hex()[2:],
"[:]",
chain_config.port,
)
logger.info('network: %s', chain_config.network_id)
manager = create_dbmanager(chain_config.database_ipc_path)
headerdb = manager.get_headerdb() # type: ignore
if chain_config.network_id == MAINNET_NETWORK_ID:
chain_class = MainnetLightPeerChain # type: ignore
elif chain_config.network_id == ROPSTEN_NETWORK_ID:
chain_class = RopstenLightPeerChain # type: ignore
else:
raise NotImplementedError(
"Only the mainnet and ropsten chains are currently supported"
)
discovery = None
peer_pool = HardCodedNodesPeerPool(
LESPeer, headerdb, chain_config.network_id, chain_config.nodekey, discovery)
chain = chain_class(headerdb, peer_pool)
loop = asyncio.get_event_loop()
for sig in [signal.SIGINT, signal.SIGTERM]:
loop.add_signal_handler(sig, chain.cancel_token.trigger)
rpc = RPCServer(chain)
ipc_server = IPCServer(rpc, chain_config.jsonrpc_ipc_path)
async def run_chain(chain):
try:
asyncio.ensure_future(chain.peer_pool.run())
asyncio.ensure_future(ipc_server.run())
await chain.run()
finally:
await ipc_server.stop()
await chain.peer_pool.cancel()
await chain.stop()
loop.run_until_complete(run_chain(chain))
loop.close()
def clientVersion(self):
"""
Returns the current client version.
"""
return construct_trinity_client_identifier()
'id': 3,
'jsonrpc': '2.0'
},
),
(
build_request('eth_mining'),
{
'result': False,
'id': 3,
'jsonrpc': '2.0'
},
),
(
build_request('web3_clientVersion'),
{
'result': construct_trinity_client_identifier(),
'id': 3,
'jsonrpc': '2.0'
},
),
(
build_request('web3_sha3', ['0x89987239849872']),
{
'result':
'0xb3406131994d9c859de3c4400e12f630638e1e992c6453358c16d0e6ce2b1a70',
'id': 3,
'jsonrpc': '2.0',
},
),
(
build_request('web3_sha3', ['0x']),
def display_launch_logs(chain_config: ChainConfig) -> None:
logger = logging.getLogger('trinity')
logger.info(TRINITY_HEADER)
logger.info(construct_trinity_client_identifier())
logger.info("Trinity DEBUG log file is created at %s",
str(chain_config.logfile_path))
def display_launch_logs(chain_config: ChainConfig) -> None:
logger = logging.getLogger('trinity')
logger.info(TRINITY_HEADER)
logger.info(construct_trinity_client_identifier())
def test_construct_trinity_client_identifier():
assert construct_trinity_client_identifier().startswith('Trinity/')
),
(
build_request('notamethod'),
{'error': "Invalid RPC method: 'notamethod'", 'id': 3, 'jsonrpc': '2.0'},
),
(
build_request('eth_accounts'),
{'result': [], 'id': 3, 'jsonrpc': '2.0'},
),
(
build_request('eth_mining'),
{'result': False, 'id': 3, 'jsonrpc': '2.0'},
),
(
build_request('web3_clientVersion'),
{'result': construct_trinity_client_identifier(), 'id': 3, 'jsonrpc': '2.0'},
),
(
build_request('web3_sha3', ['0x89987239849872']),
{
'result': '0xb3406131994d9c859de3c4400e12f630638e1e992c6453358c16d0e6ce2b1a70',
'id': 3,
'jsonrpc': '2.0',
},
),
(
build_request('web3_sha3', ['0x']),
{
'result': '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470',
'id': 3,
'jsonrpc': '2.0',
