def __init__(self, chain_manager: ChainManager, sync_state: SyncState,
qrl_node):
self.master_mr = MessageReceipt()
self.pow = None
self.sync_state = sync_state
self._ntp = ntp
self._qrl_node = qrl_node
self._chain_manager = chain_manager
self._chain_manager.set_broadcast_tx(self.broadcast_tx)
self._syncing_enabled = False
self._target_channel = None
self._target_node_header_hash = None
self._last_requested_block_number = None
self._genesis_processed = False
self._peer_connections = []
self._txn_processor_running = False
self.peer_blockheight = dict()
reactor.callLater(config.user.monitor_connections_interval,
self.monitor_connections)
self.p2p_msg_priority = p2p_msg_priority
# Maintains the list of ips in the queue that can be tried to form a new p2p connection
self._peer_q = []
def __init__(self, chain_manager: ChainManager, sync_state: SyncState,
qrl_node):
self.master_mr = MessageReceipt()
self.pow = None
self.sync_state = sync_state
self._ntp = ntp
self._qrl_node = qrl_node
self._chain_manager = chain_manager
self._chain_manager.set_broadcast_tx(self.broadcast_tx)
self._syncing_enabled = False
self._target_peer = None
self._target_node_header_hash = None
self._last_requested_block_idx = None
self._genesis_processed = False
self._peer_connections = []
self._synced_peers_protocol = set()
self._txn_processor_running = False
self.peer_blockheight = dict()
reactor.callLater(config.user.monitor_connections_interval,
self.monitor_connections)
self.p2p_msg_priority = p2p_msg_priority
def __init__(self, buffered_chain: BufferedChain, sync_state: SyncState,
qrl_node: QRLNode):
# FIXME: Constructor signature is not consistent with other factory classes
self.master_mr = MessageReceipt()
self.pos = None
self.ntp = ntp
self.buffered_chain = buffered_chain
self.sync_state = sync_state
self.sync = 0
self.genesis_processed = False # FIXME: Accessed by every p2pprotocol instance
self.peer_connections = [
] # FIXME: Accessed by every p2pprotocol instance
self.synced_peers = set(
) # FIXME: Accessed by every p2pprotocol instance
self.qrl_node = qrl_node
self.txn_processor_running = False
self.bkmr_blocknumber = 0 # Blocknumber for which bkmr is being tracked
self.bkmr_priorityq = queue.PriorityQueue()
# Scheduled and cancel the call, just to initialize with IDelayedCall
self.bkmr_processor = reactor.callLater(1, lambda: None, pos=None)
self.bkmr_processor.cancel()
def test_register(self):
mr = MessageReceipt()
msg_hash = str2bin("asdf")
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
mr.register(msg_type, msg_hash, msg_obj)
def test_contains(self):
mr = MessageReceipt()
msg_hash = str2bin("hash_valid")
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
mr.register(msg_type, msg_hash, msg_obj)
self.assertTrue(mr.contains(msg_hash, msg_type))
def __init__(self,
chain_manager: ChainManager,
sync_state: SyncState,
qrl_node):
self.master_mr = MessageReceipt()
self.pow = None
self.sync_state = sync_state
self._ntp = ntp
self._qrl_node = qrl_node
self._chain_manager = chain_manager
self._chain_manager.set_broadcast_tx(self.broadcast_tx)
self._syncing_enabled = False
self._target_peer = None
self._target_node_header_hash = None
self._last_requested_block_idx = None
self._genesis_processed = False
self._peer_connections = []
self._synced_peers_protocol = set()
self._txn_processor_running = False
self.peer_blockheight = dict()
reactor.callLater(config.user.monitor_connections_interval, self.monitor_connections)
self.p2p_msg_priority = {
qrllegacy_pb2.LegacyMessage.VE: 0,
qrllegacy_pb2.LegacyMessage.PL: 0,
qrllegacy_pb2.LegacyMessage.PONG: 0,
######################
qrllegacy_pb2.LegacyMessage.MR: 2,
qrllegacy_pb2.LegacyMessage.SFM: 1,
qrllegacy_pb2.LegacyMessage.BK: 1,
qrllegacy_pb2.LegacyMessage.FB: 1,
qrllegacy_pb2.LegacyMessage.PB: 1,
qrllegacy_pb2.LegacyMessage.BH: 1,
############################
qrllegacy_pb2.LegacyMessage.TX: 1,
qrllegacy_pb2.LegacyMessage.MT: 1,
qrllegacy_pb2.LegacyMessage.TK: 1,
qrllegacy_pb2.LegacyMessage.TT: 1,
qrllegacy_pb2.LegacyMessage.LT: 1,
qrllegacy_pb2.LegacyMessage.SL: 1,
qrllegacy_pb2.LegacyMessage.EPH: 3,
qrllegacy_pb2.LegacyMessage.SYNC: 0,
qrllegacy_pb2.LegacyMessage.CHAINSTATE: 0,
qrllegacy_pb2.LegacyMessage.HEADERHASHES: 1,
qrllegacy_pb2.LegacyMessage.P2P_ACK: 0,
}
def test_register_overflow(self):
mr = MessageReceipt()
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
config.dev.message_q_size = 4
for i in range(config.dev.message_q_size * 2):
msg_hash = str2bin(str(i))
mr.register(msg_type, msg_hash, msg_obj)
self.assertEqual(len(mr._hash_msg), config.dev.message_q_size)
def test_add_contains_remove(self):
mr = MessageReceipt()
# FIXME: Hashes being are treated as strings
msg_hash = str2bin("hash_valid")
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
peer = '127.0.0.1'
mr.register(msg_type, msg_hash, msg_obj)
mr.add_peer(msg_hash, msg_type, peer)
self.assertTrue(mr.contains(msg_hash, msg_type))
self.assertFalse(mr.contains(b'hash_invalid', msg_type))
def test_create(self):
mr = MessageReceipt()
self.assertIsNotNone(mr)
self.assertEqual(mr.allowed_types, [LegacyMessage.TX,
LegacyMessage.LT,
LegacyMessage.EPH,
LegacyMessage.BK,
LegacyMessage.MT,
LegacyMessage.TK,
LegacyMessage.TT,
LegacyMessage.SL,
LegacyMessage.MC,
LegacyMessage.MS,
LegacyMessage.MV])
def __init__(self, chain, p2pFactory, nodeState, ntp):
self.master_mr = MessageReceipt()
self.nodeState = nodeState
self.ntp = ntp
self.chain = chain
self.r1_time_diff = defaultdict(list)
self.r2_time_diff = defaultdict(list)
self.incoming_blocks = {}
self.last_pos_cycle = 0
self.last_selected_height = 0
self.last_bk_time = 0
self.last_pb_time = 0
self.next_header_hash = None
self.next_block_number = None
self.fmbh_allowed_peers = {}
self.fmbh_blockhash_peers = {}
self.p2pFactory = p2pFactory
def test_create(self):
mr = MessageReceipt()
self.assertIsNotNone(mr)
self.assertEqual(mr.allowed_types, ['TX', 'ST', 'BK', 'DT'])
