def setUp(self): opts = gateway_helpers.get_gateway_opts(8000, include_default_ont_args=True) if opts.use_extensions: helpers.set_extensions_parallelism( opts.thread_pool_parallelism_degree) node_ssl_service = MockNodeSSLService(OntGatewayNode.NODE_TYPE, MagicMock()) self.gateway_node = OntGatewayNode(opts, node_ssl_service) self.gateway_node.opts.has_fully_updated_tx_service = True self.gateway_node.opts.is_consensus = False self.sut = OntRelayConnection( MockSocketConnection(node=self.gateway_node, ip_address=LOCALHOST, port=8001), self.gateway_node) self.gateway_node.node_conn = MockConnection( MockSocketConnection(1, self.gateway_node, ip_address=LOCALHOST, port=8002), self.gateway_node) self.gateway_node_sut = OntNodeConnectionProtocol( self.gateway_node.node_conn) self.gateway_node.message_converter = converter_factory.create_ont_message_converter( 12345, self.gateway_node.opts) self.gateway_node.node_conn.state = ConnectionState.ESTABLISHED self.gateway_node.send_msg_to_node = MagicMock() self.sut.enqueue_msg = MagicMock() gateway_transaction_stats_service.set_node(self.gateway_node)
def __init__(self, opts: Namespace, node_ssl_service: Optional[NodeSSLService] = None): if node_ssl_service is None: node_ssl_service = MockNodeSSLService(self.NODE_TYPE, MagicMock()) helpers.set_extensions_parallelism() super().__init__(opts, node_ssl_service)
async def setUp(self) -> None: pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866" opts = gateway_helpers.get_gateway_opts( 8000, include_default_eth_args=True, pub_key=pub_key, ) if opts.use_extensions: helpers.set_extensions_parallelism() node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) self.node = EthGatewayNode(opts, node_ssl_service) self.feed_manager = FeedManager(self.node) self.node.feed_manager = self.feed_manager self.rpc = SubscriptionRpcHandler(self.node, self.feed_manager, Case.SNAKE) self.feed_name = NewTransactionFeed.NAME self.node.init_live_feeds() 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) self.node.account_model = BdnAccountModelBase( account_id="account_id", certificate="", logical_account_name="test", new_transaction_streaming=self.base_feed_service_model, )
def setUp(self): opts = gateway_helpers.get_gateway_opts(8000, include_default_btc_args=True) if opts.use_extensions: helpers.set_extensions_parallelism(opts.thread_pool_parallelism_degree) node_ssl_service = MockNodeSSLService(BtcGatewayNode.NODE_TYPE, MagicMock()) self.gateway_node = BtcGatewayNode(opts, node_ssl_service) self.gateway_node.opts.has_fully_updated_tx_service = True self.sut = BtcRelayConnection( MockSocketConnection(1, node=self.gateway_node, ip_address=LOCALHOST, port=8001), self.gateway_node ) self.gateway_node.message_converter = converter_factory.create_btc_message_converter( 12345, self.gateway_node.opts ) self.node_conn = MockConnection( MockSocketConnection(1, self.gateway_node, ip_address=LOCALHOST, port=8002), self.gateway_node ) self.gateway_node.connection_pool.add(1, LOCALHOST, 8002, self.node_conn) gateway_helpers.add_blockchain_peer(self.gateway_node, self.node_conn) self.node_conn_2 = MockConnection( MockSocketConnection(1, self.gateway_node, ip_address=LOCALHOST, port=8003), self.gateway_node ) self.gateway_node.connection_pool.add(1, LOCALHOST, 8003, self.node_conn_2) gateway_helpers.add_blockchain_peer(self.gateway_node, self.node_conn_2) self.blockchain_connections = [self.node_conn, self.node_conn_2] self.node_conn.enqueue_msg = MagicMock() self.node_conn_2.enqueue_msg = MagicMock() self.gateway_node.broadcast = MagicMock() self.sut.enqueue_msg = MagicMock() gateway_transaction_stats_service.set_node(self.gateway_node) self.gateway_node.has_active_blockchain_peer = MagicMock(return_value=True)
def __init__(self, opts, node_ssl_service: Optional[NodeSSLService] = None, block_queueing_cls=BtcBlockQueuingService): if opts.use_extensions: helpers.set_extensions_parallelism() if node_ssl_service is None: node_ssl_service = MockNodeSSLService(self.NODE_TYPE, MagicMock()) super(MockGatewayNode, self).__init__(opts, node_ssl_service) self.broadcast_messages = [] self.broadcast_to_nodes_messages = [] self._tx_service = GatewayTransactionService(self, 0) self.block_cleanup_service = self._get_cleanup_service() self.block_queuing_service = block_queueing_cls(self) self.message_converter = MockMessageConverter() if opts.use_extensions: from bxgateway.services.extension_gateway_transaction_service import ExtensionGatewayTransactionService self._tx_service = ExtensionGatewayTransactionService( self, self.network_num) else: self._tx_service = GatewayTransactionService( self, self.network_num) self.opts.has_fully_updated_tx_service = True self.requester = MagicMock() self.has_active_blockchain_peer = MagicMock(return_value=True) self.min_tx_from_node_gas_price = MagicMock()
def setUp(self) -> None: pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866" opts = gateway_helpers.get_gateway_opts(8000, pub_key=pub_key) node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) self.node = EthGatewayNode(opts, node_ssl_service) self.relay_1 = MockNode( helpers.get_common_opts(8000, region="us-east-1")) self.relay_connection_1 = helpers.create_connection( EthRelayConnection, self.node, node_opts=self.relay_1.opts, file_no=1, ip="1.2.3.4") self.relay_2 = MockNode( helpers.get_common_opts(8001, region="eu-west-1")) self.relay_connection_2 = helpers.create_connection( EthRelayConnection, self.node, node_opts=self.relay_2.opts, file_no=1, ip="1.2.3.5") self.node.broadcast = MagicMock() self.node.has_active_blockchain_peer = MagicMock(return_value=True)
def __init__(self, opts, node_ssl_service: Optional[NodeSSLService] = None): if node_ssl_service is None: node_ssl_service = MockNodeSSLService(NodeType.EXTERNAL_GATEWAY, MagicMock()) super(TestNode, self).__init__(opts, node_ssl_service)
def __init__(self, opts: GatewayOpts, node_ssl_service: Optional[NodeSSLService] = None): if node_ssl_service is None: node_ssl_service = MockNodeSSLService(self.NODE_TYPE, MagicMock()) super().__init__(opts, node_ssl_service) self.requester = MagicMock()
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 make_spy_node(gateway_cls, port, **kwargs): opts = gateway_helpers.get_gateway_opts(port, **kwargs) if opts.use_extensions: helpers.set_extensions_parallelism() gateway_node = gateway_cls( opts, MockNodeSSLService(gateway_cls.NODE_TYPE, MagicMock())) gateway_node.broadcast = MagicMock(wraps=gateway_node.broadcast) gateway_node.requester = MagicMock() return gateway_node
def setUp(self) -> None: pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866" opts = gateway_helpers.get_gateway_opts(8000, pub_key=pub_key) node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) self.node = EthGatewayNode(opts, node_ssl_service) self.connection = helpers.create_connection(EthRelayConnection, self.node) self.node.broadcast = MagicMock() self.node.has_active_blockchain_peer = MagicMock(return_value=True)
def __init__(self, opts: CommonOpts, node_ssl_service: Optional[NodeSSLService] = None) -> None: if node_ssl_service is None: node_ssl_service = MockNodeSSLService(self.NODE_TYPE, MagicMock()) super(MockNode, self).__init__(opts, node_ssl_service) self.alarm_queue = AlarmQueue() self.network_num = DEFAULT_NETWORK_NUM self.broadcast_messages = [] self._tx_service = TransactionService(self, self.network_num) self._tx_services = {}
def setUp(self) -> None: pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866" node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) opts = gateway_helpers.get_gateway_opts( 8000, include_default_eth_args=True, blockchain_protocol=BlockchainProtocol.ETHEREUM.name, blockchain_network_num=5, pub_key=pub_key, ) self.node = EthGatewayNode(opts, node_ssl_service) self.enqueued_messages = [] self.broadcast_to_node_messages = [] self.broadcast_messages = [] self.node.opts.has_fully_updated_tx_service = True self.node.init_live_feeds() self.connection = helpers.create_connection( EthNodeConnection, self.node, opts, port=opts.blockchain_port ) gateway_helpers.add_blockchain_peer(self.node, self.connection) self.block_queuing_service = self.node.block_queuing_service_manager.get_designated_block_queuing_service() self.connection.on_connection_established() self.node.node_conn = self.connection gateway_bdn_performance_stats_service.set_node(self.node) def mocked_enqueue_msg(msg, prepend=False): self.enqueued_messages.append(msg) self.connection.enqueue_msg = mocked_enqueue_msg def mocked_broadcast(msg, broadcasting_conn=None, prepend_to_queue=False, connection_types=None): if connection_types is None: connection_types = [ConnectionType.RELAY_ALL] if len(connection_types) == 1 and connection_types[0] == ConnectionType.BLOCKCHAIN_NODE: self.broadcast_to_node_messages.append(msg) else: self.broadcast_messages.append(msg) self.node.broadcast = mocked_broadcast self.cleanup_service = self.node.block_cleanup_service self.node.block_processing_service.queue_block_for_processing = MagicMock() self.sut = self.connection.connection_protocol self.sut._waiting_checkpoint_headers_request = False self.node.opts.ws = True self.node.publish_block = MagicMock()
def setUp(self) -> None: crypto_utils.recover_public_key = MagicMock( return_value=bytes(32)) pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866" opts = gateway_helpers.get_gateway_opts(8000, include_default_eth_args=True, pub_key=pub_key, track_detailed_sent_messages=True) if opts.use_extensions: helpers.set_extensions_parallelism() node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) self.node = EthGatewayNode(opts, node_ssl_service) self.sut = EthNewBlockFeed(self.node)
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 setUp(self) -> None: pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866" opts = gateway_helpers.get_gateway_opts( 8000, include_default_eth_args=True, pub_key=pub_key, track_detailed_sent_messages=True) if opts.use_extensions: helpers.set_extensions_parallelism() node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) self.node = EthGatewayNode(opts, node_ssl_service) self.connection_fileno = 1 self.connection = helpers.create_connection( EthNodeConnection, node=self.node, file_no=self.connection_fileno) cipher1, cipher2 = AbstractRLPxCipherTest().setup_ciphers() self.connection.connection_protocol.rlpx_cipher = cipher1
def __init__(self, opts, node_ssl_service: Optional[NodeSSLService] = None): if opts.use_extensions: helpers.set_extensions_parallelism() if node_ssl_service is None: node_ssl_service = MockNodeSSLService(self.NODE_TYPE, MagicMock()) super(MockOntGatewayNode, self).__init__(opts, node_ssl_service) self.requester = MagicMock() self.broadcast_messages = [] self.send_to_node_messages = [] self._tx_service = TransactionService(self, 0) self.block_cleanup_service = self._get_cleanup_service() self.block_queuing_service = OntBlockQueuingService(self) self.message_converter = MockMessageConverter() if opts.use_extensions: from bxcommon.services.extension_transaction_service import ExtensionTransactionService self._tx_service = ExtensionTransactionService(self, self.network_num) else: self._tx_service = TransactionService(self, self.network_num) self.opts.has_fully_updated_tx_service = True self.node_conn = MagicMock() self.node_conn.is_active = MagicMock(return_value=True)
def setUp(self) -> None: crypto_utils.recover_public_key = MagicMock(return_value=bytes(32)) pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866" opts = gateway_helpers.get_gateway_opts(8000, include_default_eth_args=True, pub_key=pub_key) 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_conn = MockConnection( MockSocketConnection(1, self.node, ip_address=LOCALHOST, port=8002), self.node) self.node.connection_pool.add(1, LOCALHOST, 8002, self.node_conn) gateway_helpers.add_blockchain_peer(self.node, self.node_conn) self.block_queuing_service = self.node.block_queuing_service_manager.get_designated_block_queuing_service( ) self.sut = EthNewBlockFeed(self.node)
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): self.node = MockGatewayNode(gateway_helpers.get_gateway_opts( 8000, include_default_eth_args=True, use_extensions=True), block_queueing_cls=MagicMock()) self.node.message_converter = converter_factory.create_eth_message_converter( self.node.opts) self.node.block_processing_service = BlockProcessingService(self.node) is_handshake_initiator = True dummy_private_key = crypto_utils.make_private_key( helpers.generate_bytearray(111)) dummy_public_key = crypto_utils.private_to_public_key( dummy_private_key) rlpx_cipher = RLPxCipher(is_handshake_initiator, dummy_private_key, dummy_public_key) node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) local_ip = "127.0.0.1" eth_port = 30303 eth_opts = gateway_helpers.get_gateway_opts( 1234, include_default_eth_args=True, blockchain_address=(local_ip, eth_port), pub_key=convert.bytes_to_hex(dummy_public_key)) self.eth_node = EthGatewayNode(eth_opts, node_ssl_service) self.blockchain_connection = EthNodeConnection( MockSocketConnection(1, node=self.node, ip_address=local_ip, port=30303), self.node) self.blockchain_connection.on_connection_established() self.node.connection_pool.add(19, local_ip, eth_port, self.blockchain_connection) self.blockchain_connection_1 = EthNodeConnection( MockSocketConnection(1, node=self.node, ip_address=local_ip, port=333), self.node) self.blockchain_connection_1.on_connection_established() self.node.mock_add_blockchain_peer(self.blockchain_connection_1) self.node_1_endpoint = IpEndpoint(local_ip, 333) self.node.connection_pool.add(20, self.node_1_endpoint.ip_address, self.node_1_endpoint.port, self.blockchain_connection_1) self.blockchain_connection_2 = EthNodeConnection( MockSocketConnection(1, node=self.node, ip_address=local_ip, port=444), self.node) self.blockchain_connection_2.on_connection_established() self.node.mock_add_blockchain_peer(self.blockchain_connection_2) self.node_2_endpoint = IpEndpoint(local_ip, 444) self.node.connection_pool.add(21, self.node_2_endpoint.ip_address, self.node_2_endpoint.port, self.blockchain_connection_2) self.blockchain_connection_1.network_num = 0 self.tx_blockchain_connection_protocol = EthNodeConnectionProtocol( self.blockchain_connection_1, is_handshake_initiator, rlpx_cipher) self.block_blockchain_connection_protocol = EthNodeConnectionProtocol( self.blockchain_connection_1, is_handshake_initiator, rlpx_cipher) self.tx_blockchain_connection_protocol.publish_transaction = MagicMock( ) self.block_blockchain_connection_protocol.publish_transaction = MagicMock( ) self.tx_blockchain_connection_protocol_2 = EthNodeConnectionProtocol( self.blockchain_connection_2, is_handshake_initiator, rlpx_cipher) self.block_blockchain_connection_protocol_2 = EthNodeConnectionProtocol( self.blockchain_connection_2, is_handshake_initiator, rlpx_cipher) self.tx_blockchain_connection_protocol_2.publish_transaction = MagicMock( ) self.block_blockchain_connection_protocol_2.publish_transaction = MagicMock( ) self.relay_connection = AbstractRelayConnection( MockSocketConnection(1, node=self.node, ip_address=local_ip, port=12345), self.node) self.relay_connection.state = ConnectionState.INITIALIZED gateway_bdn_performance_stats_service.set_node(self.node) self.node.account_id = "12345"