async def _state_changed(self, *args): change = args[0] if self.websocket is None: return payloads: List[Dict] = await self.rpc_api._state_changed(*args) if change == "add_connection" or change == "close_connection": data = await self.get_connections({}) if data is not None: payload = create_payload( "get_connections", data, self.service_name, "wallet_ui", string=False, ) payloads.append(payload) for payload in payloads: if "success" not in payload["data"]: payload["data"]["success"] = True try: await self.websocket.send_str(dict_to_json_str(payload)) except Exception: tb = traceback.format_exc() self.log.warning(f"Sending data failed. Exception {tb}.")
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 message_for_service(self, message): destination = message["destination"] if destination in self.connections: socket = self.connections[destination] await socket.send(dict_to_json_str(message)) return None
async def handle_message( self, websocket: WebSocketServerProtocol, message: Dict[str, Any]) -> Tuple[Optional[str], List[Any]]: """ This function gets called when new message is received via websocket. """ command = message["command"] destination = message["destination"] if destination != "daemon": destination = message["destination"] if destination in self.connections: sockets = self.connections[destination] return dict_to_json_str(message), sockets return None, [] data = None if "data" in message: data = message["data"] commands_with_data = [ "start_service", "start_plotting", "stop_plotting", "stop_service", "is_running", "register_service", ] if not isinstance(data, dict) and command in commands_with_data: response = { "success": False, "error": f'{command} requires "data"' } elif command == "ping": response = await ping() elif command == "start_service": response = await self.start_service(cast(Dict[str, Any], data)) elif command == "start_plotting": response = await self.start_plotting(cast(Dict[str, Any], data)) elif command == "stop_plotting": response = await self.stop_plotting(cast(Dict[str, Any], data)) elif command == "stop_service": response = await self.stop_service(cast(Dict[str, Any], data)) elif command == "is_running": response = await self.is_running(cast(Dict[str, Any], data)) elif command == "exit": response = await self.stop() elif command == "register_service": response = await self.register_service(websocket, cast(Dict[str, Any], data)) else: self.log.error(f"UK>> {message}") response = { "success": False, "error": f"unknown_command {command}" } full_response = format_response(message, response) return full_response, [websocket]
def format_response(incoming_msg: Dict[str, Any], response_data: Dict[str, Any]) -> str: """ Formats the response into standard format. """ response = { "command": incoming_msg["command"], "ack": True, "data": response_data, "request_id": incoming_msg["request_id"], "destination": incoming_msg["origin"], "origin": incoming_msg["destination"], } json_str = dict_to_json_str(response) return json_str
def create_payload( command: str, data: Dict[str, Any], origin: str, destination: str, string=True ): response = { "command": command, "ack": False, "data": data, "request_id": token_bytes().hex(), "destination": destination, "origin": origin, } if string: json_str = dict_to_json_str(response) return json_str else: return response
async def handle_message(self, websocket, message) -> Tuple[Optional[str], List[Any]]: """ This function gets called when new message is received via websocket. """ command = message["command"] destination = message["destination"] if destination != "daemon": destination = message["destination"] if destination in self.connections: sockets = self.connections[destination] return dict_to_json_str(message), sockets return None, [] data = None if "data" in message: data = message["data"] if command == "ping": response = await ping() elif command == "start_service": response = await self.start_service(data) elif command == "start_plotting": response = await self.start_plotting(data) elif command == "stop_plotting": response = await self.stop_plotting(data) elif command == "stop_service": response = await self.stop_service(data) elif command == "is_running": response = await self.is_running(data) elif command == "exit": response = await self.stop() elif command == "register_service": response = await self.register_service(websocket, data) else: self.log.error(f"UK>> {message}") response = { "success": False, "error": f"unknown_command {command}" } full_response = format_response(message, response) return full_response, [websocket]
async def coin_added(self, coin: Coin, height: int, header_hash: bytes32, removals: List[Coin]): """ Notification from wallet state manager that wallet has been received. """ self.log.info(f"CC wallet has been notified that {coin} was added") search_for_parent: bool = True inner_puzzle = await self.inner_puzzle_for_cc_puzhash(coin.puzzle_hash) lineage_proof = Program.to(( 1, [ coin.parent_coin_info, inner_puzzle.get_tree_hash(), coin.amount, ], )) await self.add_lineage(coin.name(), lineage_proof) for name, lineage_proofs in self.cc_info.lineage_proofs: if coin.parent_coin_info == name: search_for_parent = False break if search_for_parent: data: Dict[str, Any] = { "data": { "action_data": { "api_name": "request_generator", "height": height, "header_hash": header_hash, } } } data_str = dict_to_json_str(data) await self.wallet_state_manager.create_action( name="request_generator", wallet_id=self.wallet_info.id, type=self.wallet_info.type, callback="generator_received", done=False, data=data_str, )
async def _get(self, request): request_id = request["request_id"] self._request_dict[request_id] = asyncio.Event() string = dict_to_json_str(request) asyncio.ensure_future(self.websocket.send(string)) async def timeout(): await asyncio.sleep(30) if request_id in self._request_dict: print("Error, timeout.") self._request_dict[request_id].set() asyncio.ensure_future(timeout()) await self._request_dict[request_id].wait() if request_id in self.response_dict: response = self.response_dict[request_id] self.response_dict.pop(request_id) else: response = None self._request_dict.pop(request_id) return response
def create_payload(command: str, data: Dict[str, Any], origin: str, destination: str) -> str: response = create_payload_dict(command, data, origin, destination) return dict_to_json_str(response)