def _test() -> None:
import argparse
import signal
from p2p import ecies
from p2p.kademlia import Node
from p2p.peer import DEFAULT_PREFERRED_NODES
from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER, ROPSTEN_VM_CONFIGURATION
from evm.db.backends.level import LevelDB
from tests.p2p.integration_test_helpers import (FakeAsyncChainDB,
FakeAsyncRopstenChain,
FakeAsyncHeaderDB,
connect_to_peers_loop)
parser = argparse.ArgumentParser()
parser.add_argument('-db', type=str, required=True)
parser.add_argument('-fast', action="store_true")
parser.add_argument('-light', action="store_true")
parser.add_argument('-enode',
type=str,
required=False,
help="The enode we should connect to")
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
loop = asyncio.get_event_loop()
base_db = LevelDB(args.db)
chaindb = FakeAsyncChainDB(base_db)
chaindb.persist_header(ROPSTEN_GENESIS_HEADER)
headerdb = FakeAsyncHeaderDB(base_db)
peer_class: Type[HeaderRequestingPeer] = ETHPeer
if args.light:
peer_class = LESPeer
network_id = RopstenChain.network_id
privkey = ecies.generate_privkey()
peer_pool = PeerPool(peer_class, headerdb, network_id, privkey,
ROPSTEN_VM_CONFIGURATION)
if args.enode:
nodes = tuple([Node.from_uri(args.enode)])
else:
nodes = DEFAULT_PREFERRED_NODES[network_id]
asyncio.ensure_future(peer_pool.run())
asyncio.ensure_future(connect_to_peers_loop(peer_pool, nodes))
chain = FakeAsyncRopstenChain(base_db)
syncer: BaseHeaderChainSyncer = None
if args.fast:
syncer = FastChainSyncer(chain, chaindb, peer_pool)
elif args.light:
syncer = LightChainSyncer(chain, headerdb, peer_pool)
else:
syncer = RegularChainSyncer(chain, chaindb, peer_pool)
syncer.logger.setLevel(log_level)
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() -> None:
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 pathlib import Path
import signal
from p2p import ecies
from p2p.kademlia import Node
from p2p.peer import DEFAULT_PREFERRED_NODES
from eth.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER, ROPSTEN_VM_CONFIGURATION
from eth.chains.mainnet import MainnetChain, MAINNET_GENESIS_HEADER, MAINNET_VM_CONFIGURATION
from eth.db.backends.level import LevelDB
from tests.p2p.integration_test_helpers import (FakeAsyncChainDB,
FakeAsyncMainnetChain,
FakeAsyncRopstenChain,
FakeAsyncHeaderDB,
connect_to_peers_loop)
from trinity.protocol.eth.peer import ETHPeer # noqa: F811
from trinity.protocol.les.peer import LESPeer # noqa: F811
from trinity.utils.chains import load_nodekey
parser = argparse.ArgumentParser()
parser.add_argument('-db', type=str, required=True)
parser.add_argument('-fast', action="store_true")
parser.add_argument('-light', action="store_true")
parser.add_argument('-nodekey', type=str)
parser.add_argument('-enode',
type=str,
required=False,
help="The enode we should connect to")
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
loop = asyncio.get_event_loop()
base_db = LevelDB(args.db)
headerdb = FakeAsyncHeaderDB(base_db)
chaindb = FakeAsyncChainDB(base_db)
try:
genesis = chaindb.get_canonical_block_header_by_number(0)
except HeaderNotFound:
genesis = ROPSTEN_GENESIS_HEADER
chaindb.persist_header(genesis)
peer_class: Type[Union[ETHPeer, LESPeer]] = ETHPeer
if args.light:
peer_class = LESPeer
if genesis.hash == ROPSTEN_GENESIS_HEADER.hash:
network_id = RopstenChain.network_id
vm_config = ROPSTEN_VM_CONFIGURATION # type: ignore
chain_class = FakeAsyncRopstenChain
elif genesis.hash == MAINNET_GENESIS_HEADER.hash:
network_id = MainnetChain.network_id
vm_config = MAINNET_VM_CONFIGURATION # type: ignore
chain_class = FakeAsyncMainnetChain
else:
raise RuntimeError("Unknown genesis: %s", genesis)
if args.nodekey:
privkey = load_nodekey(Path(args.nodekey))
else:
privkey = ecies.generate_privkey()
peer_pool = PeerPool(peer_class, headerdb, network_id, privkey, vm_config)
if args.enode:
nodes = tuple([Node.from_uri(args.enode)])
else:
nodes = DEFAULT_PREFERRED_NODES[network_id]
asyncio.ensure_future(peer_pool.run())
asyncio.ensure_future(connect_to_peers_loop(peer_pool, nodes))
chain = chain_class(base_db)
syncer: BaseHeaderChainSyncer = None
if args.fast:
syncer = FastChainSyncer(chain, chaindb, peer_pool)
elif args.light:
syncer = LightChainSyncer(chain, headerdb, peer_pool)
else:
syncer = RegularChainSyncer(chain, chaindb, peer_pool)
syncer.logger.setLevel(log_level)
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() -> None:
await sigint_received.wait()
await peer_pool.cancel()
await syncer.cancel()
loop.stop()
async def run() -> None:
await syncer.run()
syncer.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_lightchain_integration(request, event_loop, caplog,
geth_ipc_path, enode, geth_process):
"""Test LightChainSyncer/LightPeerChain against a running geth instance.
In order to run this manually, you can use `tox -e py36-lightchain_integration` or:
pytest --integration --capture=no tests/trinity/integration/test_lightchain_integration.py
The fixture for this test was generated with:
geth --testnet --syncmode full
It only needs the first 11 blocks for this test to succeed.
"""
if not pytest.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 = MemoryDB()
chaindb = FakeAsyncChainDB(base_db)
chaindb.persist_header(ROPSTEN_GENESIS_HEADER)
headerdb = FakeAsyncHeaderDB(base_db)
peer_pool = PeerPool(
LESPeer,
FakeAsyncHeaderDB(base_db),
ROPSTEN_NETWORK_ID,
ecies.generate_privkey(),
ROPSTEN_VM_CONFIGURATION,
)
chain = FakeAsyncRopstenChain(base_db)
syncer = LightChainSyncer(chain, chaindb, peer_pool)
syncer.min_peers_to_sync = 1
peer_chain = LightPeerChain(headerdb, peer_pool)
asyncio.ensure_future(peer_pool.run())
asyncio.ensure_future(connect_to_peers_loop(peer_pool, tuple([remote])))
asyncio.ensure_future(peer_chain.run())
asyncio.ensure_future(syncer.run())
await asyncio.sleep(
0) # Yield control to give the LightChainSyncer a chance to start
def finalizer():
event_loop.run_until_complete(peer_pool.cancel())
event_loop.run_until_complete(peer_chain.cancel())
event_loop.run_until_complete(syncer.cancel())
request.addfinalizer(finalizer)
n = 11
# Wait for the chain to sync a few headers.
async def wait_for_header_sync(block_number):
while headerdb.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 = headerdb.get_canonical_block_header_by_number(n)
body = await peer_chain.get_block_body_by_hash(header.hash)
assert len(body['transactions']) == 15
receipts = await peer_chain.get_receipts(header.hash)
assert len(receipts) == 15
assert encode_hex(keccak(rlp.encode(receipts[0]))) == (
'0xf709ed2c57efc18a1675e8c740f3294c9e2cb36ba7bb3b89d3ab4c8fef9d8860')
assert len(peer_pool) == 1
head_info = peer_pool.highest_td_peer.head_info
head = await peer_chain.get_block_header_by_hash(head_info.block_hash)
assert head.block_number == head_info.block_number
# In order to answer queries for contract code, geth needs the state trie entry for the block
# we specify in the query, but because of fast sync we can only assume it has that for recent
# blocks, so we use the current head to lookup the code for the contract below.
# https://ropsten.etherscan.io/address/0x95a48dca999c89e4e284930d9b9af973a7481287
contract_addr = decode_hex('0x8B09D9ac6A4F7778fCb22852e879C7F3B2bEeF81')
contract_code = await peer_chain.get_contract_code(head.hash,
contract_addr)
assert encode_hex(contract_code) == '0x600060006000600060006000356000f1'
account = await peer_chain.get_account(head.hash, contract_addr)
assert account.code_hash == keccak(contract_code)
assert account.balance == 0
def p2p_server(monkeypatch, jsonrpc_ipc_pipe_path):
monkeypatch.setattr(Server, '_make_peer_pool',
lambda s: PeerPool(None, None, None, None, None, None))
return Server(None, None, None, None, None, None, None)
async def test_lightchain_integration(request, event_loop):
"""Test LightChainSyncer/LightPeerChain against a running geth instance.
In order to run this you need to pass the following to pytest:
pytest --integration --enode=...
"""
# TODO: Implement a pytest fixture that runs geth as above, so that we don't need to run it
# manually.
if not pytest.config.getoption("--integration"):
pytest.skip("Not asked to run integration tests")
remote = Node.from_uri(pytest.config.getoption("--enode"))
base_db = MemoryDB()
chaindb = FakeAsyncChainDB(base_db)
chaindb.persist_header(ROPSTEN_GENESIS_HEADER)
headerdb = FakeAsyncHeaderDB(base_db)
peer_pool = PeerPool(LESPeer,
FakeAsyncHeaderDB(base_db), ROPSTEN_NETWORK_ID,
ecies.generate_privkey(), ROPSTEN_VM_CONFIGURATION)
chain = FakeAsyncRopstenChain(base_db)
syncer = LightChainSyncer(chain, chaindb, peer_pool)
syncer.min_peers_to_sync = 1
peer_chain = LightPeerChain(headerdb, peer_pool)
asyncio.ensure_future(peer_pool.run())
asyncio.ensure_future(connect_to_peers_loop(peer_pool, tuple([remote])))
asyncio.ensure_future(peer_chain.run())
asyncio.ensure_future(syncer.run())
await asyncio.sleep(
0) # Yield control to give the LightChainSyncer a chance to start
def finalizer():
event_loop.run_until_complete(peer_pool.cancel())
event_loop.run_until_complete(peer_chain.cancel())
event_loop.run_until_complete(syncer.cancel())
request.addfinalizer(finalizer)
n = 11
# Wait for the chain to sync a few headers.
async def wait_for_header_sync(block_number):
while headerdb.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 = headerdb.get_canonical_block_header_by_number(n)
body = await peer_chain.get_block_body_by_hash(header.hash)
assert len(body['transactions']) == 15
receipts = await peer_chain.get_receipts(header.hash)
assert len(receipts) == 15
assert encode_hex(keccak(rlp.encode(receipts[0]))) == (
'0xf709ed2c57efc18a1675e8c740f3294c9e2cb36ba7bb3b89d3ab4c8fef9d8860')
assert len(peer_pool) == 1
head_info = peer_pool.peers[0].head_info
head = await peer_chain.get_block_header_by_hash(head_info.block_hash)
assert head.block_number == head_info.block_number
# In order to answer queries for contract code, geth needs the state trie entry for the block
# we specify in the query, but because of fast sync we can only assume it has that for recent
# blocks, so we use the current head to lookup the code for the contract below.
# https://ropsten.etherscan.io/address/0x95a48dca999c89e4e284930d9b9af973a7481287
contract_addr = decode_hex('95a48dca999c89e4e284930d9b9af973a7481287')
contract_code = await peer_chain.get_contract_code(head.hash,
keccak(contract_addr))
assert encode_hex(keccak(contract_code)) == (
'0x1e0b2ad970b365a217c40bcf3582cbb4fcc1642d7a5dd7a82ae1e278e010123e')
account = await peer_chain.get_account(head.hash, contract_addr)
assert account.code_hash == keccak(contract_code)
assert account.balance == 0
def main():
args = parser.parse_args()
if args.ropsten:
chain_identifier = ROPSTEN
else:
# TODO: mainnet
chain_identifier = ROPSTEN
if args.light:
sync_mode = SYNC_LIGHT
else:
# TODO: actually use args.sync_mode (--sync-mode)
sync_mode = SYNC_LIGHT
chain_config = ChainConfig.from_parser_args(
chain_identifier,
args,
)
# if console command, run the trinity CLI
if args.subcommand == 'console':
use_ipython = not args.vanilla_shell
debug = args.log_level.upper() == 'DEBUG'
# TODO: this should use the base `Chain` class rather than the protocol
# class since it's just a repl with access to the chain.
chain_class = get_chain_protocol_class(chain_config, sync_mode)
chaindb = ChainDB(LevelDB(chain_config.database_dir))
peer_pool = PeerPool(LESPeer, chaindb, chain_config.network_id,
chain_config.nodekey)
chain = chain_class(chaindb, peer_pool)
args.func(chain, use_ipython=use_ipython, debug=debug)
sys.exit(0)
logger, log_queue, listener = setup_trinity_logging(args.log_level.upper())
# start the listener thread to handle logs produced by other processes in
# the local logger.
listener.start()
# First initialize the database process.
database_server_process = ctx.Process(target=run_database_process,
args=(
chain_config,
LevelDB,
),
kwargs={'log_queue': log_queue})
# For now we just run the light sync against ropsten by default.
networking_process = ctx.Process(target=run_networking_process,
args=(chain_config, sync_mode),
kwargs={'log_queue': log_queue})
# start the processes
database_server_process.start()
wait_for_ipc(chain_config.database_ipc_path)
networking_process.start()
try:
networking_process.join()
except KeyboardInterrupt:
logger.info('Keyboard Interrupt: Stopping')
kill_process_gracefully(networking_process)
logger.info('KILLED networking_process')
kill_process_gracefully(database_server_process)
logger.info('KILLED database_server_process')
