def test_wait_for_connection_success():
success_tracker = {}
port = get_open_port()
def _do_client():
success_tracker['client_booted'] = True
try:
wait_for_connection('localhost', port)
except Timeout:
success_tracker['client_success'] = False
else:
success_tracker['client_success'] = True
finally:
success_tracker['client_exited'] = True
class TestHTTPServer(HTTPServer):
timeout = 30
def handle_timeout(self):
success_tracker['server_success'] = False
def handle_error(self):
success_tracker['server_success'] = True
def _do_server():
success_tracker['server_booted'] = True
server = TestHTTPServer(('localhost', port), BaseHTTPRequestHandler)
server.timeout = 30
success_tracker['server_before_handle'] = True
server.handle_request()
success_tracker['server_after_handle'] = True
success_tracker.setdefault('server_success', True)
success_tracker['server_exited'] = True
client_thread = spawn(_do_client)
server_thread = spawn(_do_server)
try:
with Timeout(5) as _timeout:
while 'client_success' not in success_tracker and 'server_success' not in success_tracker:
_timeout.sleep(random.random())
except Timeout:
pass
assert 'client_success' in success_tracker
assert success_tracker['client_success'] is True
assert 'server_success' in success_tracker
assert success_tracker['server_success'] is True
def __enter__(self):
if self._running:
raise ValueError("The TesterChain is already running")
if self.port is None:
self.port = get_open_port()
self.provider = TestRPCProvider(port=self.port)
testrpc.full_reset()
testrpc.rpc_configure('eth_mining', False)
testrpc.rpc_configure('eth_protocolVersion', '0x3f')
testrpc.rpc_configure('net_version', 1)
testrpc.evm_mine()
wait_for_connection('127.0.0.1', self.port)
self._running = True
return self
def test_wait_for_connection_success():
success_tracker = {}
port = get_open_port()
def _do_client():
try:
wait_for_connection('localhost', port)
except gevent.Timeout:
success_tracker['client_success'] = False
else:
success_tracker['client_success'] = True
class TestHTTPServer(HTTPServer):
timeout = 30
def handle_timeout():
success_tracker['server_success'] = False
def handle_error():
success_tracker['server_success'] = True
def _do_server():
server = TestHTTPServer(('localhost', port), BaseHTTPRequestHandler)
server.timeout = 30
server.handle_request()
success_tracker.setdefault('server_success', True)
client_thread = gevent.spawn(_do_client)
server_thread = gevent.spawn(_do_server)
try:
with gevent.Timeout(5):
while 'client_success' not in success_tracker and 'server_success' not in success_tracker:
gevent.sleep(random.random())
except gevent.Timeout:
pass
assert 'client_success' in success_tracker
assert success_tracker['client_success'] is True
assert 'server_success' in success_tracker
assert success_tracker['server_success'] is True
def __enter__(self):
if self._running:
raise ValueError("The TesterChain is already running")
if self.rpc_port is None:
self.rpc_port = get_open_port()
self._running = True
self.rpc_methods = self.web3.providers[0].server.application.rpc_methods
self.rpc_methods.full_reset()
self.rpc_methods.rpc_configure('eth_mining', False)
self.rpc_methods.rpc_configure('eth_protocolVersion', '0x3f')
self.rpc_methods.rpc_configure('net_version', 1)
self.rpc_methods.evm_mine()
wait_for_connection('127.0.0.1', self.rpc_port)
return self
def test_wait_for_connection_success():
success_tracker = {}
port = get_open_port()
def _do_client():
try:
wait_for_connection('localhost', port)
except gevent.Timeout:
success_tracker['client_success'] = False
else:
success_tracker['client_success'] = True
class TestHTTPServer(HTTPServer):
timeout = 30
def handle_timeout():
success_tracker['server_success'] = False
def handle_error():
success_tracker['server_success'] = True
def _do_server():
server = TestHTTPServer(('localhost', port), BaseHTTPRequestHandler)
server.timeout = 30
server.handle_request()
success_tracker.setdefault('server_success', True)
client_thread = gevent.spawn(_do_client)
server_thread = gevent.spawn(_do_server)
try:
with gevent.Timeout(5):
while 'client_success' not in success_tracker and 'server_success' not in success_tracker:
gevent.sleep(random.random())
except gevent.Timeout:
pass
assert 'client_success' in success_tracker
assert success_tracker['client_success'] is True
assert 'server_success' in success_tracker
assert success_tracker['server_success'] is True
def __enter__(self):
if self._running:
raise ValueError("The TesterChain is already running")
if self.rpc_port is None:
self.rpc_port = get_open_port()
self._running = True
self.rpc_methods = self.web3.currentProvider.server.application.rpc_methods
self.rpc_methods.full_reset()
self.rpc_methods.rpc_configure('eth_mining', False)
self.rpc_methods.rpc_configure('eth_protocolVersion', '0x3f')
self.rpc_methods.rpc_configure('net_version', 1)
self.rpc_methods.evm_mine()
wait_for_connection('127.0.0.1', self.rpc_port)
return self
def test_wait_for_connection_success():
success_tracker = {}
port = get_open_port()
def _do_client():
try:
wait_for_connection('localhost', port, 2)
except gevent.Timeout:
success_tracker['client_success'] = False
else:
success_tracker['client_success'] = True
client_thread = gevent.spawn(_do_client)
try:
with gevent.Timeout(5):
while 'client_success' not in success_tracker:
gevent.sleep(random.random())
except gevent.Timeout:
pass
assert 'client_success' in success_tracker
assert success_tracker['client_success'] is False
def test_wait_for_connection_success():
success_tracker = {}
port = get_open_port()
def _do_client():
try:
wait_for_connection('localhost', port, 2)
except gevent.Timeout:
success_tracker['client_success'] = False
else:
success_tracker['client_success'] = True
client_thread = gevent.spawn(_do_client)
try:
with gevent.Timeout(5):
while 'client_success' not in success_tracker:
gevent.sleep(random.random())
except gevent.Timeout:
pass
assert 'client_success' in success_tracker
assert success_tracker['client_success'] is False
def test_wait_for_connection_failure():
success_tracker = {}
port = get_open_port()
def _do_client():
success_tracker['client_booted'] = True
try:
wait_for_connection('localhost', port, 2)
except Timeout:
success_tracker['client_success'] = False
else:
success_tracker['client_success'] = True
client_thread = spawn(_do_client)
try:
with Timeout(5) as _timeout:
while 'client_success' not in success_tracker:
_timeout.sleep(random.random())
except Timeout:
pass
assert 'client_success' in success_tracker
assert success_tracker['client_success'] is False
def test_project_local_chain_rpc(project_dir):
project = Project()
rpc_port = str(get_open_port())
project.config['chains.local.chain.class'] = 'populus.chain.LocalGethChain'
project.config['chains.local.chain.settings.rpc_port'] = rpc_port
project.config[
'chains.local.web3.provider.class'] = 'web3.providers.rpc.HTTPProvider'
project.config[
'chains.local.web3.provider.settings.endpoint_uri'] = "http://127.0.0.1:{0}".format(
rpc_port)
project.write_config()
chain = project.get_chain('local')
with chain as running_local_chain:
web3 = running_local_chain.web3
assert web3.version.node.startswith('Geth')
running_local_chain.wait.for_block(block_number=1, timeout=180)
block_1 = web3.eth.getBlock(1)
assert block_1['hash'] != MAINNET_BLOCK_1_HASH
assert block_1['hash'] != TESTNET_BLOCK_1_HASH
assert block_1['miner'] == web3.eth.coinbase
def test_show_chain_sync_progress():
project = Project()
main_chain = project.get_chain('temp',
no_discover=False,
max_peers=None,
port=str(get_open_port()),
rpc_enabled=False,
ws_enabled=False)
with main_chain:
sync_chain = project.get_chain('temp',
no_discover=False,
max_peers=None,
mine=False,
miner_threads=None,
port=str(get_open_port()),
rpc_enabled=False,
ws_enabled=False)
main_chain_data_dir = main_chain.geth.data_dir
sync_chain_data_dir = sync_chain.geth.data_dir
main_genesis_file = os.path.join(main_chain_data_dir, 'genesis.json')
sync_genesis_file = os.path.join(sync_chain_data_dir, 'genesis.json')
main_chaindata_dir = os.path.join(main_chain_data_dir, 'chaindata')
sync_chaindata_dir = os.path.join(sync_chain_data_dir, 'chaindata')
os.remove(sync_genesis_file)
shutil.rmtree(sync_chaindata_dir)
shutil.copyfile(main_genesis_file, sync_genesis_file)
shutil.copytree(main_chaindata_dir, sync_chaindata_dir)
block_numbers = []
runner = CliRunner()
@click.command()
def wrapper():
block_numbers.append(sync_chain.web3.eth.blockNumber)
show_chain_sync_progress(sync_chain)
block_numbers.append(sync_chain.web3.eth.blockNumber)
with sync_chain:
main_node_info = main_chain.web3.admin.nodeInfo
main_enode = "enode://{node_id}@127.0.0.1:{node_port}".format(
node_id=main_node_info['id'],
node_port=main_node_info['ports']['listener'],
)
sync_node_info = sync_chain.web3.admin.nodeInfo
sync_enode = "enode://{node_id}@127.0.0.1:{node_port}".format(
node_id=sync_node_info['id'],
node_port=sync_node_info['ports']['listener'],
)
main_chain.wait.for_block(BLOCK_DELTA, timeout=BLOCK_DELTA * 4)
main_chain_start_block = main_chain.web3.eth.blockNumber
sync_chain_start_block = sync_chain.web3.eth.blockNumber
assert main_chain_start_block - sync_chain_start_block >= BLOCK_DELTA // 2
assert sync_chain.web3.net.peerCount == 0
sync_chain.web3.admin.addPeer(main_enode)
main_chain.web3.admin.addPeer(sync_enode)
sync_chain.wait.for_peers(timeout=60)
result = runner.invoke(wrapper, [])
assert result.exit_code == 0
assert len(block_numbers) == 2
start_block = block_numbers[0]
end_block = block_numbers[1]
assert start_block <= 1
assert end_block >= 20
def test_show_chain_sync_progress():
project = Project()
main_chain = project.get_chain('temp',
no_discover=False,
max_peers=None,
port=str(get_open_port()),
rpc_enabled=False,
ws_enabled=False)
with main_chain:
sync_chain = project.get_chain('temp',
no_discover=False,
max_peers=None,
mine=False,
miner_threads=None,
port=str(get_open_port()),
rpc_enabled=False,
ws_enabled=False)
main_chain_data_dir = main_chain.geth.data_dir
sync_chain_data_dir = sync_chain.geth.data_dir
main_genesis_file = os.path.join(main_chain_data_dir, 'genesis.json')
sync_genesis_file = os.path.join(sync_chain_data_dir, 'genesis.json')
main_chaindata_dir = os.path.join(main_chain_data_dir, 'chaindata')
sync_chaindata_dir = os.path.join(sync_chain_data_dir, 'chaindata')
os.remove(sync_genesis_file)
shutil.rmtree(sync_chaindata_dir)
shutil.copyfile(main_genesis_file, sync_genesis_file)
shutil.copytree(main_chaindata_dir, sync_chaindata_dir)
block_numbers = []
runner = CliRunner()
@click.command()
def wrapper():
block_numbers.append(sync_chain.web3.eth.blockNumber)
show_chain_sync_progress(sync_chain)
block_numbers.append(sync_chain.web3.eth.blockNumber)
with sync_chain:
main_node_info = main_chain.web3.admin.nodeInfo
main_enode = "enode://{node_id}@127.0.0.1:{node_port}".format(
node_id=main_node_info['id'],
node_port=main_node_info['ports']['listener'],
)
sync_node_info = sync_chain.web3.admin.nodeInfo
sync_enode = "enode://{node_id}@127.0.0.1:{node_port}".format(
node_id=sync_node_info['id'],
node_port=sync_node_info['ports']['listener'],
)
main_chain.wait.for_block(BLOCK_DELTA, timeout=BLOCK_DELTA * 4)
main_chain_start_block = main_chain.web3.eth.blockNumber
sync_chain_start_block = sync_chain.web3.eth.blockNumber
assert main_chain_start_block - sync_chain_start_block >= BLOCK_DELTA // 2
assert sync_chain.web3.net.peerCount == 0
sync_chain.web3.admin.addPeer(main_enode)
main_chain.web3.admin.addPeer(sync_enode)
sync_chain.wait.for_peers(timeout=60)
result = runner.invoke(wrapper, [])
assert result.exit_code == 0
assert len(block_numbers) == 2
start_block = block_numbers[0]
end_block = block_numbers[1]
assert start_block <= 1
assert end_block >= 20
