def _test(): import argparse from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from p2p.peer import HardCodedNodesPeerPool from evm.chains.ropsten import RopstenChain from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB 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") args = parser.parse_args() log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.getLogger('p2p.state.StateDownloader').setLevel(log_level) db = LevelDB(args.db) chaindb = FakeAsyncChainDB(db) discovery = None peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey(), discovery, min_peers=5) asyncio.ensure_future(peer_pool.run()) head = chaindb.get_canonical_head() downloader = StateDownloader(db, head.state_root, peer_pool) loop = asyncio.get_event_loop() 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 peer_pool.cancel() await downloader.cancel() loop.stop() loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(downloader.run()) loop.run_forever() loop.close()
def _test(): import argparse from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from p2p.peer import HardCodedNodesPeerPool from evm.chains.ropsten import RopstenChain from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB 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") args = parser.parse_args() log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.getLogger('p2p.state.StateDownloader').setLevel(log_level) db = LevelDB(args.db) chaindb = FakeAsyncChainDB(db) peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey(), min_peers=5) asyncio.ensure_future(peer_pool.run()) head = chaindb.get_canonical_head() downloader = StateDownloader(db, head.state_root, peer_pool) loop = asyncio.get_event_loop() loop.set_default_executor(ProcessPoolExecutor()) for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, downloader.cancel_token.trigger) async def run(): # downloader.run() will run in a loop until the SIGINT/SIGTERM handler triggers its cancel # token, at which point it returns and we stop the pool and downloader. try: await downloader.run() except OperationCancelled: pass await peer_pool.stop() await downloader.stop() loop.run_until_complete(run()) loop.close()
def _test(): import argparse import asyncio from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from p2p.peer import ETHPeer, HardCodedNodesPeerPool from evm.chains.ropsten import RopstenChain from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB, FakeAsyncRopstenChain logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) args = parser.parse_args() chaindb = FakeAsyncChainDB(LevelDB(args.db)) chain = FakeAsyncRopstenChain(chaindb) discovery = None peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey(), discovery, min_peers=5) asyncio.ensure_future(peer_pool.run()) loop = asyncio.get_event_loop() loop.set_default_executor(ProcessPoolExecutor()) 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(): 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 _test() -> None: import argparse from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB, LocalGethPeerPool parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-local-geth', action="store_true") parser.add_argument('-debug', action="store_true") args = parser.parse_args() logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s', datefmt='%H:%M:%S') log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.getLogger('p2p.chain.ChainSyncer').setLevel(log_level) loop = asyncio.get_event_loop() # Use a ProcessPoolExecutor as the default because the tasks we want to offload from the main # thread are cpu intensive. loop.set_default_executor(ProcessPoolExecutor()) chaindb = FakeAsyncChainDB(LevelDB(args.db)) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) privkey = ecies.generate_privkey() if args.local_geth: peer_pool = LocalGethPeerPool(ETHPeer, chaindb, RopstenChain.network_id, privkey) else: from p2p.peer import HardCodedNodesPeerPool min_peers = 5 peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, privkey, min_peers) asyncio.ensure_future(peer_pool.run()) downloader = ChainSyncer(chaindb, peer_pool) async def run(): # downloader.run() will run in a loop until the SIGINT/SIGTERM handler triggers its cancel # token, at which point it returns and we stop the pool and downloader. try: await downloader.run() except OperationCancelled: pass await peer_pool.stop() await downloader.stop() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, downloader.cancel_token.trigger) loop.run_until_complete(run()) loop.close()
def _test(): import argparse import signal from p2p import ecies from p2p.peer import HardCodedNodesPeerPool from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.level import LevelDB from evm.db.backends.memory import MemoryDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-root-hash', type=str, required=True, help='Hex encoded root hash') args = parser.parse_args() chaindb = FakeAsyncChainDB(MemoryDB()) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey()) asyncio.ensure_future(peer_pool.run()) state_db = LevelDB(args.db) root_hash = decode_hex(args.root_hash) downloader = StateDownloader(state_db, root_hash, peer_pool) loop = asyncio.get_event_loop() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, downloader.cancel_token.trigger) async def run(): # downloader.run() will run in a loop until the SIGINT/SIGTERM handler triggers its cancel # token, at which point it returns and we stop the pool and downloader. await downloader.run() await peer_pool.stop() await downloader.stop() loop.run_until_complete(run()) loop.close()
def _test(): import argparse import asyncio from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from p2p.peer import ETHPeer, HardCodedNodesPeerPool from evm.chains.ropsten import RopstenChain from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) args = parser.parse_args() chaindb = FakeAsyncChainDB(LevelDB(args.db)) peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey(), min_peers=5) asyncio.ensure_future(peer_pool.run()) loop = asyncio.get_event_loop() loop.set_default_executor(ProcessPoolExecutor()) syncer = FullNodeSyncer(chaindb, peer_pool) for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, syncer.cancel_token.trigger) async def run(): try: await syncer.run() except OperationCancelled: pass await peer_pool.stop() loop.run_until_complete(run()) loop.close()
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 _test() -> None: import argparse import signal from p2p import ecies from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import ( FakeAsyncChainDB, FakeAsyncRopstenChain, LocalGethPeerPool, FakeAsyncHeaderDB) parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-fast', action="store_true") parser.add_argument('-local-geth', action="store_true") parser.add_argument('-debug', action="store_true") args = parser.parse_args() logging.basicConfig( level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s', datefmt='%H:%M:%S') log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.getLogger('p2p.chain.ChainSyncer').setLevel(log_level) loop = asyncio.get_event_loop() base_db = LevelDB(args.db) chaindb = FakeAsyncChainDB(base_db) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) headerdb = FakeAsyncHeaderDB(base_db) privkey = ecies.generate_privkey() if args.local_geth: peer_pool = LocalGethPeerPool(ETHPeer, headerdb, RopstenChain.network_id, privkey) else: from p2p.peer import HardCodedNodesPeerPool discovery = None peer_pool = HardCodedNodesPeerPool( peer_class=ETHPeer, headerdb=headerdb, network_id=RopstenChain.network_id, privkey=privkey, discovery=discovery, ) asyncio.ensure_future(peer_pool.run()) if args.fast: syncer = FastChainSyncer(chaindb, peer_pool) else: chain = FakeAsyncRopstenChain(base_db) syncer = RegularChainSyncer(chain, chaindb, peer_pool) syncer.min_peers_to_sync = 1 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 peer_pool.cancel() await syncer.cancel() loop.stop() loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(syncer.run()) loop.run_forever() loop.close()
def _test() -> None: import argparse from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import (FakeAsyncChainDB, FakeAsyncRopstenChain, LocalGethPeerPool) parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-fast', action="store_true") parser.add_argument('-local-geth', action="store_true") parser.add_argument('-debug', action="store_true") args = parser.parse_args() logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s', datefmt='%H:%M:%S') log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.getLogger('p2p.chain.ChainSyncer').setLevel(log_level) loop = asyncio.get_event_loop() # Use a ProcessPoolExecutor as the default because the tasks we want to offload from the main # thread are cpu intensive. loop.set_default_executor(ProcessPoolExecutor()) chaindb = FakeAsyncChainDB(LevelDB(args.db)) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) privkey = ecies.generate_privkey() if args.local_geth: peer_pool = LocalGethPeerPool(ETHPeer, chaindb, RopstenChain.network_id, privkey) else: from p2p.peer import HardCodedNodesPeerPool min_peers = 5 peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, privkey, min_peers) asyncio.ensure_future(peer_pool.run()) if args.fast: syncer = FastChainSyncer(chaindb, peer_pool) else: chain = FakeAsyncRopstenChain(chaindb) syncer = RegularChainSyncer(chain, chaindb, peer_pool) syncer.min_peers_to_sync = 1 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 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()