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"
