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()