async def main(): root_path = DEFAULT_ROOT_PATH net_config = load_config(root_path, "config.yaml") config = load_config_cli(root_path, "config.yaml", "harvester") try: plot_config = load_config(root_path, "plots.yaml") except FileNotFoundError: raise RuntimeError("Plots not generated. Run chia-create-plots") initialize_logging("Harvester %(name)-22s", config["logging"]) log = logging.getLogger(__name__) setproctitle("chia_harvester") harvester = Harvester(config, plot_config) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None server = ChiaServer(config["port"], harvester, NodeType.HARVESTER, ping_interval, network_id) _ = await server.start_server(None, config) asyncio.get_running_loop().add_signal_handler(signal.SIGINT, server.close_all) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, server.close_all) peer_info = PeerInfo(harvester.config["farmer_peer"]["host"], harvester.config["farmer_peer"]["port"]) _ = await server.start_client(peer_info, None, config) await server.await_closed() harvester._shutdown() await harvester._await_shutdown() log.info("Harvester fully closed.")
def __init__( self, root_path, api: Any, node_type: NodeType, advertised_port: int, service_name: str, server_listen_ports: List[int] = [], connect_peers: List[PeerInfo] = [], on_connect_callback: Optional[OutboundMessage] = None, rpc_start_callback_port: Optional[Tuple[Callable, int]] = None, start_callback: Optional[Callable] = None, stop_callback: Optional[Callable] = None, await_closed_callback: Optional[Callable] = None, periodic_introducer_poll: Optional[Tuple[PeerInfo, int, int]] = None, ): net_config = load_config(root_path, "config.yaml") ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None self._node_type = node_type proctitle_name = f"chia_{service_name}" setproctitle(proctitle_name) self._log = logging.getLogger(service_name) config = load_config_cli(root_path, "config.yaml", service_name) initialize_logging(f"{service_name:<30s}", config["logging"], root_path) self._rpc_start_callback_port = rpc_start_callback_port self._server = ChiaServer( config["port"], api, node_type, ping_interval, network_id, root_path, config, ) for _ in ["set_server", "_set_server"]: f = getattr(api, _, None) if f: f(self._server) self._connect_peers = connect_peers self._server_listen_ports = server_listen_ports self._api = api self._task = None self._is_stopping = False self._periodic_introducer_poll = periodic_introducer_poll self._on_connect_callback = on_connect_callback self._start_callback = start_callback self._stop_callback = stop_callback self._await_closed_callback = await_closed_callback
async def main(): root_path = DEFAULT_ROOT_PATH net_config = load_config(root_path, "config.yaml") config = load_config_cli(root_path, "config.yaml", "introducer") initialize_logging("Introducer %(name)-21s", config["logging"]) log = logging.getLogger(__name__) setproctitle("chia_introducer") introducer = Introducer(config) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None server = ChiaServer(config["port"], introducer, NodeType.INTRODUCER, ping_interval, network_id) introducer.set_server(server) _ = await server.start_server(None, config) asyncio.get_running_loop().add_signal_handler(signal.SIGINT, server.close_all) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, server.close_all) await server.await_closed() log.info("Introducer fully closed.")
async def async_run_daemon(root_path): chia_init(root_path) config = load_config(root_path, "config.yaml") setproctitle("chia_daemon") initialize_logging("daemon", config["logging"], root_path) lockfile = singleton(daemon_launch_lock_path(root_path)) crt_path = root_path / config["daemon_ssl"]["private_crt"] key_path = root_path / config["daemon_ssl"]["private_key"] ca_crt_path = root_path / config["private_ssl_ca"]["crt"] ca_key_path = root_path / config["private_ssl_ca"]["key"] sys.stdout.flush() json_msg = dict_to_json_str({ "message": "cert_path", "success": True, "cert": f"{crt_path}", "key": f"{key_path}", "ca_crt": f"{ca_crt_path}", }) sys.stdout.write("\n" + json_msg + "\n") sys.stdout.flush() if lockfile is None: print("daemon: already launching") return 2 # TODO: clean this up, ensuring lockfile isn't removed until the listen port is open create_server_for_daemon(root_path) ws_server = WebSocketServer(root_path, ca_crt_path, ca_key_path, crt_path, key_path) await ws_server.start()
async def async_main(): root_path = DEFAULT_ROOT_PATH net_config = load_config(root_path, "config.yaml") config = load_config_cli(root_path, "config.yaml", "farmer") # TOD: Remove once we have pool server config_pool = load_config_cli(root_path, "config.yaml", "pool") initialize_logging("Farmer %(name)-25s", config["logging"], root_path) log = logging.getLogger(__name__) setproctitle("chia_farmer") keychain = Keychain() farmer = Farmer(config, config_pool, keychain) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None server = ChiaServer( config["port"], farmer, NodeType.FARMER, ping_interval, network_id, root_path, config, ) try: asyncio.get_running_loop().add_signal_handler(signal.SIGINT, server.close_all) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, server.close_all) except NotImplementedError: log.info("signal handlers unsupported") _ = await server.start_server(farmer._on_connect) farmer.set_server(server) rpc_cleanup = None if config["start_rpc_server"]: # Starts the RPC server rpc_cleanup = await start_farmer_rpc_server(farmer, server.close_all, config["rpc_port"]) await asyncio.sleep(10) # Allows full node to startup farmer._start_bg_tasks() await server.await_closed() farmer._shut_down = True # Waits for the rpc server to close if rpc_cleanup is not None: await rpc_cleanup() log.info("Closed RPC server.") log.info("Farmer fully closed.")
async def async_main(): root_path = DEFAULT_ROOT_PATH net_config = load_config(root_path, "config.yaml") config = load_config_cli(root_path, "config.yaml", "timelord") initialize_logging("Timelord %(name)-23s", config["logging"], root_path) log = logging.getLogger(__name__) setproctitle("chia_timelord") timelord = Timelord(config, constants) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None server = ChiaServer( config["port"], timelord, NodeType.TIMELORD, ping_interval, network_id, DEFAULT_ROOT_PATH, config, ) timelord.set_server(server) coro = asyncio.start_server( timelord._handle_client, config["vdf_server"]["host"], config["vdf_server"]["port"], loop=asyncio.get_running_loop(), ) def stop_all(): server.close_all() timelord._shutdown() try: asyncio.get_running_loop().add_signal_handler(signal.SIGINT, stop_all) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, stop_all) except NotImplementedError: log.info("signal handlers unsupported") await asyncio.sleep(10) # Allows full node to startup peer_info = PeerInfo(config["full_node_peer"]["host"], config["full_node_peer"]["port"]) bg_task = start_timelord_bg_task(server, peer_info, log) vdf_server = asyncio.ensure_future(coro) await timelord._manage_discriminant_queue() log.info("Closed discriminant queue.") log.info("Shutdown timelord.") await server.await_closed() vdf_server.cancel() bg_task.cancel() log.info("Timelord fully closed.")
async def main(): root_path = DEFAULT_ROOT_PATH net_config = load_config(root_path, "config.yaml") config = load_config_cli(root_path, "config.yaml", "timelord") initialize_logging("Timelord %(name)-23s", config["logging"]) log = logging.getLogger(__name__) setproctitle("chia_timelord") timelord = Timelord(config, constants) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None server = ChiaServer(config["port"], timelord, NodeType.TIMELORD, ping_interval, network_id) _ = await server.start_server(None, config) timelord_shutdown_task: Optional[asyncio.Task] = None coro = asyncio.start_server( timelord._handle_client, config["vdf_server"]["host"], config["vdf_server"]["port"], loop=asyncio.get_running_loop(), ) def signal_received(): nonlocal timelord_shutdown_task server.close_all() timelord_shutdown_task = asyncio.create_task(timelord._shutdown()) asyncio.get_running_loop().add_signal_handler(signal.SIGINT, signal_received) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, signal_received) full_node_peer = PeerInfo( timelord.config["full_node_peer"]["host"], timelord.config["full_node_peer"]["port"], ) await asyncio.sleep(1) # Prevents TCP simultaneous connect with full node await server.start_client(full_node_peer, None, config) vdf_server = asyncio.ensure_future(coro) async for msg in timelord._manage_discriminant_queue(): server.push_message(msg) log.info("Closed discriminant queue.") if timelord_shutdown_task is not None: await timelord_shutdown_task log.info("Shutdown timelord.") await server.await_closed() vdf_server.cancel() log.info("Timelord fully closed.")
async def start_websocket_server(): """ Starts WalletNode, WebSocketServer, and ChiaServer """ setproctitle("chia-wallet") keychain = Keychain(testing=False) websocket_server = WebSocketServer(keychain, DEFAULT_ROOT_PATH) await websocket_server.start() log.info("Wallet fully closed")
async def async_main(): root_path = DEFAULT_ROOT_PATH net_config = load_config(root_path, "config.yaml") config = load_config_cli(root_path, "config.yaml", "harvester") try: plot_config = load_config(root_path, "plots.yaml") except FileNotFoundError: raise RuntimeError("Plots not generated. Run chia-create-plots") initialize_logging("Harvester %(name)-22s", config["logging"], root_path) log = logging.getLogger(__name__) setproctitle("chia_harvester") harvester = await Harvester.create(config, plot_config, root_path) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None server = ChiaServer( config["port"], harvester, NodeType.HARVESTER, ping_interval, network_id, DEFAULT_ROOT_PATH, config, ) try: asyncio.get_running_loop().add_signal_handler(signal.SIGINT, server.close_all) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, server.close_all) except NotImplementedError: log.info("signal handlers unsupported") rpc_cleanup = None if config["start_rpc_server"]: # Starts the RPC server rpc_cleanup = await start_harvester_rpc_server( harvester, server.close_all, config["rpc_port"] ) harvester.set_server(server) await asyncio.sleep(1) harvester._start_bg_tasks() await server.await_closed() harvester._shutdown() await harvester._await_shutdown() # Waits for the rpc server to close if rpc_cleanup is not None: await rpc_cleanup() log.info("Closed RPC server.") log.info("Harvester fully closed.")
async def async_main(): root_path = DEFAULT_ROOT_PATH net_config = load_config(root_path, "config.yaml") config = load_config_cli(root_path, "config.yaml", "farmer") try: check_keys(root_path) key_config = load_config(root_path, "keys.yaml") except FileNotFoundError: raise RuntimeError("Keys not generated. Run `chia generate keys`") initialize_logging("Farmer %(name)-25s", config["logging"], root_path) log = logging.getLogger(__name__) setproctitle("chia_farmer") farmer = Farmer(config, key_config) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None server = ChiaServer( config["port"], farmer, NodeType.FARMER, ping_interval, network_id, root_path, config, ) try: asyncio.get_running_loop().add_signal_handler(signal.SIGINT, server.close_all) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, server.close_all) except NotImplementedError: log.info("signal handlers unsupported") _ = await server.start_server(farmer._on_connect) farmer.set_server(server) await asyncio.sleep(10) # Allows full node to startup farmer._start_bg_tasks() await server.await_closed() farmer._shut_down = True log.info("Farmer fully closed.")
def main(): setproctitle("chia_timelord_launcher") config = load_config(DEFAULT_ROOT_PATH, "config.yaml", "timelord_launcher") initialize_logging("Launcher %(name)-23s", config["logging"]) def signal_received(): asyncio.create_task(kill_processes()) loop = asyncio.get_event_loop() loop.add_signal_handler(signal.SIGINT, signal_received) loop.add_signal_handler(signal.SIGTERM, signal_received) try: loop.run_until_complete(spawn_all_processes(config)) finally: log.info("Launcher fully closed.") loop.close()
async def main(): root_path = DEFAULT_ROOT_PATH net_config = load_config(root_path, "config.yaml") config = load_config_cli(root_path, "config.yaml", "farmer") try: key_config = load_config(root_path, "keys.yaml") except FileNotFoundError: raise RuntimeError("Keys not generated. Run chia-generate-keys") initialize_logging("Farmer %(name)-25s", config["logging"]) log = logging.getLogger(__name__) setproctitle("chia_farmer") farmer = Farmer(config, key_config) harvester_peer = PeerInfo(config["harvester_peer"]["host"], config["harvester_peer"]["port"]) full_node_peer = PeerInfo(config["full_node_peer"]["host"], config["full_node_peer"]["port"]) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None server = ChiaServer(config["port"], farmer, NodeType.FARMER, ping_interval, network_id) asyncio.get_running_loop().add_signal_handler(signal.SIGINT, server.close_all) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, server.close_all) _ = await server.start_server(farmer._on_connect, config) await asyncio.sleep(2) # Prevents TCP simultaneous connect with harvester _ = await server.start_client(harvester_peer, None, config) _ = await server.start_client(full_node_peer, None, config) farmer.set_server(server) farmer._start_bg_tasks() await server.await_closed() farmer._shut_down = True log.info("Farmer fully closed.")
def main(): root_path = DEFAULT_ROOT_PATH setproctitle("chia_timelord_launcher") net_config = load_config(root_path, "config.yaml") config = net_config["timelord_launcher"] initialize_logging("TLauncher", config["logging"], root_path) def signal_received(): asyncio.create_task(kill_processes()) loop = asyncio.get_event_loop() try: loop.add_signal_handler(signal.SIGINT, signal_received) loop.add_signal_handler(signal.SIGTERM, signal_received) except NotImplementedError: log.info("signal handlers unsupported") try: loop.run_until_complete(spawn_all_processes(config, net_config)) finally: log.info("Launcher fully closed.") loop.close()
async def async_main(): root_path = DEFAULT_ROOT_PATH config = load_config_cli(root_path, "config.yaml", "full_node") net_config = load_config(root_path, "config.yaml") setproctitle("chia_full_node") initialize_logging("FullNode %(name)-23s", config["logging"], root_path) log = logging.getLogger(__name__) server_closed = False full_node = await FullNode.create(config, root_path=root_path) if config["enable_upnp"]: log.info(f"Attempting to enable UPnP (open up port {config['port']})") try: upnp = miniupnpc.UPnP() upnp.discoverdelay = 5 upnp.discover() upnp.selectigd() upnp.addportmapping(config["port"], "TCP", upnp.lanaddr, config["port"], "chia", "") log.info(f"Port {config['port']} opened with UPnP.") except Exception: log.warning( "UPnP failed. This is not required to run chia, but it allows incoming connections from other peers." ) # Starts the full node server (which full nodes can connect to) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None server = ChiaServer( config["port"], full_node, NodeType.FULL_NODE, ping_interval, network_id, DEFAULT_ROOT_PATH, config, ) full_node._set_server(server) _ = await server.start_server(full_node._on_connect) rpc_cleanup = None def master_close_cb(): nonlocal server_closed if not server_closed: # Called by the UI, when node is closed, or when a signal is sent log.info("Closing all connections, and server...") server.close_all() full_node._close() server_closed = True if config["start_rpc_server"]: # Starts the RPC server rpc_cleanup = await start_full_node_rpc_server(full_node, master_close_cb, config["rpc_port"]) try: asyncio.get_running_loop().add_signal_handler(signal.SIGINT, master_close_cb) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, master_close_cb) except NotImplementedError: log.info("signal handlers unsupported") full_node._start_bg_tasks() # Awaits for server and all connections to close await server.await_closed() log.info("Closed all node servers.") # Stops the full node and closes DBs await full_node._await_closed() # Waits for the rpc server to close if rpc_cleanup is not None: await rpc_cleanup() log.info("Closed RPC server.") await asyncio.get_running_loop().shutdown_asyncgens() log.info("Node fully closed.")
async def async_main(): root_path = DEFAULT_ROOT_PATH config = load_config_cli(root_path, "config.yaml", "full_node") net_config = load_config(root_path, "config.yaml") setproctitle("chia_full_node") initialize_logging("FullNode %(name)-23s", config["logging"], root_path) log = logging.getLogger(__name__) server_closed = False db_path = path_from_root(root_path, config["database_path"]) mkdir(db_path.parent) # Create the store (DB) and full node instance connection = await aiosqlite.connect(db_path) store = await FullNodeStore.create(connection) genesis: FullBlock = FullBlock.from_bytes(constants["GENESIS_BLOCK"]) await store.add_block(genesis) unspent_store = await CoinStore.create(connection) log.info("Initializing blockchain from disk") blockchain = await Blockchain.create(unspent_store, store) log.info("Blockchain initialized") mempool_manager = MempoolManager(unspent_store) await mempool_manager.new_tips(await blockchain.get_full_tips()) full_node = FullNode(store, blockchain, config, mempool_manager, unspent_store) if config["enable_upnp"]: log.info(f"Attempting to enable UPnP (open up port {config['port']})") try: upnp = miniupnpc.UPnP() upnp.discoverdelay = 5 upnp.discover() upnp.selectigd() upnp.addportmapping( config["port"], "TCP", upnp.lanaddr, config["port"], "chia", "" ) log.info(f"Port {config['port']} opened with UPnP.") except Exception: log.exception(f"UPnP failed") # Starts the full node server (which full nodes can connect to) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None server = ChiaServer( config["port"], full_node, NodeType.FULL_NODE, ping_interval, network_id, DEFAULT_ROOT_PATH, config, ) full_node._set_server(server) _ = await server.start_server(full_node._on_connect) rpc_cleanup = None def master_close_cb(): nonlocal server_closed if not server_closed: # Called by the UI, when node is closed, or when a signal is sent log.info("Closing all connections, and server...") full_node._shutdown() server.close_all() server_closed = True if config["start_rpc_server"]: # Starts the RPC server rpc_cleanup = await start_rpc_server( full_node, master_close_cb, config["rpc_port"] ) try: asyncio.get_running_loop().add_signal_handler(signal.SIGINT, master_close_cb) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, master_close_cb) except NotImplementedError: log.info("signal handlers unsupported") full_node._start_bg_tasks() # Awaits for server and all connections to close await server.await_closed() log.info("Closed all node servers.") # Waits for the rpc server to close if rpc_cleanup is not None: await rpc_cleanup() log.info("Closed RPC server.") await connection.close() log.info("Closed db connection.") await asyncio.get_running_loop().shutdown_asyncgens() log.info("Node fully closed.")
def test_does_not_crash(self): setproctitle("chia test title")
def __init__( self, root_path, node: Any, peer_api: Any, node_type: NodeType, advertised_port: int, service_name: str, network_id=bytes32, 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, ): 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 = None self._network_id: bytes32 = 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) self._server = ChiaServer( advertised_port, node, peer_api, node_type, ping_interval, network_id, 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] = []
def __init__( self, root_path, api: Any, node_type: NodeType, advertised_port: int, service_name: str, server_listen_ports: List[int] = [], connect_peers: List[PeerInfo] = [], auth_connect_peers: bool = True, on_connect_callback: Optional[OnConnectFunc] = None, rpc_info: Optional[Tuple[type, int]] = None, start_callback: Optional[Callable] = None, stop_callback: Optional[Callable] = None, await_closed_callback: Optional[Callable] = None, periodic_introducer_poll: Optional[Tuple[PeerInfo, int, int]] = None, parse_cli_args=True, ): net_config = load_config(root_path, "config.yaml") ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") self.self_hostname = net_config.get("self_hostname") self.daemon_port = net_config.get("daemon_port") assert ping_interval is not None assert network_id is not None self._node_type = node_type proctitle_name = f"chia_{service_name}" setproctitle(proctitle_name) self._log = logging.getLogger(service_name) if parse_cli_args: config = load_config_cli(root_path, "config.yaml", service_name) else: config = load_config(root_path, "config.yaml", service_name) initialize_logging(service_name, config["logging"], root_path) self._rpc_info = rpc_info self._server = ChiaServer( advertised_port, api, node_type, ping_interval, network_id, root_path, config, name=f"{service_name}_server", ) for _ in ["set_server", "_set_server"]: f = getattr(api, _, None) if f: f(self._server) self._connect_peers = connect_peers self._auth_connect_peers = auth_connect_peers self._server_listen_ports = server_listen_ports self._api = api self._task = None self._is_stopping = False self._periodic_introducer_poll = periodic_introducer_poll self._on_connect_callback = on_connect_callback self._start_callback = start_callback self._stop_callback = stop_callback self._await_closed_callback = await_closed_callback self._advertised_port = advertised_port self._server_sockets: List = []
async def main(): root_path = DEFAULT_ROOT_PATH net_config = load_config(root_path, "config.yaml") config = load_config_cli(root_path, "config.yaml", "full_node") setproctitle("chia_full_node") initialize_logging("FullNode %(name)-23s", config["logging"], root_path) log = logging.getLogger(__name__) server_closed = False db_path = path_from_root(DEFAULT_ROOT_PATH, config["simulator_database_path"]) mkdir(db_path.parent) connection = await aiosqlite.connect(db_path) # Create the store (DB) and full node instance store = await FullNodeStore.create(connection) await store._clear_database() genesis: FullBlock = FullBlock.from_bytes(test_constants["GENESIS_BLOCK"]) await store.add_block(genesis) unspent_store = await CoinStore.create(connection) log.info("Initializing blockchain from disk") blockchain = await Blockchain.create(unspent_store, store, test_constants) mempool_manager = MempoolManager(unspent_store, test_constants) await mempool_manager.new_tips(await blockchain.get_full_tips()) full_node = FullNodeSimulator( store, blockchain, config, mempool_manager, unspent_store, override_constants=test_constants, ) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") # Starts the full node server (which full nodes can connect to) assert ping_interval is not None assert network_id is not None server = ChiaServer( config["port"], full_node, NodeType.FULL_NODE, ping_interval, network_id, DEFAULT_ROOT_PATH, config, ) full_node._set_server(server) _ = await server.start_server(full_node._on_connect) rpc_cleanup = None def master_close_cb(): nonlocal server_closed if not server_closed: # Called by the UI, when node is closed, or when a signal is sent log.info("Closing all connections, and server...") full_node._shutdown() server.close_all() server_closed = True if config["start_rpc_server"]: # Starts the RPC server rpc_cleanup = await start_rpc_server(full_node, master_close_cb, config["rpc_port"]) try: asyncio.get_running_loop().add_signal_handler(signal.SIGINT, master_close_cb) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, master_close_cb) except NotImplementedError: log.info("signal handlers unsupported") log.info("Waiting to connect to some peers...") await asyncio.sleep(3) log.info( f"Connected to {len(server.global_connections.get_connections())} peers." ) # Awaits for server and all connections to close await server.await_closed() log.info("Closed all node servers.") # Waits for the rpc server to close if rpc_cleanup is not None: await rpc_cleanup() log.info("Closed RPC server.") await store.close() log.info("Closed store.") await unspent_store.close() log.info("Closed unspent store.") await asyncio.get_running_loop().shutdown_asyncgens() log.info("Node fully closed.")
async def main(): root_path = DEFAULT_ROOT_PATH net_config = load_config(root_path, "config.yaml") config = load_config_cli(root_path, "config.yaml", "full_node") setproctitle("chia_full_node") initialize_logging("FullNode %(name)-23s", config["logging"], root_path) log = logging.getLogger(__name__) server_closed = False db_path = path_from_root(root_path, config["simulator_database_path"]) mkdir(db_path.parent) db_path.unlink() full_node = await FullNodeSimulator.create( config, root_path=root_path, override_constants=test_constants, ) ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") # Starts the full node server (which full nodes can connect to) assert ping_interval is not None assert network_id is not None server = ChiaServer( config["port"], full_node, NodeType.FULL_NODE, ping_interval, network_id, DEFAULT_ROOT_PATH, config, ) full_node._set_server(server) _ = await server.start_server(full_node._on_connect) rpc_cleanup = None def master_close_cb(): nonlocal server_closed if not server_closed: # Called by the UI, when node is closed, or when a signal is sent log.info("Closing all connections, and server...") server.close_all() server_closed = True if config["start_rpc_server"]: # Starts the RPC server rpc_cleanup = await start_rpc_server(full_node, master_close_cb, config["rpc_port"]) try: asyncio.get_running_loop().add_signal_handler(signal.SIGINT, master_close_cb) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, master_close_cb) except NotImplementedError: log.info("signal handlers unsupported") # Awaits for server and all connections to close await server.await_closed() log.info("Closed all node servers.") # Stops the full node and closes DBs await full_node._shutdown() # Waits for the rpc server to close if rpc_cleanup is not None: await rpc_cleanup() log.info("Closed RPC server.") await asyncio.get_running_loop().shutdown_asyncgens() log.info("Node fully closed.")
async def start_websocket_server(): """ Starts WalletNode, WebSocketServer, and ChiaServer """ root_path = DEFAULT_ROOT_PATH config = load_config_cli(root_path, "config.yaml", "wallet") initialize_logging("Wallet %(name)-25s", config["logging"]) log = logging.getLogger(__name__) try: key_config = load_config(DEFAULT_ROOT_PATH, "keys.yaml") except FileNotFoundError: raise RuntimeError("Keys not generated. Run chia-generate-keys") if config["testing"] is True: log.info(f"Testing") config["database_path"] = "test_db_wallet.db" wallet_node = await WalletNode.create( config, key_config, override_constants=test_constants) else: log.info(f"Not Testing") wallet_node = await WalletNode.create(config, key_config) setproctitle("chia-wallet") handler = WebSocketServer(wallet_node, log) wallet_node.wallet_state_manager.set_callback( handler.state_changed_callback) net_config = load_config(root_path, "config.yaml") ping_interval = net_config.get("ping_interval") network_id = net_config.get("network_id") assert ping_interval is not None assert network_id is not None log.info(f"Starting wallet server on port {config['port']}.") server = ChiaServer(config["port"], wallet_node, NodeType.WALLET, ping_interval, network_id) wallet_node.set_server(server) _ = await server.start_server(None, config) if "full_node_peer" in config: full_node_peer = PeerInfo(config["full_node_peer"]["host"], config["full_node_peer"]["port"]) log.info(f"Connecting to full node peer at {full_node_peer}") server.global_connections.peers.add(full_node_peer) _ = await server.start_client(full_node_peer, None, config) log.info("Starting websocket server.") websocket_server = await websockets.serve(handler.safe_handle, "localhost", config["rpc_port"]) log.info(f"Started websocket server at port {config['rpc_port']}.") def master_close_cb(): websocket_server.close() server.close_all() wallet_node._shutdown() asyncio.get_running_loop().add_signal_handler(signal.SIGINT, master_close_cb) asyncio.get_running_loop().add_signal_handler(signal.SIGTERM, master_close_cb) if config["testing"] is False: wallet_node._start_bg_tasks() await server.await_closed() await websocket_server.wait_closed() await wallet_node.wallet_state_manager.close_all_stores() log.info("Wallet fully closed")