def test_get_ping_latencies_one_country(self, mock_get_ping_latencies): relays = [ OutboundPeerModel("34.227.149.148", 1609, node_id="0", attributes={"country": "China"}), OutboundPeerModel("35.198.90.230", 1609, node_id="1", attributes={"country": "China"}), OutboundPeerModel("52.221.211.38", 1609, node_id="2", attributes={"country": "China"}), OutboundPeerModel("34.245.23.125", 1609, node_id="3", attributes={"country": "EU"}), OutboundPeerModel("34.238.245.201", 1609, node_id="4", attributes={"country": "EU"}), ] mock_get_ping_latencies.return_value = [ NodeLatencyInfo(relays[4], 100), NodeLatencyInfo(relays[1], 101), NodeLatencyInfo(relays[3], 109), NodeLatencyInfo(relays[2], 120), NodeLatencyInfo(relays[0], 130), ] best_relays = network_latency.get_best_relays_by_ping_latency_one_per_country( relays, 1) self.assertEqual(1, len(best_relays)) self.assertEqual("1", best_relays[0].node_id)
def test_on_updated_peers(self): self.node.connection_pool.add(self.fileno, self.ip, self.port, self.connection) self.node.opts.outbound_peers = [ OutboundPeerModel("222.222.222.222", 2000, node_type=NodeType.GATEWAY) ] self.node.outbound_peers = [ OutboundPeerModel("111.111.111.111", 1000, node_type=NodeType.GATEWAY), OutboundPeerModel("222.222.222.222", 2000, node_type=NodeType.GATEWAY), OutboundPeerModel(self.ip, self.port, node_type=NodeType.GATEWAY) ] outbound_peer_models = [ OutboundPeerModel("111.111.111.111", 1000, node_type=NodeType.GATEWAY) ] self.node.on_updated_peers(outbound_peer_models) self.assertEqual(outbound_peer_models, self.node.outbound_peers) self._assert_socket_disconnected(False)
def test_get_ping_latencies_in_threads(self): relays = [ OutboundPeerModel("34.227.149.148", 1609, node_id="0", attributes={"country": "China"}), OutboundPeerModel("35.198.90.230", 1609, node_id="1", attributes={"country": "China"}), OutboundPeerModel("52.221.211.38", 1609, node_id="2", attributes={"country": "China"}), OutboundPeerModel("34.245.23.125", 1609, node_id="3", attributes={"country": "China"}), OutboundPeerModel("34.238.245.201", 1609, node_id="4", attributes={"country": "China"}), ] start = time.time() network_latency.get_best_relays_by_ping_latency_one_per_country( relays, 1) end = time.time() - start self.assertTrue(end < constants.PING_TIMEOUT_S + 1)
def test_get_best_relay_sorted_relays(self): relays = [ OutboundPeerModel("34.227.149.148", 1609, node_id="0", attributes={"country": "China"}), OutboundPeerModel("35.198.90.230", 1609, node_id="1", attributes={"country": "China"}), OutboundPeerModel("52.221.211.38", 1609, node_id="2", attributes={"country": "China"}), OutboundPeerModel("34.245.23.125", 1609, node_id="3", attributes={"country": "China"}), OutboundPeerModel("34.238.245.201", 1609, node_id="4", attributes={"country": "China"}), ] sorted_relays_ping_latency = [ NodeLatencyInfo(relays[0], 100), NodeLatencyInfo(relays[1], 101), NodeLatencyInfo(relays[2], 109), NodeLatencyInfo(relays[3], 120), NodeLatencyInfo(relays[4], 130), ] best_relay = network_latency._get_best_relay_latencies_one_per_country( sorted_relays_ping_latency, relays, 1) self.assertEqual("0", best_relay[0].node.node_id)
def of_type(gateway_class: Type[AbstractGatewayNode], opts: GatewayOpts) -> FullGatewayInfo: # probably pyre bug # pyre-fixme[45]: Cannot instantiate abstract class `AbstractGatewayNode`. gateway = gateway_class(opts, MockNodeSSLService(gateway_class.NODE_TYPE, MagicMock())) gateway.requester = MagicMock() blockchain_fileno = 1 relay_fileno = 2 gateway_fileno = 3 blockchain_socket = MockSocketConnection(file_no=blockchain_fileno, ip_address=constants.LOCALHOST, port=7000) relay_socket = MockSocketConnection(file_no=relay_fileno, ip_address=constants.LOCALHOST, port=7001) gateway_socket = MockSocketConnection(file_no=gateway_fileno, ip_address=constants.LOCALHOST, port=7002) gateway.on_connection_added(blockchain_socket) gateway.peer_relays.add(OutboundPeerModel(constants.LOCALHOST, 7001)) gateway.on_connection_added(relay_socket) gateway.peer_gateways.add(OutboundPeerModel(constants.LOCALHOST, 7002)) gateway.on_connection_added(gateway_socket) blockchain_connection = gateway.connection_pool.get_by_fileno(blockchain_fileno) assert blockchain_connection is not None assert isinstance(blockchain_connection, AbstractGatewayBlockchainConnection) relay_connection = gateway.connection_pool.get_by_fileno(relay_fileno) assert relay_connection is not None assert isinstance(relay_connection, AbstractRelayConnection) gateway_connection = gateway.connection_pool.get_by_fileno(gateway_fileno) assert gateway_connection is not None assert isinstance(gateway_connection, GatewayConnection) gateway.on_blockchain_connection_ready(blockchain_connection) blockchain_connection.state |= ConnectionState.ESTABLISHED relay_connection.state |= ConnectionState.ESTABLISHED gateway_connection.state |= ConnectionState.ESTABLISHED # clear output buffers if blockchain_connection.outputbuf.length: blockchain_connection.advance_sent_bytes(blockchain_connection.outputbuf.length) if relay_connection.outputbuf.length: relay_connection.advance_sent_bytes(relay_connection.outputbuf.length) if gateway_connection.outputbuf.length: gateway_connection.advance_sent_bytes(gateway_connection.outputbuf.length) return FullGatewayInfo( gateway, blockchain_fileno, relay_fileno, gateway_fileno, blockchain_socket, relay_socket, gateway_socket, blockchain_connection, relay_connection, gateway_connection )
def test_parse_peer_string(self): peers = main.parse_peer_string("127.0.0.1:8000,192.168.1.1:80001") self.assertEqual(2, len(peers)) self.assertEqual(OutboundPeerModel("127.0.0.1", 8000), peers[0]) self.assertEqual(OutboundPeerModel("192.168.1.1", 80001), peers[1]) peers2 = main.parse_peer_string("127.0.0.1:8000, 192.168.1.1:80001") self.assertEqual(peers, peers2)
def test_relay_connection_update(self): relay_connections = [ OutboundPeerModel(LOCALHOST, 8001, node_type=NodeType.RELAY_BLOCK), OutboundPeerModel(LOCALHOST, 9001, node_type=NodeType.RELAY_BLOCK) ] network_latency.get_best_relays_by_ping_latency_one_per_country = MagicMock(return_value=[relay_connections[0]]) opts = gateway_helpers.get_gateway_opts(8000, split_relays=True, include_default_btc_args=True) if opts.use_extensions: helpers.set_extensions_parallelism() node = GatewayNode(opts) node.enqueue_connection = MagicMock() node._register_potential_relay_peers( node._find_best_relay_peers( network_latency.get_best_relays_by_ping_latency_one_per_country() ) ) self.assertEqual(1, len(node.peer_relays)) self.assertEqual(1, len(node.peer_transaction_relays)) self.assertEqual(8002, next(iter(node.peer_transaction_relays)).port) node.enqueue_connection.assert_has_calls([ call(LOCALHOST, 8001, ConnectionType.RELAY_BLOCK), call(LOCALHOST, 8002, ConnectionType.RELAY_TRANSACTION), ], any_order=True) node.on_connection_added(MockSocketConnection(1, ip_address=LOCALHOST, port=8001, node=node)) self._check_connection_pool(node, 1, 1, 0, 1) node.on_connection_added(MockSocketConnection(2, ip_address=LOCALHOST, port=8002, node=node)) self._check_connection_pool(node, 2, 1, 1, 2) network_latency.get_best_relays_by_ping_latency_one_per_country = MagicMock(return_value=[relay_connections[1]]) node._register_potential_relay_peers( node._find_best_relay_peers( network_latency.get_best_relays_by_ping_latency_one_per_country() ) ) self.assertEqual(1, len(node.peer_relays)) self.assertEqual(1, len(node.peer_transaction_relays)) self.assertEqual(9001, next(iter(node.peer_relays)).port) self.assertEqual(9002, next(iter(node.peer_transaction_relays)).port) node.enqueue_connection.assert_has_calls([ call(LOCALHOST, 9001, ConnectionType.RELAY_BLOCK), call(LOCALHOST, 9002, ConnectionType.RELAY_TRANSACTION), ], any_order=True) node.on_connection_added(MockSocketConnection(3, ip_address=LOCALHOST, port=9001)) node.on_connection_added(MockSocketConnection(4, ip_address=LOCALHOST, port=9002)) for conn in node.connection_pool.get_by_connection_types([ConnectionType.RELAY_BLOCK]): self.assertEqual(9001, conn.peer_port) for conn in node.connection_pool.get_by_connection_types([ConnectionType.RELAY_TRANSACTION]): self.assertEqual(9002, conn.peer_port)
def test_get_ping_latencies_in_threads(self): relays = [ OutboundPeerModel("34.227.149.148", node_id="0"), OutboundPeerModel("35.198.90.230", node_id="1"), OutboundPeerModel("52.221.211.38", node_id="2"), OutboundPeerModel("34.245.23.125", node_id="3"), OutboundPeerModel("34.238.245.201", node_id="4") ] start = time.time() network_latency.get_best_relay_by_ping_latency(relays) end = time.time() - start self.assertTrue(end < constants.PING_TIMEOUT_S + 1)
async def test_gateway_peer_get_more_peers_when_too_few_gateways(self): peer_gateways = [ OutboundPeerModel(LOCALHOST, 8001, node_type=NodeType.EXTERNAL_GATEWAY), ] opts = gateway_helpers.get_gateway_opts(8000, peer_gateways=peer_gateways, min_peer_gateways=2) if opts.use_extensions: helpers.set_extensions_parallelism() node = GatewayNode(opts) node.peer_gateways.add( OutboundPeerModel(LOCALHOST, 8002, node_type=NodeType.EXTERNAL_GATEWAY)) sdn_http_service.fetch_gateway_peers = MagicMock(return_value=[ OutboundPeerModel( LOCALHOST, 8003, "12345", node_type=NodeType.EXTERNAL_GATEWAY) ]) node.on_connection_added( MockSocketConnection(node=node, ip_address=LOCALHOST, port=8002)) not_cli_peer_conn = node.connection_pool.get_by_ipport(LOCALHOST, 8002) not_cli_peer_conn.mark_for_close(False) time.time = MagicMock(return_value=time.time() + constants.SDN_CONTACT_RETRY_SECONDS + 1) sdn_http_service.fetch_gateway_peers.assert_not_called() node.alarm_queue.fire_alarms() sdn_http_service.fetch_gateway_peers.assert_has_calls( [call(node.opts.node_id, False)]) self.assertEqual( 2, len([ node for node in node.outbound_peers if node.node_type in NodeType.GATEWAY_TYPE ])) self.assertIn( OutboundPeerModel(LOCALHOST, 8001, node_type=NodeType.EXTERNAL_GATEWAY), node.outbound_peers) self.assertIn( OutboundPeerModel(LOCALHOST, 8003, "12345", node_type=NodeType.EXTERNAL_GATEWAY), node.outbound_peers)
async def setUp(self) -> None: account_model = BdnAccountModelBase( "account_id", "account_name", "fake_certificate", new_transaction_streaming=BdnServiceModelConfigBase( expire_date=date(2999, 1, 1).isoformat() ) ) gateway_opts = gateway_helpers.get_gateway_opts(8000, ws=True) gateway_opts.set_account_options(account_model) self.gateway_node = MockGatewayNode(gateway_opts) self.gateway_node.NODE_TYPE = NodeType.INTERNAL_GATEWAY self.transaction_streamer_peer = OutboundPeerModel("127.0.0.1", 8006, node_type=NodeType.INTERNAL_GATEWAY) self.gateway_node.requester = ThreadedRequestService( "mock_thread_service", self.gateway_node.alarm_queue, constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S ) self.gateway_node.requester.start() self.server = WsServer( constants.LOCALHOST, 8005, self.gateway_node.feed_manager, self.gateway_node ) self.ws_uri = f"ws://{constants.LOCALHOST}:8005" await self.server.start()
async def setUp(self) -> None: self.feed_service_model = FeedServiceModelBase( allow_filtering=True, available_fields=["all"]) self.base_feed_service_model = BdnFeedServiceModelConfigBase( expire_date="2999-01-01", feed=self.feed_service_model) account_model = BdnAccountModelBase( "account_id", "account_name", "fake_certificate", tier_name="Developer", new_transaction_streaming=self.base_feed_service_model, new_pending_transaction_streaming=self.base_feed_service_model, on_block_feed=self.base_feed_service_model, transaction_receipts_feed=self.base_feed_service_model) gateway_opts = gateway_helpers.get_gateway_opts(8000, ws=True) gateway_opts.set_account_options(account_model) self.gateway_node = MockGatewayNode(gateway_opts) self.gateway_node.NODE_TYPE = NodeType.INTERNAL_GATEWAY self.transaction_streamer_peer = OutboundPeerModel( "127.0.0.1", 8006, node_type=NodeType.INTERNAL_GATEWAY) self.gateway_node.requester = ThreadedRequestService( "mock_thread_service", self.gateway_node.alarm_queue, constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S, ) self.gateway_node.requester.start() self.server = WsServer(constants.LOCALHOST, 8005, self.gateway_node.feed_manager, self.gateway_node) self.ws_uri = f"ws://{constants.LOCALHOST}:8005" await self.server.start() self.gateway_node.get_ws_server_status = MagicMock(return_value=True)
def test_gateway_peer_never_destroy_cli_peer(self): peer_gateways = [OutboundPeerModel(LOCALHOST, 8001)] opts = gateway_helpers.get_gateway_opts(8000, peer_gateways=peer_gateways) if opts.use_extensions: helpers.set_extensions_parallelism() node = GatewayNode(opts) node.enqueue_connection = MagicMock() node.alarm_queue.register_alarm = MagicMock() node.alarm_queue.register_approx_alarm = MagicMock() mock_socket = MockSocketConnection(7, node, ip_address=LOCALHOST, port=8001) node.on_connection_added(mock_socket) cli_peer_conn = node.connection_pool.get_by_ipport(LOCALHOST, 8001) node.num_retries_by_ip[(LOCALHOST, 8001)] = MAX_CONNECT_RETRIES cli_peer_conn.state = ConnectionState.CONNECTING node._connection_timeout(cli_peer_conn) self.assertFalse(mock_socket.alive) node.on_connection_closed(mock_socket.fileno()) # timeout is fib(3) == 3 node.alarm_queue.register_alarm.assert_has_calls([ call(3, node._retry_init_client_socket, LOCALHOST, 8001, ConnectionType.EXTERNAL_GATEWAY) ]) node._retry_init_client_socket(LOCALHOST, 8001, ConnectionType.EXTERNAL_GATEWAY) self.assertEqual(MAX_CONNECT_RETRIES + 1, node.num_retries_by_ip[(LOCALHOST, 8001)])
def initialize_split_relay_node(): relay_connections = [ OutboundPeerModel(LOCALHOST, 8001, node_type=NodeType.RELAY_BLOCK) ] network_latency.get_best_relays_by_ping_latency_one_per_country = MagicMock( return_value=[relay_connections[0]]) opts = gateway_helpers.get_gateway_opts(8000, split_relays=True, include_default_btc_args=True) if opts.use_extensions: helpers.set_extensions_parallelism() node = GatewayNode(opts) node.enqueue_connection = MagicMock() node._register_potential_relay_peers( node._find_best_relay_peers( network_latency.get_best_relays_by_ping_latency_one_per_country())) node.enqueue_connection.assert_has_calls([ call(LOCALHOST, 8001, ConnectionType.RELAY_BLOCK), call(LOCALHOST, 8002, ConnectionType.RELAY_TRANSACTION), ], any_order=True) node.on_connection_added( MockSocketConnection(1, node, ip_address=LOCALHOST, port=8001)) node.on_connection_added( MockSocketConnection(2, node, ip_address=LOCALHOST, port=8002)) node.alarm_queue = AlarmQueue() node.enqueue_connection.reset_mock() return node
def gateway_2_opts(self): return gateway_helpers.get_gateway_opts( 9001, peer_gateways=[OutboundPeerModel(LOCALHOST, 7002)], include_default_btc_args=True, encrypt_blocks=False, sync_tx_service=False)
def test_better_relays_from_sdn(self): self.gateway_node.peer_relays = { OutboundPeerModel("2.1.1.1", 1609, node_type=NodeType.RELAY_BLOCK), OutboundPeerModel("2.1.1.2", 1609, node_type=NodeType.RELAY_BLOCK), } self.gateway_node.peer_transaction_relays = { OutboundPeerModel("2.1.1.1", 1610, node_type=NodeType.RELAY_TRANSACTION), OutboundPeerModel("2.1.1.2", 1610, node_type=NodeType.RELAY_TRANSACTION), } self._run_connection_process() self._assert_connects_to_relays(0) self._assert_reevaluation_alarm_set()
def test_make_sync_request(self): other_connections = [] for i in range(2, 5): fileno = i port = 8000 + i connection = MockConnection(fileno, (LOCALHOST, port), self.node) connection.state |= ConnectionState.ESTABLISHED connection.enqueue_msg = MagicMock() self.node.connection_pool.add(fileno, LOCALHOST, port, connection) other_connections.append(connection) preferred_connection = other_connections[0] self.node.peer_gateways.add(OutboundPeerModel(LOCALHOST, 8002)) request = GetHeadersBtcMessage(self.MAGIC, self.VERSION, self.HASHES, self.HASH2) self.blockchain_sync_service.make_sync_request(request.command(), request) request_message = BlockchainSyncRequestMessage(request.command(), request.rawbytes()) preferred_connection.enqueue_msg.assert_called_once_with( request_message, prepend=True) time.time = MagicMock( return_value=time.time() + gateway_constants.BLOCKCHAIN_SYNC_BROADCAST_DELAY_S) self.node.alarm_queue.fire_alarms() self.assertIn(request_message, self.node.broadcast_messages)
def test_remote_sync_response_broadcast_response(self): self.node.send_msg_to_node = MagicMock() not_responding_connection = GatewayConnection(MockSocketConnection(1), (LOCALHOST, 8002), self.node) not_responding_connection.enqueue_msg = MagicMock() not_responding_connection.state |= ConnectionState.ESTABLISHED responding_connection = GatewayConnection(MockSocketConnection(2), (LOCALHOST, 8003), self.node) responding_connection.enqueue_msg = MagicMock() responding_connection.state |= ConnectionState.ESTABLISHED self.node.connection_pool.add(1, LOCALHOST, 8002, not_responding_connection) self.node.connection_pool.add(2, LOCALHOST, 8003, responding_connection) self.node.peer_gateways.add( OutboundPeerModel(LOCALHOST, 8002, is_internal=True)) self.node.peer_gateways.add( OutboundPeerModel(LOCALHOST, 8003, is_internal=False)) request = GetHeadersBtcMessage(self.MAGIC, self.VERSION, self.HASHES, self.HASH2) self.blockchain_sync_service.make_sync_request(request.command(), request) not_responding_connection.enqueue_msg.assert_called_once() responding_connection.enqueue_msg.assert_not_called() time.time = MagicMock( return_value=time.time() + gateway_constants.BLOCKCHAIN_SYNC_BROADCAST_DELAY_S) self.node.alarm_queue.fire_alarms() self.assertEqual(1, len(self.node.broadcast_messages)) remote_response = HeadersBtcMessage(self.MAGIC, headers=[]) self.blockchain_sync_service.process_remote_sync_response( remote_response.command(), remote_response, responding_connection) self.node.send_msg_to_node.assert_called_once_with(remote_response) self.assertEqual( 0, len(self.blockchain_sync_service. awaiting_local_callback_connections)) self.assertEqual(responding_connection, self.node.get_preferred_gateway_connection())
def reinitialize_gateways(self, opts1, opts2): node_ssl_service = MockNodeSSLService(BtcGatewayNode.NODE_TYPE, MagicMock()) self.node1 = BtcGatewayNode(opts1, node_ssl_service) self.node1.opts.has_fully_updated_tx_service = True self.node1.requester.send_threaded_request = MagicMock() self.node2 = BtcGatewayNode(opts2, node_ssl_service) self.node2.opts.has_fully_updated_tx_service = True self.node2.requester.send_threaded_request = MagicMock() self.node1.peer_gateways = {OutboundPeerModel(LOCALHOST, 7002)} self.node1.peer_relays = {OutboundPeerModel(LOCALHOST, 7001)} self.node2.peer_gateways = {OutboundPeerModel(LOCALHOST, 7002)} self.node2.peer_relays = {OutboundPeerModel(LOCALHOST, 7001)} self.blockchain_fileno = 1 self.relay_fileno = 2 self.gateway_fileno = 3 self.blockchain_connection = MockSocketConnection( self.blockchain_fileno, self.node1, ip_address=LOCALHOST, port=7000 ) self.relay_connection = MockSocketConnection(self.relay_fileno, self.node1, ip_address=LOCALHOST, port=7001) self.gateway_connection = MockSocketConnection(self.gateway_fileno, self.node1, ip_address=LOCALHOST, port=7002) # add node1 connections self.node1.on_connection_added(self.blockchain_connection) self.node1.on_connection_added(self.relay_connection) self.node1.on_connection_added(self.gateway_connection) # add node 2 connections self.node2.on_connection_added(self.blockchain_connection) self.node2.on_connection_added(self.relay_connection) self.node2.on_connection_added(self.gateway_connection) # initialize node1 connections helpers.receive_node_message(self.node1, self.blockchain_fileno, btc_version_message().rawbytes()) helpers.receive_node_message(self.node1, self.relay_fileno, hello_message().rawbytes()) helpers.receive_node_message(self.node1, self.relay_fileno, AckMessage().rawbytes()) helpers.receive_node_message(self.node1, self.gateway_fileno, AckMessage().rawbytes()) # initialize node2 connections helpers.receive_node_message(self.node2, self.blockchain_fileno, btc_version_message().rawbytes()) helpers.receive_node_message(self.node2, self.relay_fileno, hello_message().rawbytes()) helpers.receive_node_message(self.node2, self.relay_fileno, AckMessage().rawbytes()) helpers.receive_node_message(self.node2, self.gateway_fileno, AckMessage().rawbytes()) self.clear_all_buffers()
def test_on_updated_peers(self): self.node.connection_pool.add(self.fileno, self.ip, self.port, self.connection) self.node.opts.outbound_peers = [ OutboundPeerModel("222.222.222.222", 2000) ] self.node.outbound_peers = [ OutboundPeerModel("111.111.111.111", 1000), OutboundPeerModel("222.222.222.222", 2000), OutboundPeerModel(self.ip, self.port) ] outbound_peer_models = [OutboundPeerModel("111.111.111.111", 1000)] self.node.on_updated_peers(outbound_peer_models) self.assertEqual(outbound_peer_models, self.node.outbound_peers) self.assertIn((self.fileno, False), self.node.disconnect_queue)
def test_get_best_relay_sorted_relays(self): relays = [ OutboundPeerModel("34.227.149.148", node_id="0"), OutboundPeerModel("35.198.90.230", node_id="1"), OutboundPeerModel("52.221.211.38", node_id="2"), OutboundPeerModel("34.245.23.125", node_id="3"), OutboundPeerModel("34.238.245.201", node_id="4") ] sorted_relays_ping_latency = [ NodeLatencyInfo(relays[0], 100), NodeLatencyInfo(relays[1], 101), NodeLatencyInfo(relays[2], 109), NodeLatencyInfo(relays[3], 120), NodeLatencyInfo(relays[4], 130) ] best_relay = network_latency._get_best_relay( sorted_relays_ping_latency, relays) self.assertEqual("0", best_relay.node.node_id)
def test_get_ping_latency(self): relay = OutboundPeerModel("34.227.149.148", 1609, node_id="0", attributes={"country": "China"}) start = time.time() network_latency.get_best_relays_by_ping_latency_one_per_country( [relay], 1) end = time.time() - start self.assertTrue(end < constants.PING_TIMEOUT_S + 1)
async def setUp(self) -> None: await super().setUp() self.gateway_node.NODE_TYPE = NodeType.INTERNAL_GATEWAY self.transaction_streamer_peer = OutboundPeerModel( "127.0.0.1", 8006, node_type=NodeType.INTERNAL_GATEWAY) self.feed_manager = FeedManager(self.gateway_node) self.server = IpcServer("bxgateway.ipc", self.feed_manager, self.gateway_node, Case.SNAKE) self.ipc_path = self.server.ipc_path await self.server.start()
def opts_defaults(cls, opts) -> Namespace: opts = super().opts_defaults(opts) if "blockchain_networks" not in opts: # node_cache dependencies should be untangled # parameter to call `node_cache.read` but got `Namespace` cache_file_info = node_cache.read(opts) if cache_file_info is not None: opts.blockchain_networks = cache_file_info.blockchain_networks opts.outbound_peers = set(opts.peer_gateways).union(opts.peer_relays) if opts.connect_to_remote_blockchain and opts.remote_blockchain_ip and opts.remote_blockchain_port: opts.remote_blockchain_peer = OutboundPeerModel( opts.remote_blockchain_ip, opts.remote_blockchain_port) else: opts.remote_blockchain_peer = None opts.account_model = None opts.is_docker = os.path.exists("/.dockerenv") # Request streaming from BDN if ws server is turned on opts.request_remote_transaction_streaming = opts.ws # set by node runner opts.blockchain_block_interval = 0 opts.blockchain_ignore_block_interval_count = 0 opts.blockchain_block_recovery_timeout_s = 0 opts.blockchain_block_hold_timeout_s = 0 opts.enable_network_content_logs = False opts.should_update_source_version = False # set after initialization opts.peer_transaction_relays = [] if opts.blockchain_protocol: opts.blockchain_protocol = opts.blockchain_protocol.lower() else: opts.blockchain_protocol = None if not opts.blockchain_peers: opts.blockchain_peers = set() if opts.blockchain_peers_file: cls.read_blockchain_peers_from_file(opts) if not opts.cookie_file_path: opts.cookie_file_path = gateway_constants.COOKIE_FILE_PATH_TEMPLATE.format( "{}_{}".format(get_sdn_hostname(opts.sdn_url), opts.external_ip)) opts.min_peer_relays_count = 1 return opts
def test_get_ping_latencies_current_relay_within_threshold_of_fastest( self, mock_get_ping_latencies): current_relay = OutboundPeerModel("52.221.211.38", 1609, node_id="2", attributes={"country": "EU"}) fastest_relay = OutboundPeerModel("35.198.90.230", 1609, node_id="1", attributes={"country": "EU"}) first_recommended_relay = OutboundPeerModel( "34.227.149.148", 1609, node_id="0", attributes={"country": "EU"}) self.peer_relays = set() self.peer_relays.add(current_relay) relays = [ first_recommended_relay, fastest_relay, current_relay, OutboundPeerModel("34.245.23.125", 1609, node_id="3", attributes={"country": "China"}), OutboundPeerModel("34.238.245.201", 1609, node_id="4", attributes={"country": "China"}), ] mock_get_ping_latencies.return_value = [ NodeLatencyInfo(relays[4], 100), NodeLatencyInfo(fastest_relay, 8), NodeLatencyInfo(relays[3], 109), NodeLatencyInfo(current_relay, 10), NodeLatencyInfo(first_recommended_relay, 9), ] best_relays = network_latency.get_best_relays_by_ping_latency_one_per_country( relays, 2, self.peer_relays) self.assertEqual(2, len(best_relays)) self.assertEqual("2", best_relays[0].node_id) self.assertEqual("3", best_relays[1].node_id)
def test_get_best_relay_less_relays(self): relays = [ OutboundPeerModel("34.227.149.148", 1609, node_id="0", attributes={"country": "China"}) ] sorted_relays_ping_latency = [NodeLatencyInfo(relays[0], 100)] best_relays = network_latency._get_best_relay_latencies_one_per_country( sorted_relays_ping_latency, relays, 2) self.assertEqual(1, len(best_relays)) self.assertEqual("0", best_relays[0].node.node_id)
def parse_peer_string(peer_string): """ Parses string of format ip:port,ip:port,ip:port,... to list of OutboundPeerModels. """ peers = [] for ip_port_string in peer_string.split(","): if ip_port_string: ip_port_list = ip_port_string.strip().split(":") ip = ip_port_list[0] port = int(ip_port_list[1]) peers.append(OutboundPeerModel(ip, port)) return peers
def parse_peer_string(peer_string): """ Parses string of format ip:port:node_type,ip:port,ip:port:node_type,... to list of OutboundPeerModels. """ peers = [] for ip_port_string in peer_string.split(","): if ip_port_string: ip, port_str, node_type_str = ip_port_string.strip().split(":") peers.append( OutboundPeerModel(ip, int(port_str), node_type=NodeType[node_type_str.upper()])) return peers
def _set_up_test_node(self, initialize_handshake, generate_pub_key=False): # Dummy address self.server_ip = "127.0.0.1" self.server_port = 1234 self.blockchain_ip = "0.0.0.0" self.blockchain_port = 30303 # Setting up dummy server addresses self.servers = [ OutboundPeerModel("172.0.0.1", 2222, node_type=NodeType.GATEWAY), OutboundPeerModel("172.0.0.2", 3333, node_type=NodeType.GATEWAY), OutboundPeerModel("172.0.0.3", 4444, node_type=NodeType.GATEWAY) ] if generate_pub_key: pub_key = convert.bytes_to_hex(self._get_dummy_public_key()) else: pub_key = None opts = gateway_helpers.get_gateway_opts( self.server_port, sid_expire_time=0, external_ip=self.server_ip, test_mode=[], peer_gateways=[], peer_relays=self.servers, blockchain_address=(self.blockchain_ip, self.blockchain_port), include_default_eth_args=True, pub_key=pub_key, no_discovery=not initialize_handshake) if opts.use_extensions: helpers.set_extensions_parallelism() node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) self.node = EthGatewayNode(opts, node_ssl_service) self.node.requester = MagicMock() self.assertTrue(self.node) return self.node
def setUp(self) -> None: self.gateway_node = MockGatewayNode( gateway_helpers.get_gateway_opts(8000, split_relays=True)) self.gateway_node.alarm_queue = AlarmQueue() self.gateway_node.requester = ThreadedRequestService( "mock_thread_service", self.gateway_node.alarm_queue, constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S) self.gateway_node.requester.start() self.outbound_peer_models = [ OutboundPeerModel("1.1.1.1", 1609, node_type=NodeType.RELAY_BLOCK), OutboundPeerModel("1.1.1.2", 1609, node_type=NodeType.RELAY_BLOCK), OutboundPeerModel("1.1.1.3", 1609, node_type=NodeType.RELAY_BLOCK), ] sdn_http_service.fetch_potential_relay_peers_by_network = MagicMock( side_effect=lambda *args: self.outbound_peer_models) sdn_http_service.submit_peer_connection_error_event = MagicMock() self.latencies = [10, 20, 30] ping_latency.get_ping_latencies = MagicMock(side_effect=lambda *args: [ NodeLatencyInfo(self.outbound_peer_models[0], self.latencies[0]), NodeLatencyInfo(self.outbound_peer_models[1], self.latencies[1]), NodeLatencyInfo(self.outbound_peer_models[2], self.latencies[2]), ]) self.gateway_node.enqueue_connection = MagicMock()
def test_msg_notification_assigning_short_ids(self): # set test connection to be transaction relay connection relay_id = str(uuid.uuid4()) peer_model = OutboundPeerModel(constants.LOCALHOST, 12345, relay_id) self.node.peer_transaction_relays = {peer_model} self.connection.peer_id = relay_id self.connection.peer_model = peer_model self.assertEqual(1, len(self.node.peer_transaction_relays)) self.connection.msg_notify(NotificationMessage(NotificationCode.ASSIGNING_SHORT_IDS)) relay_peer = next(iter(self.node.peer_transaction_relays)) self.assertTrue(relay_peer.assigning_short_ids) self.connection.msg_notify(NotificationMessage(NotificationCode.NOT_ASSIGNING_SHORT_IDS)) relay_peer = next(iter(self.node.peer_transaction_relays)) self.assertFalse(relay_peer.assigning_short_ids)