def test_in_flight_max(self):
self.log.info(
"Test that we don't request more than {} transactions from any peer, every {} minutes"
.format(MAX_GETDATA_IN_FLIGHT, TX_EXPIRY_INTERVAL / 60))
txids = [i for i in range(MAX_GETDATA_IN_FLIGHT + 2)]
p = self.nodes[0].p2ps[0]
with mininode_lock:
p.tx_getdata_count = 0
p.send_message(msg_inv([CInv(t=1, h=i) for i in txids]))
wait_until(lambda: p.tx_getdata_count >= MAX_GETDATA_IN_FLIGHT,
lock=mininode_lock)
with mininode_lock:
assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT)
self.log.info(
"Now check that if we send a NOTFOUND for a transaction, we'll get one more request"
)
p.send_message(msg_notfound(vec=[CInv(t=1, h=txids[0])]))
wait_until(lambda: p.tx_getdata_count >= MAX_GETDATA_IN_FLIGHT + 1,
timeout=10,
lock=mininode_lock)
with mininode_lock:
assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT + 1)
WAIT_TIME = TX_EXPIRY_INTERVAL // 2 + TX_EXPIRY_INTERVAL
self.log.info(
"if we wait about {} minutes, we should eventually get more requests"
.format(WAIT_TIME / 60))
self.nodes[0].setmocktime(int(time.time() + WAIT_TIME))
wait_until(lambda: p.tx_getdata_count == MAX_GETDATA_IN_FLIGHT + 2)
self.nodes[0].setmocktime(0)
def test_notfound_fallback(self):
self.log.info('Check that notfounds will select another peer for download immediately')
WTXID = 0xffdd
peer1 = self.nodes[0].add_p2p_connection(TestP2PConn())
peer2 = self.nodes[0].add_p2p_connection(TestP2PConn())
for p in [peer1, peer2]:
p.send_message(msg_inv([CInv(t=MSG_WTX, h=WTXID)]))
# One of the peers is asked for the tx
peer2.wait_until(lambda: sum(p.tx_getdata_count for p in [peer1, peer2]) == 1)
with p2p_lock:
peer_notfound, peer_fallback = (peer1, peer2) if peer1.tx_getdata_count == 1 else (peer2, peer1)
assert_equal(peer_fallback.tx_getdata_count, 0)
peer_notfound.send_and_ping(msg_notfound(vec=[CInv(MSG_WTX, WTXID)])) # Send notfound, so that fallback peer is selected
peer_fallback.wait_until(lambda: peer_fallback.tx_getdata_count >= 1, timeout=1)
def test_notfound_fallback(self, context):
self.log.info(
'Check that notfounds will select another peer for download immediately'
)
peer1 = self.nodes[0].add_p2p_connection(context.p2p_conn())
peer2 = self.nodes[0].add_p2p_connection(context.p2p_conn())
for p in [peer1, peer2]:
p.send_message(msg_inv([CInv(t=context.inv_type, h=0xffdd)]))
# One of the peers is asked for the data
peer2.wait_until(
lambda: sum(p.getdata_count for p in [peer1, peer2]) == 1)
with p2p_lock:
peer_notfound, peer_fallback = (
peer1, peer2) if peer1.getdata_count == 1 else (peer2, peer1)
assert_equal(peer_fallback.getdata_count, 0)
# Send notfound, so that fallback peer is selected
peer_notfound.send_and_ping(
msg_notfound(vec=[CInv(context.inv_type, 0xffdd)]))
peer_fallback.wait_until(lambda: peer_fallback.getdata_count >= 1)
with p2p_lock:
assert_equal(peer_fallback.getdata_count, 1)
def test_spurious_notfound(self):
self.log.info('Check that spurious notfound is ignored')
self.nodes[0].p2ps[0].send_message(msg_notfound(vec=[CInv(MSG_TX, 1)]))
def test_spurious_notfound(self, context):
self.log.info('Check that spurious notfound is ignored')
self.nodes[0].p2ps[0].send_message(
msg_notfound(vec=[CInv(context.inv_type, 1)]))
