def __init__(self,
*,
ssl_dir: Optional[str] = None,
ssl_certificate_location: Optional[str] = None,
ssl_key_location: Optional[str] = None,
ca_file: Optional[str] = None,
ca_url: str = CA_CERT_URL,
ws_uri: str = CLOUD_WEBSOCKETS_URL):
if ssl_dir is None:
ssl_dir = os.path.join(config.get_default_data_path(),
utils_constants.SSL_FOLDER,
DEFAULT_NODE_NAME, "registration_only")
if ssl_certificate_location is None:
ssl_certificate_location = os.path.join(
ssl_dir, f"{DEFAULT_NODE_NAME}_cert.pem")
if ssl_key_location is None:
ssl_key_location = os.path.join(ssl_dir,
f"{DEFAULT_NODE_NAME}_key.pem")
if ca_file is None:
with urllib.request.urlopen(ca_url) as cert_file:
contents = cert_file.read().decode("utf-8")
context = ssl.create_default_context(
Purpose.SERVER_AUTH,
cadata=contents,
)
else:
context = ssl.create_default_context(
Purpose.SERVER_AUTH,
cafile=ca_file,
)
super().__init__(ws_uri)
context.load_cert_chain(ssl_certificate_location, ssl_key_location)
context.check_hostname = False
self.ssl_context = context
def add_argument_parser_common(arg_parser: ArgumentParser):
arg_parser.add_argument(
"--data-dir",
help="Path to store configuration, state and log files",
default=config.get_default_data_path()
)
arg_parser.add_argument(
"--ca-cert-url",
help="The URL for retrieving BDN ca certificate data (default: {})".format(
config.get_env_default(NodeStartArgs.CA_CERT_URL)
),
default=config.get_env_default(NodeStartArgs.CA_CERT_URL),
type=str
)
arg_parser.add_argument(
"--private-ssl-base-url",
help="The base URL for retrieving specific certificate data (default: {})".format(
config.get_env_default(NodeStartArgs.PRIVATE_SSL_BASE_URL)
),
default=config.get_env_default(NodeStartArgs.PRIVATE_SSL_BASE_URL),
type=str
)
def get_common_opts(
port: int,
external_ip: str = constants.LOCALHOST,
node_id: Optional[str] = None,
outbound_peers: Optional[List[OutboundPeerModel]] = None,
blockchain_network_num: int = constants.ALL_NETWORK_NUM,
block_confirmations_count: int = 2,
final_tx_confirmations_count: int = 4,
rpc_port: int = 28332,
continent: str = "NA",
country: str = "United States",
region: str = "us-east-1",
parallelism_degree: int = 1,
split_relays: bool = False,
sid_expire_time: int = 30,
rpc: bool = False,
transaction_validation: bool = True,
rpc_use_ssl: bool = False,
**kwargs,
) -> CommonOpts:
if node_id is None:
node_id = f"Node at {port}"
if outbound_peers is None:
outbound_peers = []
arg_parser = argparse.ArgumentParser(add_help=False)
cli.add_argument_parser_logging(arg_parser, default_log_level=LogLevel.DEBUG)
opts = arg_parser.parse_args([])
# opts = Namespace()
opts.__dict__.update(
{
"external_ip": external_ip,
"external_port": port,
"node_id": node_id,
"memory_stats_interval": 3600,
"dump_detailed_report_at_memory_usage": 100,
"dump_removed_short_ids": False,
"dump_removed_short_ids_path": "",
"transaction_pool_memory_limit": 200000000,
"use_extensions": constants.USE_EXTENSION_MODULES,
"import_extensions": constants.USE_EXTENSION_MODULES,
"tx_mem_pool_bucket_size": constants.DEFAULT_TX_MEM_POOL_BUCKET_SIZE,
"throughput_stats_interval": constants.THROUGHPUT_STATS_INTERVAL_S,
"info_stats_interval": constants.INFO_STATS_INTERVAL_S,
"sync_tx_service": True,
"source_version": "v1.0.0",
"non_ssl_port": 3000,
"enable_node_cache": True,
"rpc_port": rpc_port,
"rpc_host": constants.LOCALHOST,
"rpc_user": "",
"rpc_password": "",
"rpc_use_ssl": rpc_use_ssl,
"rpc_ssl_base_url": "",
"continent": continent,
"country": country,
"region": region,
"hostname": "bxlocal",
"sdn_url": f"{constants.LOCALHOST}:8080",
"enable_buffered_send": False,
"block_compression_debug": False,
"enable_tcp_quickack": True,
"thread_pool_parallelism_degree": config.get_thread_pool_parallelism_degree(
str(parallelism_degree)
),
"data_dir": config.get_default_data_path(),
"ca_cert_url": "https://certificates.blxrbdn.com/ca",
"private_ssl_base_url": "https://certificates.blxrbdn.com",
"rpc": rpc,
"transaction_validation": transaction_validation,
"using_private_ip_connection": False,
}
)
for key, val in kwargs.items():
opts.__dict__[key] = val
common_opts = CommonOpts.from_opts(opts)
# some attributes are usually set by the node runner
common_opts.__dict__.update({
"node_type": AbstractNode.NODE_TYPE,
"outbound_peers": outbound_peers,
"sid_expire_time": sid_expire_time,
"split_relays": split_relays,
"blockchain_networks": {
0: blockchain_network(
"Bitcoin",
"Mainnet",
0,
15,
15,
final_tx_confirmations_count,
block_confirmations_count,
),
1: blockchain_network(
"Bitcoin",
"Testnet",
1,
15,
15,
final_tx_confirmations_count,
block_confirmations_count,
),
4: blockchain_network(
"BitcoinCash",
"Testnet",
4,
15,
15,
24,
block_confirmations_count,
),
5: blockchain_network(
"Ethereum",
"Mainnet",
5,
5,
5,
24,
block_confirmations_count,
),
3: blockchain_network(
"Ethereum",
"Testnet",
3,
5,
5,
final_tx_confirmations_count,
block_confirmations_count,
),
33: blockchain_network(
"Ontology",
"Mainnet",
33,
5,
5,
final_tx_confirmations_count,
block_confirmations_count,
),
10: blockchain_network(
"Ethereum",
"BSC-Mainnet",
10,
5,
5,
24,
block_confirmations_count,
),
},
"blockchain_network_num": blockchain_network_num,
})
return common_opts
def setUp(self):
self.blockchain_network = helpers.blockchain_network(
protocol="Bitcoin",
network_name="Mainnet",
network_num=1,
block_interval=600,
final_tx_confirmations_count=6)
self.set_ssl_folder()
opts = {
"log_path":
"",
"to_stdout":
True,
"external_port":
0,
"external_ip":
"1.1.1.1",
"node_id":
None,
"blockchain_network":
self.blockchain_network.network,
"network_num":
self.blockchain_network.network_num,
"blockchain_protocol":
self.blockchain_network.protocol,
"blockchain_networks": {
self.blockchain_network.network_num: self.blockchain_network
},
"log_level":
LogLevel.INFO,
"log_format":
LogFormat.PLAIN,
"log_flush_immediately":
True,
"log_fluentd_enable":
False,
"log_fluentd_host":
None,
"use_extensions":
True,
"log_fluentd_queue_size":
1000,
"thread_pool_parallelism_degree":
config.get_thread_pool_parallelism_degree(
str(constants.DEFAULT_THREAD_POOL_PARALLELISM_DEGREE), ),
"log_level_overrides": {},
"source_version":
"v1.0.0",
"ca_cert_url":
self.ssl_folder_url,
"private_ssl_base_url":
self.ssl_folder_url,
"data_dir":
config.get_default_data_path(),
"log_level_fluentd":
LogLevel.DEBUG,
"log_level_stdout":
LogLevel.TRACE,
"sdn_url":
"https://localhost:8080",
}
for item in CommonOpts.__dataclass_fields__:
if item not in opts:
opts[item] = None
self.opts = CommonOpts.from_opts(Namespace(**opts))
log_config.create_logger(None, LogLevel.WARNING)
self.event_loop_mock = EventLoopMock()