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 setUp(self):
self.conn_pool1 = ConnectionPool()
self.fileno1 = 1
self.ip1 = "123.123.123.123"
self.port1 = 1000
self.node1 = MockNode(
helpers.get_common_opts(1001, external_ip="128.128.128.128"))
self.node_id1 = str(uuid.uuid1())
self.conn1 = MockConnection(
MockSocketConnection(self.fileno1,
ip_address=self.ip1,
port=self.port1), self.node1)
self.fileno2 = 5
self.ip2 = "234.234.234.234"
self.port2 = 2000
self.node2 = MockNode(
helpers.get_common_opts(1003, external_ip="321.321.321.321"))
self.node_id2 = str(uuid.uuid1())
self.conn2 = MockConnection(
MockSocketConnection(self.fileno2,
ip_address=self.ip2,
port=self.port2), self.node2)
self.fileno3 = 6
self.ip3 = "234.234.234.234"
self.port3 = 3000
self.node3 = MockNode(
helpers.get_common_opts(1003, external_ip="213.213.213.213."))
self.node_id3 = str(uuid.uuid1())
self.conn3 = MockConnection(
MockSocketConnection(self.fileno3,
ip_address=self.ip3,
port=self.port3), self.node3)
def test_add_special_objects(self):
node1 = MockNode(get_common_opts(1001, external_ip="128.128.128.128"))
conn1 = MockConnection(
MockSocketConnection(1,
node1,
ip_address="123.123.123.123",
port=1000), node1)
conn1.inputbuf.add_bytes(bytearray(b"0000" * 10))
conn1.outputbuf.prepend_msgbytes(bytearray(b"1111" * 100))
total_special_size, ids = memory_utils.get_special_size(conn1)
self.assertTrue(ids)
self.assertTrue(id(conn1.inputbuf.input_list) in ids)
self.assertTrue(id(conn1.outputbuf.output_msgs) in ids)
expected_special_size = memory_utils.get_special_size(
conn1.inputbuf.input_list).size
expected_special_size += memory_utils.get_special_size(
conn1.outputbuf.output_msgs).size
self.assertEqual(total_special_size, expected_special_size)
s, s_id = memory_utils.get_special_size(conn1.outputbuf.output_msgs)
self.assertNotEqual(s, 0)
s, ids = memory_utils.get_special_size(conn1.outputbuf.output_msgs,
ids)
self.assertEqual(s, 0)
def test_remove_blockchain_connection_and_add_new(self):
self._add_connections()
new_desc6 = "1.1.1.1 80"
new_ip6 = new_desc6.split()[0]
new_port6 = new_desc6.split()[1]
new_fileno6 = "10"
new_node6 = MockNode(helpers.get_common_opts(1004, external_ip="214.215.216.217"))
new_conn6 = MockConnection(
MockSocketConnection(new_fileno6, new_node6, ip_address=new_ip6, port=int(new_port6)), new_node6
)
self.conn_pool.delete(self.conn3)
self.blockchain_peers.add(BlockchainPeerInfo(new_ip6, int(new_port6)))
self.conn_pool.add(int(new_fileno6), new_ip6, int(new_port6), new_conn6)
update(self.conn_pool, True, self.source_version, self.ip_address, self.continent, self.country, False,
self.blockchain_peers, self.account_id, self.quota_level)
summary_loaded, _, _, network_loaded = self._load_status_file()
self.assertEqual(summary_loaded,
network_loaded.get_summary(self.ip_address, self.continent, self.country,
False, self.account_id, self.quota_level))
self.assertEqual(summary_loaded.gateway_status, GatewayStatus.WITH_ERRORS)
self.assertEqual(summary_loaded.account_info, summary.gateway_status_get_account_info(None))
self.assertEqual(summary_loaded.quota_level, summary.gateway_status_get_quota_level(self.quota_level))
self.assertEqual(
summary_loaded.blockchain_node_connection_states,
{
f"{new_ip6} {new_port6}": ConnectionState.ESTABLISHED,
f"{self.ip3} {self.port3}": ConnectionState.DISCONNECTED,
f"{self.ip5} {self.port5}": ConnectionState.ESTABLISHED,
}
)
def test_get_object_size(self):
mock_node = MockNode(get_common_opts(1234))
object_size = memory_utils.get_object_size(mock_node)
self.assertIsInstance(object_size, ObjectSize)
self.assertTrue(object_size.size > 0)
self.assertTrue(object_size.flat_size > 0)
self.assertTrue(object_size.is_actual_size)
self.assertEqual(0, len(object_size.references))
ex_set = ExpiringSet(AlarmQueue(), 10, "testset")
s = set()
h1 = Sha256Hash(b"1" * 32)
h2 = Sha256Hash(b"0" * 32)
print(memory_utils.get_object_size(ex_set).size)
print(memory_utils.get_object_size(s).size)
print(memory_utils.get_object_size(h1).size)
print(memory_utils.get_object_size(h2).size)
print(memory_utils.get_special_size(ex_set).size)
print(memory_utils.get_special_size(s).size)
print(memory_utils.get_special_size(h1).size)
print(memory_utils.get_special_size(h2).size)
ex_set.add(h1)
ex_set.add(h2)
s.add(h1)
s.add(h2)
print(memory_utils.get_object_size(ex_set).size)
print(memory_utils.get_special_size(ex_set).size)
print(memory_utils.get_object_size(s).size)
async def setUp(self) -> None:
self.rpc_port = 8001
self.rpc_url = f"http://{constants.LOCALHOST}:{self.rpc_port}"
self.node = MockNode(
helpers.get_common_opts(8000, rpc_port=self.rpc_port)
)
self.rpc_server = HttpRpcServer(self.node)
await self.rpc_server.start()
def setUp(self) -> None:
self.socket_instance = MagicMock(spec=socket.socket)
self.socket_instance.fileno = MagicMock(return_value=1)
self.node = AbstractNode(helpers.get_common_opts(1234))
self.sut = SocketConnection(self.socket_instance, self.node, False)
self.connection = helpers.create_connection(MockConnection,
self.node,
from_me=True)
self.connection.socket_connection = self.sut
def setUp(self):
throughput_statistics.set_node(MockNode(helpers.get_common_opts(8888)))
self.inbound_throughput_event1 = ThroughputEvent(Direction.INBOUND, "test_in_msg", 100, "localhost 0000")
self.inbound_throughput_event2 = ThroughputEvent(Direction.INBOUND, "test_in_msg", 50, "localhost 0000")
self.inbound_throughput_event3 = ThroughputEvent(Direction.INBOUND, "mock_msg", 60, "localhost 0000")
self.outbound_throughput_event1 = ThroughputEvent(Direction.OUTBOUND, "test_out_msg", 100, "localhost 0000")
self.outbound_throughput_event2 = ThroughputEvent(Direction.OUTBOUND, "test_out_msg", 75, "localhost 0000")
def setUp(self):
self.node = MockNode(helpers.get_common_opts(8888))
# noinspection PyTypeChecker
connection = helpers.create_connection(MockConnection,
self.node,
port=9999)
self.node.connection_pool = ConnectionPool()
self.node.connection_pool.add(1, connection.peer_ip,
connection.peer_port, connection)
node_info_statistics.set_node(self.node)
def setUp(self) -> None:
self.mock_node = MockNode(
helpers.get_common_opts(
8000,
node_type=NodeType.EXTERNAL_GATEWAY,
log_level_overrides={}
)
)
self.mock_node.opts.transaction_pool_memory_limit = self.TEST_MEMORY_LIMIT_MB
self.mock_node.network_num = 5
self.transaction_service = self._get_transaction_service()
def setUp(self):
sdn_http_service.submit_peer_connection_error_event = MagicMock()
self.node = TestNode(helpers.get_common_opts(4321), None)
self.fileno = 1
self.ip = "123.123.123.123"
self.port = 8000
self.connection = helpers.create_connection(MockConnection, self.node, file_no=self.fileno, ip=self.ip,
port=self.port, add_to_pool=False, from_me=True)
self.connection.dispose = MagicMock(side_effect=self.connection.dispose)
self.socket_connection = self.connection.socket_connection
def setUp(self):
self.node = TestNode(helpers.get_common_opts(4321))
self.fileno = 1
self.ip = "123.123.123.123"
self.port = 8000
self.connection = helpers.create_connection(MockConnection,
self.node,
fileno=self.fileno,
ip=self.ip,
port=self.port,
add_to_pool=False)
self.connection.close = MagicMock(side_effect=self.connection.close)
self.socket_connection = self.connection.socket_connection
def test_get_detailed_object_size(self):
mock_node = MockNode(get_common_opts(1234))
object_size = memory_utils.get_detailed_object_size(mock_node, 10000)
self.assertIsInstance(object_size, ObjectSize)
self.assertTrue(object_size.size > 0)
self.assertTrue(object_size.flat_size > 0)
self.assertTrue(object_size.is_actual_size)
self.assertTrue(len(object_size.references) > 0)
for ref in object_size.references:
self.assertIsInstance(ref, ObjectSize)
self.assertTrue(ref.size > 0)
self.assertTrue(ref.flat_size > 0)
self.assertTrue(ref.is_actual_size)
def test_get_by_connection_types_performance(self):
log_config.set_level([
"bxcommon.connections.abstract_node",
"bxcommon.services.transaction_service"
], LogLevel.INFO)
conn_pool = ConnectionPool()
self.conn1.CONNECTION_TYPE = ConnectionType.EXTERNAL_GATEWAY
self.conn2.CONNECTION_TYPE = ConnectionType.RELAY_BLOCK
self.conn3.CONNECTION_TYPE = ConnectionType.RELAY_ALL
number_of_iteration = 100
for i in range(40):
ip = f"{i}.{i}.{i}.{i}"
node = MockNode(helpers.get_common_opts(i, external_ip=ip))
conn = MockConnection(
MockSocketConnection(i, ip_address=ip, port=i), node)
if i % 7 == 0:
conn.CONNECTION_TYPE = ConnectionType.RELAY_BLOCK
elif i % 5 == 0:
conn.CONNECTION_TYPE = ConnectionType.RELAY_TRANSACTION
elif i % 3 == 0:
conn.CONNECTION_TYPE = ConnectionType.INTERNAL_GATEWAY
else:
conn.CONNECTION_TYPE = ConnectionType.EXTERNAL_GATEWAY
conn_pool.add(i, ip, i, conn)
timeit_get_by_connections_types_one_type = timeit.timeit(
lambda: conn_pool.get_by_connection_types([ConnectionType.GATEWAY]
),
number=number_of_iteration)
timeit_get_by_connections_types_two_types = timeit.timeit(
lambda: conn_pool.get_by_connection_types(
[ConnectionType.GATEWAY, ConnectionType.RELAY_TRANSACTION]),
number=number_of_iteration)
print(
f"\ntimeit_get_by_connections_types_one_type # 2: {timeit_get_by_connections_types_one_type * 1000 / number_of_iteration:.4f}ms, "
f"#connections: {len(list(conn_pool.get_by_connection_types([ConnectionType.GATEWAY])))}"
f"\ntimeit_get_by_connections_types_two_types # 2: {timeit_get_by_connections_types_two_types * 1000 / number_of_iteration:.4f}ms, "
f"#connections: {len(list(conn_pool.get_by_connection_types([ConnectionType.GATEWAY, ConnectionType.RELAY_TRANSACTION])))}"
)
print("*****")
for c in conn_pool.get_by_connection_types(
[ConnectionType.GATEWAY, ConnectionType.RELAY_TRANSACTION]):
print(f"connection: {c}, connection type: {c.CONNECTION_TYPE}")
def __init__(self, port, peers_ports, timeout=None, send_bytes=None):
opts = helpers.get_common_opts(port)
super(TestNode, self).__init__(opts)
self.port = port
self.peers_ports = peers_ports
self.timeout = timeout
self.initialized = False
self.closed = False
self.finished_sending = True
self.ready_to_close = False
self.connections = []
self.send_bytes = send_bytes if send_bytes is not None else bytearray(
0)
self.memory_view = memoryview(self.send_bytes)
self.bytes_sent = 0
self.receive_buffers = {}
self.timeout_triggered_loops = 0
def setUp(self) -> None:
self.node = MockNode(
helpers.get_common_opts(1001, external_ip="128.128.128.128"))
self.tracker = MessageTracker(
MockConnection(MockSocketConnection(), self.node))
self.output_buffer = OutputBuffer(enable_buffering=True)
def test_sizer(self):
s = Sizer()
node1 = MockNode(get_common_opts(1001, external_ip="128.128.128.128"))
s.set_excluded_asizer("bxcommon.test_utils.mocks.mock_node.MockNode")
self.assertGreater(memory_utils.get_object_size(node1).size, 0)
self.assertEqual(memory_utils.get_object_size(node1, sizer=s.sizer).size, 0)
def setUp(self) -> None:
self.mock_node = MockNode(helpers.get_common_opts(8000, node_type=NodeType.GATEWAY))
self.mock_node.opts.transaction_pool_memory_limit = self.TEST_MEMORY_LIMIT_MB
self.transaction_service = self._get_transaction_service()
def setUp(self) -> None:
self.node = MockNode(helpers.get_common_opts(8000))
self.connection_pool = ConnectionPool()
self.sut = TestBroadcastService(self.connection_pool)
def setUp(self):
self.conn_pool = ConnectionPool()
self.source_version = "v1.0.0"
self.ip_address = "0.0.0.0"
self.continent = "NA"
self.country = "United States"
self.account_id = None
self.fileno1 = 1
self.ip1 = "123.123.123.123"
self.port1 = 1000
self.node1 = MockNode(
helpers.get_common_opts(1001, external_ip="128.128.128.128"))
self.node_id1 = str(uuid.uuid1())
self.conn1 = MockConnection(
MockSocketConnection(self.fileno1,
self.node1,
ip_address=self.ip1,
port=self.port1), self.node1)
self.conn1.CONNECTION_TYPE = ConnectionType.RELAY_BLOCK
self.fileno2 = 5
self.ip2 = "234.234.234.234"
self.port2 = 2000
self.node2 = MockNode(
helpers.get_common_opts(1003, external_ip="321.321.321.321"))
self.node_id2 = str(uuid.uuid1())
self.conn2 = MockConnection(
MockSocketConnection(self.fileno2,
self.node2,
ip_address=self.ip2,
port=self.port2), self.node2)
self.conn2.CONNECTION_TYPE = ConnectionType.RELAY_TRANSACTION
self.fileno3 = 6
self.ip3 = "234.234.234.234"
self.port3 = 3000
self.node3 = MockNode(
helpers.get_common_opts(1003, external_ip="213.213.213.213"))
self.node_id3 = str(uuid.uuid1())
self.conn3 = MockConnection(
MockSocketConnection(self.fileno3,
self.node3,
ip_address=self.ip3,
port=self.port3), self.node3)
self.conn3.CONNECTION_TYPE = ConnectionType.BLOCKCHAIN_NODE
self.fileno4 = 8
self.ip4 = "111.222.111.222"
self.port4 = 3000
self.node4 = MockNode(
helpers.get_common_opts(1003, external_ip="101.101.101.101"))
self.node_id4 = str(uuid.uuid1())
self.conn4 = MockConnection(
MockSocketConnection(self.fileno4,
self.node4,
ip_address=self.ip4,
port=self.port4), self.node4)
self.conn4.CONNECTION_TYPE = ConnectionType.REMOTE_BLOCKCHAIN_NODE
self.quota_level = 0
initialize(False, self.source_version, self.ip_address, self.continent,
self.country, False, self.account_id, self.quota_level)
path = config.get_data_file(STATUS_FILE_NAME)
self.addCleanup(os.remove, path)
def setUp(self) -> None:
self.node = MockNode(helpers.get_common_opts(1234))
self.network_num = 4
self.transaction_service = TransactionService(self.node,
self.network_num)
def setUp(self):
self.node = MockNode(helpers.get_common_opts(8888))
tx_stats.set_node(self.node)
tx_stats.configure_network(1, 0.5, 0.06)
tx_stats.configure_network(2, 50, 60)
def get_gateway_opts(
port,
node_id=None,
external_ip=constants.LOCALHOST,
blockchain_address=None,
test_mode=None,
peer_gateways=None,
peer_relays=None,
peer_transaction_relays=None,
protocol_version=1,
bloxroute_version="bloxroute 1.5",
pub_key=None,
include_default_ont_args=False,
blockchain_network_num=constants.DEFAULT_NETWORK_NUM,
min_peer_gateways=0,
remote_blockchain_ip=None,
remote_blockchain_port=None,
connect_to_remote_blockchain=False,
blockchain_peers=None,
blockchain_peers_file=None,
is_internal_gateway=False,
is_gateway_miner=False,
enable_buffered_send=False,
encrypt_blocks=True,
cookie_file_path=COOKIE_FILE_PATH,
blockchain_block_hold_timeout_s=30,
blockchain_block_recovery_timeout_s=30,
stay_alive_duration=30 * 60,
source_version="v1.1.1.1",
initial_liveliness_check=30,
block_interval=600,
non_ssl_port: int = 9001,
has_fully_updated_tx_service: bool = False,
max_block_interval_s: float = 10,
default_tx_flag: TransactionFlag = TransactionFlag.NO_FLAGS,
log_level_overrides=None,
enable_network_content_logs=False,
account_model=None,
ipc=False,
ipc_file="bxgateway.ipc",
ws=False,
ws_host=constants.LOCALHOST,
ws_port=28333,
request_remote_transaction_streaming: bool = False,
enable_block_compression: bool = True,
filter_txs_factor: float = 0,
blockchain_protocol: str = "Ethereum",
should_restart_on_high_memory: bool = False,
account_id: str = constants.DECODED_EMPTY_ACCOUNT_ID,
**kwargs,
) -> GatewayOpts:
if node_id is None:
node_id = "Gateway at {0}".format(port)
if peer_gateways is None:
peer_gateways = set()
if peer_relays is None:
peer_relays = set()
if peer_transaction_relays is None:
peer_transaction_relays = []
if blockchain_address is None:
blockchain_address = ("127.0.0.1", 7000
) # not real, just a placeholder
if test_mode is None:
test_mode = []
if log_level_overrides is None:
log_level_overrides = {}
if remote_blockchain_ip is not None and remote_blockchain_port is not None:
remote_blockchain_peer = (remote_blockchain_ip, remote_blockchain_port)
else:
remote_blockchain_peer = None
# below is the same as `class ParseBlockchainPeers(argparse.Action)`
if blockchain_peers is not None:
blockchain_peers_set = set()
blockchain_protocol = blockchain_protocol
for peer in blockchain_peers.split(","):
blockchain_peer = argument_parsers.parse_peer(
blockchain_protocol,
peer) # from bxgateway import argument_parsers,
blockchain_peers_set.add(blockchain_peer)
blockchain_peers = blockchain_peers_set
partial_apply_args = locals().copy()
for kwarg, arg in partial_apply_args["kwargs"].items():
partial_apply_args[kwarg] = arg
partial_apply_args["outbound_peers"] = set(peer_gateways).union(
peer_relays)
opts = Namespace()
common_opts = get_common_opts(**partial_apply_args)
opts.__dict__.update(common_opts.__dict__)
opts.__dict__.update({
"bloxroute_version":
bloxroute_version,
"blockchain_ip":
blockchain_address[0],
"blockchain_port":
blockchain_address[1],
"blockchain_protocol":
blockchain_protocol,
"blockchain_network":
"Mainnet",
"blockchain_version":
12345,
"test_mode":
test_mode,
"peer_gateways":
peer_gateways,
"peer_relays":
peer_relays,
"peer_transaction_relays":
peer_transaction_relays,
"protocol_version":
protocol_version,
"min_peer_gateways":
min_peer_gateways,
"remote_blockchain_ip":
remote_blockchain_ip,
"remote_blockchain_port":
remote_blockchain_port,
"remote_blockchain_peer":
remote_blockchain_peer,
"connect_to_remote_blockchain":
connect_to_remote_blockchain,
"blockchain_peers":
blockchain_peers,
"blockchain_peers_file":
blockchain_peers_file,
"is_internal_gateway":
is_internal_gateway,
"is_gateway_miner":
is_gateway_miner,
"encrypt_blocks":
encrypt_blocks,
"enable_buffered_send":
enable_buffered_send,
"compact_block":
True,
"compact_block_min_tx_count":
BTC_COMPACT_BLOCK_DECOMPRESS_MIN_TX_COUNT,
"tune_send_buffer_size":
False,
"dump_short_id_mapping_compression":
False,
"max_block_interval_s":
max_block_interval_s,
"cookie_file_path":
cookie_file_path,
"config_update_interval":
60,
"blockchain_message_ttl":
10,
"remote_blockchain_message_ttl":
10,
"stay_alive_duration":
stay_alive_duration,
"initial_liveliness_check":
initial_liveliness_check,
"has_fully_updated_tx_service":
has_fully_updated_tx_service,
"source_version":
source_version,
"require_blockchain_connection":
True,
"non_ssl_port":
non_ssl_port,
"default_tx_flag":
default_tx_flag,
"should_update_source_version":
False,
"enable_network_content_logs":
False,
"enable_node_cache":
True,
"dump_short_id_mapping_compression_path":
"",
"ws":
ws,
"ws_host":
constants.LOCALHOST,
"ws_port":
28333,
"account_id":
account_id,
"ipc":
False,
"ipc_file":
"bxgateway.ipc",
"request_remote_transaction_streaming":
request_remote_transaction_streaming,
"process_node_txs_in_extension":
True,
"enable_eth_extensions":
True, # TODO remove,
"request_recovery":
True,
"enable_block_compression":
enable_block_compression,
"filter_txs_factor":
filter_txs_factor,
"min_peer_relays_count":
None,
"should_restart_on_high_memory":
should_restart_on_high_memory,
})
# bitcoin
opts.__dict__.update({
"blockchain_net_magic": 12345,
"blockchain_version": 23456,
"blockchain_nonce": 0,
"blockchain_services": 1,
})
# ethereum
opts.__dict__.update({
"private_key":
"294549f8629f0eeb2b8e01aca491f701f5386a9662403b485c4efe7d447dfba3",
"node_public_key": pub_key,
"remote_public_key": pub_key,
"network_id": 1,
"chain_difficulty": 4194304,
"genesis_hash":
"1e8ff5fd9d06ab673db775cf5c72a6b2d63171cd26fe1e6a8b9d2d696049c781",
"no_discovery": True,
"enode":
"enode://294549f8629f0eeb2b8e01aca491f701f5386a9662403b485c4efe7d447dfba3@127.0.0.1:8000",
"eth_ws_uri": None
})
# ontology
opts.__dict__.update({
"blockchain_net_magic": 12345,
"blockchain_version": 23456,
"is_consensus": True,
"sync_port": 10001,
"http_info_port": 10002,
"consensus_port": 10003,
"cap": bytes(32),
"blockchain_nonce": 0,
"relay": True,
"soft_version": "myversion",
"blockchain_services": 1,
})
for key, val in kwargs.items():
opts.__dict__[key] = val
gateway_opts = GatewayOpts.from_opts(opts)
if account_model:
gateway_opts.set_account_options(account_model)
# some attributes are usually set by the node runner
gateway_opts.__dict__.update({
"node_type":
NodeType.EXTERNAL_GATEWAY,
"outbound_peers":
common_opts.outbound_peers,
"sid_expire_time":
common_opts.sid_expire_time,
"blockchain_networks":
common_opts.blockchain_networks,
"blockchain_network_num":
common_opts.blockchain_network_num,
"split_relays":
common_opts.split_relays,
"should_update_source_version":
False,
"blockchain_block_interval":
block_interval,
"blockchain_ignore_block_interval_count":
3,
"blockchain_block_recovery_timeout_s":
blockchain_block_recovery_timeout_s,
"blockchain_block_hold_timeout_s":
blockchain_block_hold_timeout_s,
})
return gateway_opts
def setUp(self):
self.node = MockNode(helpers.get_common_opts(8888))
