async def _state_changed(self, change: str) -> List[Dict]:
payloads = []
if change == "block":
data = await self.get_latest_block_headers({})
assert data is not None
payloads.append(
create_payload(
"get_latest_block_headers",
data,
self.service_name,
"wallet_ui",
string=False,
))
data = await self.get_blockchain_state({})
assert data is not None
payloads.append(
create_payload(
"get_blockchain_state",
data,
self.service_name,
"wallet_ui",
string=False,
))
return payloads
return []
async def _state_changed(self, change: str,
change_data: Dict) -> List[Dict]:
if change == "signage_point":
sp_hash = change_data["sp_hash"]
data = await self.get_signage_point({"sp_hash": sp_hash.hex()})
return [
create_payload(
"get_signage_point",
data,
self.service_name,
"wallet_ui",
string=False,
)
]
elif change == "proof":
proof: NewProofOfSpace = change_data["proof"]
data = {
"proof": {
"challenge_hash": proof.challenge_hash,
"sp_hash": proof.sp_hash,
"plot_identifier": proof.plot_identifier,
"signage_point_index": proof.signage_point_index,
}
}
return [
create_payload(
"proof",
data,
self.service_name,
"wallet_ui",
string=False,
)
]
return []
async def connection(self, ws):
data = {"service": "chia-wallet"}
payload = create_payload("register_service", data, "chia-wallet",
"daemon")
await ws.send_str(payload)
while True:
msg = await ws.receive()
if msg.type == aiohttp.WSMsgType.TEXT:
message = msg.data.strip()
# self.log.info(f"received message: {message}")
await self.safe_handle(ws, message)
elif msg.type == aiohttp.WSMsgType.BINARY:
pass
# self.log.warning("Received binary data")
elif msg.type == aiohttp.WSMsgType.PING:
await ws.pong()
elif msg.type == aiohttp.WSMsgType.PONG:
self.log.info("Pong received")
else:
if msg.type == aiohttp.WSMsgType.CLOSE:
print("Closing")
await ws.close()
elif msg.type == aiohttp.WSMsgType.ERROR:
print("Error during receive %s" % ws.exception())
elif msg.type == aiohttp.WSMsgType.CLOSED:
pass
break
await ws.close()
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 _state_changed(self, service: str, state: str):
if service not in self.connections:
return
message = None
websockets = self.connections[service]
if service == service_plotter:
message = {
"state": state,
"queue": self.extract_plot_queue(),
}
if message is None:
return
response = create_payload("state_changed", message, service,
"wallet_ui")
for websocket in websockets:
try:
await websocket.send(response)
except Exception as e:
tb = traceback.format_exc()
self.log.error(
f"Unexpected exception trying to send to websocket: {e} {tb}"
)
websockets.remove(websocket)
await websocket.close()
async def _state_changed(self, change: str) -> List[str]:
if change == "plots":
data = await self.get_plots({})
payload = create_payload("get_plots", data, self.service_name,
"wallet_ui")
return [payload]
return []
async def _state_changed(self, change: str) -> List[str]:
if change == "challenge":
data = await self.get_latest_challenges({})
return [
create_payload("get_latest_challenges", data,
self.service_name, "wallet_ui")
]
return []
async def _state_changed(self, change: str) -> List[Dict]:
if change == "plots":
data = await self.get_plots({})
payload = create_payload("get_plots",
data,
self.service_name,
"wallet_ui",
string=False)
# print("Payload: ", payload)
# print(f"Len of payload: {len(payload)}")
return [payload]
return []
async def _state_changed(self, *args) -> List[str]:
if len(args) < 2:
return []
change = args[0]
wallet_id = args[1]
data = {
"state": change,
}
if wallet_id is not None:
data["wallet_id"] = wallet_id
return [create_payload("state_changed", data, "chia_wallet", "wallet_ui")]
async def _state_changed(self, change: str):
assert self.websocket is not None
if change == "add_connection" or change == "close_connection":
data = await self.get_connections({})
payload = create_payload("get_connections", data,
self.service_name, "wallet_ui")
try:
await self.websocket.send_str(payload)
except (BaseException) as e:
try:
self.log.warning(f"Sending data failed. Exception {type(e)}.")
except BrokenPipeError:
pass
async def _state_changed(self, change: str):
assert self.websocket is not None
payloads = []
if change == "block":
data = await self.get_latest_block_headers({})
payloads.append(
create_payload("get_latest_block_headers", data,
self.service_name, "wallet_ui"))
data = await self.get_blockchain_state({})
payloads.append(
create_payload("get_blockchain_state", data, self.service_name,
"wallet_ui"))
else:
await super()._state_changed(change)
return
try:
for payload in payloads:
await self.websocket.send_str(payload)
except (BaseException) as e:
try:
self.log.warning(f"Sending data failed. Exception {type(e)}.")
except BrokenPipeError:
pass
async def _state_changed(self, change: str, change_data: Dict) -> List[Dict]:
if change == "new_signage_point":
sp_hash = change_data["sp_hash"]
data = await self.get_signage_point({"sp_hash": sp_hash.hex()})
return [
create_payload(
"new_signage_point",
data,
self.service_name,
"wallet_ui",
string=False,
)
]
elif change == "new_farming_info":
return [
create_payload(
"new_farming_info",
change_data,
self.service_name,
"wallet_ui",
string=False,
)
]
return []
async def _state_changed(self, *args) -> List[str]:
"""
Called by the WalletNode or WalletStateManager when something has changed in the wallet. This
gives us an opportunity to send notifications to all connected clients via WebSocket.
"""
if len(args) < 2:
return []
data = {
"state": args[0],
}
if args[1] is not None:
data["wallet_id"] = args[1]
if args[2] is not None:
data["additional_data"] = args[2]
return [create_payload("state_changed", data, "chia_wallet", "wallet_ui", string=False)]
async def _state_changed(self, *args):
change = args[0]
if self.websocket is None:
return
payloads: List[str] = await self.rpc_api._state_changed(*args)
if change == "add_connection" or change == "close_connection":
data = await self.get_connections({})
payload = create_payload("get_connections", data,
self.service_name, "wallet_ui")
payloads.append(payload)
for payload in payloads:
try:
await self.websocket.send_str(payload)
except Exception as e:
self.log.warning(f"Sending data failed. Exception {type(e)}.")
async def _state_changed(self, change: str):
assert self.websocket is not None
if change == "plots":
data = await self.get_plots({})
payload = create_payload("get_plots", data, self.service_name,
"wallet_ui")
else:
await super()._state_changed(change)
return
try:
await self.websocket.send_str(payload)
except (BaseException) as e:
try:
self.log.warning(f"Sending data failed. Exception {type(e)}.")
except BrokenPipeError:
pass
async def notify_ui_that_state_changed(self, state: str, wallet_id):
data = {
"state": state,
}
# self.log.info(f"Wallet notify id is: {wallet_id}")
if wallet_id is not None:
data["wallet_id"] = wallet_id
if self.websocket is not None:
try:
await self.websocket.send_str(
create_payload("state_changed", data, "chia-wallet", "wallet_ui")
)
except (BaseException) as e:
try:
self.log.warning(f"Sending data failed. Exception {type(e)}.")
except BrokenPipeError:
pass
def format_request(self, command, data=None):
request = create_payload(command, data, "client", "daemon", False)
return request
async def test_daemon_simulation(self, simulation, get_daemon):
node1, node2, _, _, _, _, _, _, _, server1 = simulation
await server1.start_client(PeerInfo(self_hostname, uint16(21238)))
async def num_connections():
count = len(
node2.server.connection_by_type[NodeType.FULL_NODE].items())
return count
await time_out_assert_custom_interval(60, 1, num_connections, 1)
await time_out_assert(1500, node_height_at_least, True, node2, 1)
session = aiohttp.ClientSession()
crt_path = b_tools.root_path / b_tools.config["daemon_ssl"][
"private_crt"]
key_path = b_tools.root_path / b_tools.config["daemon_ssl"][
"private_key"]
ca_cert_path = b_tools.root_path / b_tools.config["private_ssl_ca"][
"crt"]
ca_key_path = b_tools.root_path / b_tools.config["private_ssl_ca"][
"key"]
ssl_context = ssl_context_for_server(ca_cert_path, ca_key_path,
crt_path, key_path)
ws = await session.ws_connect(
"wss://127.0.0.1:55401",
autoclose=True,
autoping=True,
heartbeat=60,
ssl_context=ssl_context,
max_msg_size=100 * 1024 * 1024,
)
service_name = "test_service_name"
data = {"service": service_name}
payload = create_payload("register_service", data, service_name,
"daemon")
await ws.send_str(payload)
message_queue = asyncio.Queue()
async def reader(ws, queue):
while True:
msg = await ws.receive()
if msg.type == aiohttp.WSMsgType.TEXT:
message = msg.data.strip()
message = json.loads(message)
await queue.put(message)
elif msg.type == aiohttp.WSMsgType.PING:
await ws.pong()
elif msg.type == aiohttp.WSMsgType.PONG:
continue
else:
if msg.type == aiohttp.WSMsgType.CLOSE:
await ws.close()
elif msg.type == aiohttp.WSMsgType.ERROR:
await ws.close()
elif msg.type == aiohttp.WSMsgType.CLOSED:
pass
break
read_handler = asyncio.create_task(reader(ws, message_queue))
data = {}
payload = create_payload("get_blockchain_state", data, service_name,
"chia_full_node")
await ws.send_str(payload)
await asyncio.sleep(5)
blockchain_state_found = False
while not message_queue.empty():
message = await message_queue.get()
if message["command"] == "get_blockchain_state":
blockchain_state_found = True
await ws.close()
read_handler.cancel()
assert blockchain_state_found
