def _test() -> None: import argparse import asyncio import signal from eth.chains.ropsten import RopstenChain, ROPSTEN_VM_CONFIGURATION from eth.db.backends.level import LevelDB from p2p import ecies from p2p.kademlia import Node from trinity.protocol.common.constants import DEFAULT_PREFERRED_NODES from trinity.protocol.common.context import ChainContext from tests.trinity.core.integration_test_helpers import ( FakeAsyncChainDB, FakeAsyncRopstenChain, connect_to_peers_loop) logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-enode', type=str, required=False, help="The enode we should connect to") args = parser.parse_args() chaindb = FakeAsyncChainDB(LevelDB(args.db)) chain = FakeAsyncRopstenChain(chaindb) network_id = RopstenChain.network_id privkey = ecies.generate_privkey() context = ChainContext(headerdb=chaindb, network_id=network_id, vm_configuration=ROPSTEN_VM_CONFIGURATION) peer_pool = ETHPeerPool(privkey=privkey, context=context) if args.enode: nodes = tuple([Node.from_uri(args.enode)]) else: nodes = DEFAULT_PREFERRED_NODES[network_id] asyncio.ensure_future(peer_pool.run()) peer_pool.run_task(connect_to_peers_loop(peer_pool, nodes)) loop = asyncio.get_event_loop() syncer = FullNodeSyncer(chain, chaindb, chaindb.db, peer_pool) sigint_received = asyncio.Event() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, sigint_received.set) async def exit_on_sigint() -> None: await sigint_received.wait() await syncer.cancel() await peer_pool.cancel() loop.stop() loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(syncer.run()) loop.run_forever() loop.close()
def _make_peer_pool(self) -> ETHPeerPool: context = ChainContext( headerdb=self.headerdb, network_id=self.network_id, vm_configuration=self.chain.vm_configuration, ) return ETHPeerPool(privkey=self.privkey, max_peers=self.max_peers, context=context, token=self.cancel_token, event_bus=self.event_bus)
def _make_peer_pool(self) -> ETHPeerPool: context = ChainContext( headerdb=self.headerdb, network_id=self.network_id, vm_configuration=self.chain.vm_configuration, client_version_string=construct_trinity_client_identifier(), listen_port=self.port, ) return ETHPeerPool(privkey=self.privkey, max_peers=self.max_peers, context=context, token=self.cancel_token, event_bus=self.event_bus)
def _make_peer_pool(self) -> ETHPeerPool: context = ChainContext( headerdb=self.headerdb, network_id=self.network_id, vm_configuration=self.chain.vm_configuration, client_version_string=self.p2p_handshake_params. client_version_string, listen_port=self.p2p_handshake_params.listen_port, p2p_version=self.p2p_handshake_params.version, ) return ETHPeerPool(privkey=self.privkey, max_peers=self.max_peers, context=context, token=self.cancel_token, event_bus=self.event_bus)
def _test() -> None: import argparse import signal from eth.chains.ropsten import RopstenChain, ROPSTEN_VM_CONFIGURATION from p2p import ecies from p2p.kademlia import Node from trinity.protocol.common.constants import DEFAULT_PREFERRED_NODES from trinity.protocol.common.context import ChainContext from tests.trinity.core.integration_test_helpers import ( FakeAsyncChainDB, FakeAsyncLevelDB, connect_to_peers_loop) logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-debug', action="store_true") parser.add_argument('-enode', type=str, required=False, help="The enode we should connect to") args = parser.parse_args() log_level = logging.INFO if args.debug: log_level = logging.DEBUG db = FakeAsyncLevelDB(args.db) chaindb = FakeAsyncChainDB(db) network_id = RopstenChain.network_id if args.enode: nodes = tuple([Node.from_uri(args.enode)]) else: nodes = DEFAULT_PREFERRED_NODES[network_id] context = ChainContext( headerdb=chaindb, network_id=network_id, vm_configuration=ROPSTEN_VM_CONFIGURATION, ) peer_pool = ETHPeerPool( privkey=ecies.generate_privkey(), context=context, ) asyncio.ensure_future(peer_pool.run()) peer_pool.run_task(connect_to_peers_loop(peer_pool, nodes)) head = chaindb.get_canonical_head() downloader = StateDownloader(chaindb, db, head.state_root, peer_pool) downloader.logger.setLevel(log_level) loop = asyncio.get_event_loop() sigint_received = asyncio.Event() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, sigint_received.set) async def exit_on_sigint() -> None: await sigint_received.wait() await peer_pool.cancel() await downloader.cancel() loop.stop() async def run() -> None: await downloader.run() downloader.logger.info("run() finished, exiting") sigint_received.set() # loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(run()) loop.run_forever() loop.close()
async def test_sync_integration(request, caplog, geth_ipc_path, enode, geth_process): """Test a regular chain sync against a running geth instance. In order to run this manually, you can use `tox -e py37-sync_integration` or: pytest --integration --capture=no tests/integration/test_sync.py The fixture for this test was generated with: geth --ropsten --syncmode full It only needs the first 11 blocks for this test to succeed. """ if not request.config.getoption("--integration"): pytest.skip("Not asked to run integration tests") # will almost certainly want verbose logging in a failure caplog.set_level(logging.DEBUG) # make sure geth has been launched wait_for_socket(geth_ipc_path) remote = Node.from_uri(enode) base_db = AtomicDB() chaindb = AsyncChainDB(base_db) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) headerdb = AsyncHeaderDB(base_db) chain_config = Eth1ChainConfig.from_preconfigured_network( ROPSTEN_NETWORK_ID) chain = chain_config.initialize_chain(base_db) context = ChainContext( headerdb=headerdb, network_id=ROPSTEN_NETWORK_ID, vm_configuration=ROPSTEN_VM_CONFIGURATION, client_version_string='trinity-test', listen_port=30303, p2p_version=DEVP2P_V5, ) peer_pool = ETHPeerPool(privkey=ecies.generate_privkey(), context=context) syncer = RegularChainSyncer(chain, chaindb, peer_pool) async with background_asyncio_service(peer_pool) as manager: await manager.wait_started() await peer_pool.connect_to_nodes([remote]) assert len(peer_pool) == 1 async with background_asyncio_service(syncer) as syncer_manager: await syncer_manager.wait_started() n = 11 manager.logger.info(f"Waiting for the chain to sync {n} blocks") async def wait_for_header_sync(block_number): while chaindb.get_canonical_head().block_number < block_number: await asyncio.sleep(0.1) await asyncio.wait_for(wait_for_header_sync(n), 5) # https://ropsten.etherscan.io/block/11 header = chaindb.get_canonical_block_header_by_number(n) transactions = chaindb.get_block_transactions( header, BaseTransactionFields) assert len(transactions) == 15 receipts = chaindb.get_receipts(header, Receipt) assert len(receipts) == 15 assert encode_hex(keccak(rlp.encode(receipts[0]))) == ( '0xf709ed2c57efc18a1675e8c740f3294c9e2cb36ba7bb3b89d3ab4c8fef9d8860' )