def test_eof():
peer = BitcoinPeerProtocol(MAGIC_HEADER)
pt = PeerTransport(None)
peer.connection_made(pt)
COUNT = 0
@asyncio.coroutine
def async_listen(next_message):
count = 0
try:
while True:
name, data = yield from next_message()
count += 1
except EOFError:
pass
assert count == 2
nonlocal COUNT
COUNT += 1
tasks = [asyncio.Task(async_listen(peer.new_get_next_message_f())) for i in range(50)]
peer.data_received(VERSION_MSG_BIN)
peer.data_received(VERACK_MSG_BIN)
# end of stream
peer.connection_lost(None)
# give everyone a chance to run (but no one finishes)
asyncio.get_event_loop().run_until_complete(asyncio.wait(tasks))
assert COUNT == 50
def create_protocol_callback():
peer = BitcoinPeerProtocol(network["MAGIC_HEADER"])
install_pingpong_manager(peer)
fetcher = Fetcher(peer)
peer.add_task(
run_peer(peer, fetcher, self.getheaders_add_peer,
self.blockfetcher, self.inv_collector))
return peer
def create_protocol_callback():
peer = BitcoinPeerProtocol(network["MAGIC_HEADER"])
install_pingpong_manager(peer)
fetcher = Fetcher(peer)
peer.add_task(run_peer(
peer, fetcher, self.getheaders_add_peer,
self.blockfetcher, self.inv_collector))
return peer
def create_protocol_callback():
peer = BitcoinPeerProtocol(MAINNET["MAGIC_HEADER"])
install_pingpong_manager(peer)
fetcher = Fetcher(peer)
peer.add_task(run_peer(
peer, fetcher, fast_forward_add_peer,
blockfetcher, inv_collector, blockhandler))
return peer
def test_BitcoinPeerProtocol_multiplex():
peer = BitcoinPeerProtocol(MAGIC_HEADER)
pt = PeerTransport(None)
peer.connection_made(pt)
next_message_list = [peer.new_get_next_message_f() for i in range(50)]
COUNT = 0
@asyncio.coroutine
def async_test(next_message):
name, data = yield from next_message()
assert name == 'version'
assert data == VERSION_MSG
name, data = yield from next_message()
assert name == 'verack'
assert data == {}
nonlocal COUNT
COUNT += 1
peer.data_received(VERSION_MSG_BIN)
peer.data_received(VERACK_MSG_BIN)
asyncio.get_event_loop().run_until_complete(
asyncio.wait(
[asyncio.Task(async_test(nm)) for nm in next_message_list]))
assert COUNT == 50
def test_BitcoinPeerProtocol_read():
DATA = []
def write_f(data):
DATA.append(data)
peer = BitcoinPeerProtocol(MAGIC_HEADER)
pt = PeerTransport(write_f)
peer.connection_made(pt)
next_message = peer.new_get_next_message_f()
@asyncio.coroutine
def async_test():
t = []
name, data = yield from next_message()
t.append((name, data))
name, data = yield from next_message()
t.append((name, data))
return t
peer.data_received(VERSION_MSG_BIN)
peer.data_received(VERACK_MSG_BIN)
t = asyncio.get_event_loop().run_until_complete(async_test())
assert len(t) == 2
assert t[0] == ('version', VERSION_MSG)
assert t[1] == ('verack', {})
def test_BitcoinPeerProtocol_read():
DATA = []
def write_f(data):
DATA.append(data)
peer = BitcoinPeerProtocol(MAGIC_HEADER)
pt = PeerTransport(write_f)
peer.connection_made(pt)
next_message = peer.new_get_next_message_f()
@asyncio.coroutine
def async_test():
t = []
name, data = yield from next_message()
t.append((name, data))
name, data = yield from next_message()
t.append((name, data))
return t
peer.data_received(VERSION_MSG_BIN)
peer.data_received(VERACK_MSG_BIN)
t = asyncio.get_event_loop().run_until_complete(async_test())
assert len(t) == 2
assert t[0] == ('version', VERSION_MSG)
assert t[1] == ('verack', {})
def create_peers(ip1="127.0.0.1", ip2="127.0.0.2"):
peer1 = BitcoinPeerProtocol(MAGIC_HEADER)
peer2 = BitcoinPeerProtocol(MAGIC_HEADER)
pt1 = PeerTransport(peer2.data_received, (ip2, 6111))
pt2 = PeerTransport(peer1.data_received, (ip1, 6111))
peer1.writ_data = pt1.writ_data
peer2.writ_data = pt2.writ_data
# connect them
peer1.connection_made(pt1)
peer2.connection_made(pt2)
return peer1, peer2
def loop_connect_to_superpeer(superpeer_ip_queue):
while 1:
try:
pair = yield from superpeer_ip_queue.get()
if pair is None:
break
peer_name = "%s:%d" % pair
host, port = pair
logging.debug("connecting to superpeer at %s", peer_name)
transport, peer = yield from asyncio.get_event_loop(
).create_connection(lambda: BitcoinPeerProtocol(magic_header),
host=host,
port=port)
logging.debug("connected to superpeer at %s", peer_name)
yield from initial_handshake(peer, version_data_for_peer(peer))
logging.debug("handshake complete on %s", peer_name)
date_address_tuples = yield from get_date_address_tuples(peer)
logging.debug("got addresses from %s", peer_name)
for da in date_address_tuples:
timestamp_peeraddress_tuple_queue.put_nowait(
(-da[0], da[1]))
logging.debug("closing connection to %s", peer_name)
transport.close()
except Exception:
logging.exception("failed during connect to %s", peer_name)
def test_BitcoinPeerProtocol_send():
DATA = []
def write_f(data):
DATA.append(data)
peer = BitcoinPeerProtocol(MAGIC_HEADER)
pt = PeerTransport(write_f)
peer.connection_made(pt)
assert DATA == []
peer.send_msg("version", **VERSION_MSG)
assert DATA[-1] == VERSION_MSG_BIN
peer.send_msg("verack")
assert len(DATA) == 2
assert DATA[-1] == VERACK_MSG_BIN
peer.send_msg("mempool")
assert len(DATA) == 3
assert DATA[-1] == b'foodmempool\x00\x00\x00\x00\x00\x00\x00\x00\x00]\xf6\xe0\xe2'
def test_BitcoinPeerProtocol():
@asyncio.coroutine
def do_test(peer, vm1, vm2):
next_message = peer.new_get_next_message_f()
peer.send_msg("version", **vm1)
message_name, data = yield from next_message()
assert message_name == 'version'
assert data == vm2
peer.send_msg("verack")
message_name, data = yield from next_message()
assert message_name == 'verack'
assert data == {}
peer.send_msg("getaddr")
message_name, data = yield from next_message()
assert message_name == 'getaddr'
assert data == {}
return True
peer1 = BitcoinPeerProtocol(MAGIC_HEADER)
peer2 = BitcoinPeerProtocol(MAGIC_HEADER)
pt1 = PeerTransport(peer2.data_received)
pt2 = PeerTransport(peer1.data_received)
# connect them
peer1.connection_made(pt1)
peer2.connection_made(pt2)
f1 = asyncio.Task(do_test(peer1, VERSION_MSG, VERSION_MSG_2))
f2 = asyncio.Task(do_test(peer2, VERSION_MSG_2, VERSION_MSG))
done, pending = asyncio.get_event_loop().run_until_complete(
asyncio.wait([f1, f2]))
for f in done:
assert f.result() == True
def test_BitcoinPeerProtocol_multiplex():
peer = BitcoinPeerProtocol(MAGIC_HEADER)
pt = PeerTransport(None)
peer.connection_made(pt)
next_message_list = [peer.new_get_next_message_f() for i in range(50)]
COUNT = 0
@asyncio.coroutine
def async_test(next_message):
name, data = yield from next_message()
assert name == 'version'
assert data == VERSION_MSG
name, data = yield from next_message()
assert name == 'verack'
assert data == {}
nonlocal COUNT
COUNT += 1
peer.data_received(VERSION_MSG_BIN)
peer.data_received(VERACK_MSG_BIN)
asyncio.get_event_loop().run_until_complete(asyncio.wait([asyncio.Task(async_test(nm)) for nm in next_message_list]))
assert COUNT == 50
def connect_to_remote(event_loop, magic_header, address_db, connections):
host, port = address_db.next_address()
logging.info("connecting to %s port %d", host, port)
try:
transport, peer = yield from event_loop.create_connection(
lambda: BitcoinPeerProtocol(magic_header),
host=host, port=port)
except Exception:
logging.exception("failed to connect to %s:%d", host, port)
address_db.remove_address(host, port)
address_db.save()
return
try:
logging.info("connected to %s:%d", host, port)
yield from asyncio.wait_for(peer.connection_made_future, timeout=None)
version_parameters = version_data_for_peer(peer)
yield from initial_handshake(peer, version_parameters)
AddressKeeper(peer, address_db)
address_db.add_address(host, port, int(time.time()))
connections.add(peer)
except Exception:
logging.exception("exception talking to %s:%d", host, port)
logging.info("done talking to %s:%d", host, port)
def test_BitcoinPeerProtocol():
@asyncio.coroutine
def do_test(peer, vm1, vm2):
next_message = peer.new_get_next_message_f()
peer.send_msg("version", **vm1)
message_name, data = yield from next_message()
assert message_name == 'version'
assert data == vm2
peer.send_msg("verack")
message_name, data = yield from next_message()
assert message_name == 'verack'
assert data == {}
peer.send_msg("getaddr")
message_name, data = yield from next_message()
assert message_name == 'getaddr'
assert data == {}
return True
peer1 = BitcoinPeerProtocol(MAGIC_HEADER)
peer2 = BitcoinPeerProtocol(MAGIC_HEADER)
pt1 = PeerTransport(peer2.data_received)
pt2 = PeerTransport(peer1.data_received)
# connect them
peer1.connection_made(pt1)
peer2.connection_made(pt2)
f1 = asyncio.Task(do_test(peer1, VERSION_MSG, VERSION_MSG_2))
f2 = asyncio.Task(do_test(peer2, VERSION_MSG_2, VERSION_MSG))
done, pending = asyncio.get_event_loop().run_until_complete(asyncio.wait([f1, f2]))
for f in done:
assert f.result() == True
def protocol_factory():
return BitcoinPeerProtocol(MAGIC_HEADER)
def test_queue_gc():
# create a peer
# add 50 listeners
# receive 100 messages
# first 10 listeners will stop listening after two messages
# check GC
peer = BitcoinPeerProtocol(MAGIC_HEADER)
pt = PeerTransport(None)
peer.connection_made(pt)
next_message_list = [peer.new_get_next_message_f() for i in range(50)]
assert len(peer.message_queues) == 50
next_message_list = None
assert len(peer.message_queues) == 0
@asyncio.coroutine
def async_listen(next_message, delay=0):
for i in range(101):
name, data = yield from next_message()
yield from asyncio.sleep(delay)
for i in range(3):
peer.add_task(async_listen(peer.new_get_next_message_f(), delay=60))
tasks = [asyncio.Task(async_listen(peer.new_get_next_message_f(), delay=1)) for i in range(50)]
peer.data_received(VERSION_MSG_BIN)
for i in range(100):
peer.data_received(VERACK_MSG_BIN)
# give everyone a chance to run (but no one finishes)
asyncio.get_event_loop().run_until_complete(asyncio.wait(tasks, timeout=0.1))
assert len(peer.message_queues) == 53
# now let all 50 finish. They should be collected.
asyncio.get_event_loop().run_until_complete(asyncio.wait(tasks))
## you would think this number would be 3, but it's not.
## oh well. This is close enough.
assert len(peer.message_queues) <= 4
def protocol_factory():
peer = BitcoinPeerProtocol(MAGIC_HEADER)
future_peer.set_result(peer)
#abstract_server.close()
return peer
def test_queue_gc():
# create a peer
# add 50 listeners
# receive 100 messages
# first 10 listeners will stop listening after two messages
# check GC
peer = BitcoinPeerProtocol(MAGIC_HEADER)
pt = PeerTransport(None)
peer.connection_made(pt)
next_message_list = [peer.new_get_next_message_f() for i in range(50)]
assert len(peer.message_queues) == 50
next_message_list = None
assert len(peer.message_queues) == 0
@asyncio.coroutine
def async_listen(next_message, delay=0):
for i in range(101):
name, data = yield from next_message()
yield from asyncio.sleep(delay)
for i in range(3):
peer.add_task(async_listen(peer.new_get_next_message_f(), delay=60))
tasks = [
asyncio.Task(async_listen(peer.new_get_next_message_f(), delay=1))
for i in range(50)
]
peer.data_received(VERSION_MSG_BIN)
for i in range(100):
peer.data_received(VERACK_MSG_BIN)
# give everyone a chance to run (but no one finishes)
asyncio.get_event_loop().run_until_complete(
asyncio.wait(tasks, timeout=0.1))
assert len(peer.message_queues) == 53
# now let all 50 finish. They should be collected.
asyncio.get_event_loop().run_until_complete(asyncio.wait(tasks))
## you would think this number would be 3, but it's not.
## oh well. This is close enough.
assert len(peer.message_queues) <= 4
def test_eof():
peer = BitcoinPeerProtocol(MAGIC_HEADER)
pt = PeerTransport(None)
peer.connection_made(pt)
COUNT = 0
@asyncio.coroutine
def async_listen(next_message):
count = 0
try:
while True:
name, data = yield from next_message()
count += 1
except EOFError:
pass
assert count == 2
nonlocal COUNT
COUNT += 1
tasks = [
asyncio.Task(async_listen(peer.new_get_next_message_f()))
for i in range(50)
]
peer.data_received(VERSION_MSG_BIN)
peer.data_received(VERACK_MSG_BIN)
# end of stream
peer.connection_lost(None)
# give everyone a chance to run (but no one finishes)
asyncio.get_event_loop().run_until_complete(asyncio.wait(tasks))
assert COUNT == 50
