def start():
with open(DATA_FILE) as fin:
blocks = fin.read().strip().split('\n')
for block in blocks[:1]:
block = json.loads(block)
txs = block['txs']
n_txs = len(txs)
bytes_pushed['n_txs'] = n_txs
logging.info("Read %d transactions" % n_txs)
logging.info(
"Selecting %d transactions at random for inclusion in mempool"
% (MEMPOOL_PCT * n_txs))
# random.shuffle(txs)
n_selected = 0
for i, tx in enumerate(txs):
if n_selected < MEMPOOL_PCT * n_txs:
selected_txs.append(tx)
n_selected += 1
else:
# print("Excluding ", tx['hash'])
skipped_txs_ids.add(tx['hash'].encode('utf-8'))
bytes_pushed['txs'].append(len(tx_to_bytes(tx)))
skipped_txs.append(tx)
bytes_pushed['cmpct'] = n_txs * 6 + 10 + 80
logging.info("Skipped %d transactions" % len(skipped_txs))
client = network.GeventNetworkClient()
client.register_handler('inv', inv_handler)
client.register_handler('graphene', graphene_handler)
network.ClientBehavior(client)
client.listen(address, port)
client.run_forever()
def start():
client = network.GeventNetworkClient()
client.register_handler('inv', on_inv_received)
client.register_handler('tx', on_tx_received)
client.register_handler('block', on_block_received)
network.ClientBehavior(client)
client.connect(('seed.bitcoinstats.com', 8333))
client.run_forever()
def test_client_behavior_init(self):
network.ClientBehavior(self.network_client)
args = self.network_client.register_handler.call_args_list
types = [a[0][0] for a in args]
# Ensure we have at least handlers for the connection established event
# and an incoming version message
self.assertTrue(network.ConnectionEstablishedEvent.type in types)
self.assertTrue(messages.VersionPacket.type in types)
def test_client_behavior_on_connect(self):
b = network.ClientBehavior(self.network_client)
message = mock.Mock(type=network.ConnectionEstablishedEvent.type)
# We should not send anything on new incoming connections
self.connection.incoming = True
b.on_connect(self.connection, message)
self.assertFalse(self.connection.send.called)
# On outgoing connections we initiate the handshake
self.connection.incoming = False
b.on_connect(self.connection, message)
self.assertTrue(self.connection.send.called)
def start():
with open(DATA_FILE) as fin:
blocks = fin.read().strip().split('\n')
for block in blocks[:1]:
block = json.loads(block)
txs = block['txs']
n_txs = len(txs)
logging.info("Read %d transactions" % n_txs)
# random.shuffle(txs)
n_selected = 0
selected_txs.extend(txs)
client = network.GeventNetworkClient()
client.register_handler('getdata', getdata_handler)
client.register_handler('verack', verack_handler)
network.ClientBehavior(client)
client.connect((peer_address, peer_port))
client.run_forever()
def test_client_behavior_on_version(self):
b = network.ClientBehavior(self.network_client)
b.send_version = mock.Mock()
b.send_verack = mock.Mock()
# This is an outgoing connection, so we should send just one verack
self.connection.incoming = False
b.on_version(self.connection, mock.Mock())
self.assertFalse(b.send_version.called)
self.assertEquals(b.send_verack.call_count, 1)
# Now on an incoming connection, we also respond with a version
self.connection.incoming = True
b.send_verack.reset()
b.on_version(self.connection, mock.Mock())
self.assertTrue(b.send_verack.call_count, 1)
self.assertTrue(b.send_version.call_count, 1)
def test_client_behavior_send_verack(self):
b = network.ClientBehavior(self.network_client)
b.send_verack(self.connection)
self.connection.send.assert_called_with('verack', '')
self.assertEquals(self.connection.send.call_count, 1)