def main() -> None:
# Use a temp keychain which will be deleted when it exits scope
with TempKeyring() as keychain:
# If launched with -D, we should connect to the keychain via the daemon instead
# of using a local keychain
if "-D" in sys.argv:
keychain = None
sys.argv.remove(
"-D"
) # Remove -D to avoid conflicting with load_config_cli's argparse usage
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml",
SERVICE_NAME)
config["database_path"] = config["simulator_database_path"]
config["peer_db_path"] = config["simulator_peer_db_path"]
config["introducer_peer"]["host"] = "127.0.0.1"
config["introducer_peer"]["port"] = 58555
config["selected_network"] = "testnet0"
config["simulation"] = True
kwargs = service_kwargs_for_full_node_simulator(
DEFAULT_ROOT_PATH,
config,
create_block_tools(test_constants,
root_path=DEFAULT_ROOT_PATH,
keychain=keychain),
)
return run_service(**kwargs)
def main():
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", "seeder")
overrides = config["network_overrides"]["constants"][
config["selected_network"]]
updated_constants = DEFAULT_CONSTANTS.replace_str_to_bytes(**overrides)
kwargs = service_kwargs_for_full_node_crawler(DEFAULT_ROOT_PATH, config,
updated_constants)
return run_service(**kwargs)
def service_kwargs_for_wallet(
root_path: pathlib.Path,
config: Dict,
consensus_constants: ConsensusConstants,
keychain: Keychain,
) -> Dict:
overrides = config["network_overrides"]["constants"][
config["selected_network"]]
updated_constants = consensus_constants.replace_str_to_bytes(**overrides)
# add local node to trusted peers if old config
if "trusted_peers" not in config:
full_node_config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml",
"full_node")
trusted_peer = full_node_config["ssl"]["public_crt"]
config["trusted_peers"] = {}
config["trusted_peers"]["local_node"] = trusted_peer
node = WalletNode(
config,
keychain,
root_path,
consensus_constants=updated_constants,
)
peer_api = WalletNodeAPI(node)
fnp = config.get("full_node_peer")
if fnp:
connect_peers = [PeerInfo(fnp["host"], fnp["port"])]
node.full_node_peer = PeerInfo(fnp["host"], fnp["port"])
else:
connect_peers = []
node.full_node_peer = None
network_id = config["selected_network"]
kwargs = dict(
root_path=root_path,
node=node,
peer_api=peer_api,
node_type=NodeType.WALLET,
service_name=SERVICE_NAME,
on_connect_callback=node.on_connect,
connect_peers=connect_peers,
auth_connect_peers=False,
network_id=network_id,
)
port = config.get("port")
if port is not None:
kwargs.update(
advertised_port=config["port"],
server_listen_ports=[config["port"]],
)
rpc_port = config.get("rpc_port")
if rpc_port is not None:
kwargs["rpc_info"] = (WalletRpcApi, config["rpc_port"])
return kwargs
def main() -> None:
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
config["database_path"] = config["simulator_database_path"]
config["peer_db_path"] = config["simulator_peer_db_path"]
config["introducer_peer"]["host"] = "127.0.0.1"
config["introducer_peer"]["port"] = 58555
config["selected_network"] = "testnet0"
config["simulation"] = True
kwargs = service_kwargs_for_full_node_simulator(
DEFAULT_ROOT_PATH,
config,
BlockTools(test_constants),
)
return run_service(**kwargs)
def main() -> None:
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
# This is simulator
local_test = config["testing"]
if local_test is True:
constants = test_constants
current = config["database_path"]
config["database_path"] = f"{current}_simulation"
config["selected_network"] = "testnet0"
else:
constants = DEFAULT_CONSTANTS
keychain = Keychain(testing=False)
kwargs = service_kwargs_for_wallet(DEFAULT_ROOT_PATH, config, constants, keychain)
return run_service(**kwargs)
def main() -> None:
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
config_pool = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", "pool")
kwargs = service_kwargs_for_farmer(DEFAULT_ROOT_PATH, config, config_pool,
DEFAULT_CONSTANTS)
return run_service(**kwargs)
def main() -> None:
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
kwargs = service_kwargs_for_timelord(DEFAULT_ROOT_PATH, config, DEFAULT_CONSTANTS)
return run_service(**kwargs)
def main() -> None:
config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
kwargs = service_kwargs_for_introducer(DEFAULT_ROOT_PATH, config)
return run_service(**kwargs)
def __init__(
self,
root_path,
node: Any,
peer_api: Any,
node_type: NodeType,
advertised_port: int,
service_name: str,
network_id: str,
upnp_ports: List[int] = [],
server_listen_ports: List[int] = [],
connect_peers: List[PeerInfo] = [],
auth_connect_peers: bool = True,
on_connect_callback: Optional[Callable] = None,
rpc_info: Optional[Tuple[type, int]] = None,
parse_cli_args=True,
connect_to_daemon=True,
) -> None:
self.root_path = root_path
self.config = load_config(root_path, "config.yaml")
ping_interval = self.config.get("ping_interval")
self.self_hostname = self.config.get("self_hostname")
self.daemon_port = self.config.get("daemon_port")
assert ping_interval is not None
self._connect_to_daemon = connect_to_daemon
self._node_type = node_type
self._service_name = service_name
self._rpc_task: Optional[asyncio.Task] = None
self._rpc_close_task: Optional[asyncio.Task] = None
self._network_id: str = network_id
proctitle_name = f"chia_{service_name}"
setproctitle(proctitle_name)
self._log = logging.getLogger(service_name)
if parse_cli_args:
service_config = load_config_cli(root_path, "config.yaml",
service_name)
else:
service_config = load_config(root_path, "config.yaml",
service_name)
initialize_logging(service_name, service_config["logging"], root_path)
self._rpc_info = rpc_info
private_ca_crt, private_ca_key = private_ssl_ca_paths(
root_path, self.config)
chia_ca_crt, chia_ca_key = chia_ssl_ca_paths(root_path, self.config)
inbound_rlp = self.config.get("inbound_rate_limit_percent")
outbound_rlp = self.config.get("outbound_rate_limit_percent")
if NodeType == NodeType.WALLET:
inbound_rlp = service_config.get("inbound_rate_limit_percent",
inbound_rlp)
outbound_rlp = service_config.get("outbound_rate_limit_percent",
60)
assert inbound_rlp and outbound_rlp
self._server = ChiaServer(
advertised_port,
node,
peer_api,
node_type,
ping_interval,
network_id,
inbound_rlp,
outbound_rlp,
root_path,
service_config,
(private_ca_crt, private_ca_key),
(chia_ca_crt, chia_ca_key),
name=f"{service_name}_server",
)
f = getattr(node, "set_server", None)
if f:
f(self._server)
else:
self._log.warning(f"No set_server method for {service_name}")
self._connect_peers = connect_peers
self._auth_connect_peers = auth_connect_peers
self._upnp_ports = upnp_ports
self._server_listen_ports = server_listen_ports
self._api = peer_api
self._node = node
self._did_start = False
self._is_stopping = asyncio.Event()
self._stopped_by_rpc = False
self._on_connect_callback = on_connect_callback
self._advertised_port = advertised_port
self._reconnect_tasks: List[asyncio.Task] = []
self.upnp: Optional[UPnP] = None
