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