async def handle_message(self, raw_message):
message = json.loads(raw_message)
if (not message):
raise Exception(f"message does not appear to be json")
logger.debug("WSConnector: handle_message:")
logger.debug(json.dumps(message, indent=2))
check_json_field(message, 'message', dict, True)
message = message['message'] # Drill down
check_json_field(message, 'messageId', int, True)
check_json_field(message, 'messageType', str, True)
check_json_field(message, 'requiresResponse', bool, True)
message_type = message['messageType']
message_type_prefix = message_type[:message_type.find(":")]
logger.debug(
f"ws_connector: handle_message: message type prefix: {message_type_prefix}"
)
if message_type_prefix == "REST":
await self.handle_rest_message(message)
elif message_type_prefix == "EVENT:":
await self.handle_event_message(message)
else:
if message_type_prefix not in self.handler_table:
raise Exception(
f"unknown message type prefix {message_type_prefix}")
type_handler = self.handler_table[message_type_prefix]
await type_handler.handle_ws_message(message)
async def _resolve(self):
if self._resolved:
return
conn = current_app.engine
await conn.connect()
data = await conn.fetch_one(
f"select * from world where id = {self.world_id}")
if data[2] is not None:
world_data = json.loads(data[2])
self._name = data[1]
self._welcome = world_data['welcome']
self._path = world_data['path']
if 'sky_color' in world_data:
self._sky_color = world_data['sky_color']
if 'skybox' in world_data:
self._skybox = world_data['skybox']
if 'entry' in world_data:
self._entry = world_data['entry'] or '0N 0W'
if 'enable_terrain' in world_data:
self._terrain = world_data['enable_terrain']
with contextlib.suppress(FileNotFoundError):
self._elev = await self.build_elev()
self._resolved = True
await conn.disconnect()
async def ws_writer(websocket, path):
print("ws-test-server: ws_writer: started")
global pending_requests
i = 1
while True:
# message = await producer()
##
## THIS IS JUST FOR TESTING - SEND A GET REQUEST...
##
message = json.dumps({
'message': {
'messageId': i,
'messageType': 'REST:REQUEST',
'requiresResponse': True,
'method': 'GET',
'path': '/micronets/v1/dhcp/subnets'
}
})
print("ws-test-client: > sending client message: ", message)
await websocket.send(message)
print("ws-test-client: > sent client message #", i)
message_future = asyncio.get_event_loop().create_future()
pending_requests[i] = message_future
print("ws-test-client: Waiting for future #", i)
response = await message_future
message = json.loads(response)
print(f"ws-test-client: Got a response from future #{i}: ",
json.dumps(message, indent=2))
print(f"ws-test-client: Sleeping...")
await asyncio.sleep(30)
i += 1
async def ws_reader(websocket, path):
print("ws-test-server: ws_reader: started")
global pending_requests
while True:
message = await websocket.recv()
print("ws-test-server: ws_reader: < received: ", message)
message_json = json.loads(message)['message']
if ('inResponseTo' in message_json):
in_response_to_id = message_json['inResponseTo']
print(
f"ws-test-server: ws_reader: Message {message_json['messageId']} "
f"is a response to {in_response_to_id} - signaling future #{in_response_to_id}"
)
response_future = pending_requests.pop(in_response_to_id)
if (not response_future):
print(
f"ws-test-server: ws_reader: No future found for message {in_response_to_id}!"
)
else:
response_future.set_result(message)
if (message_json['messageType'] == 'REST:REQUEST'):
print(
f"ws-test-server: ws_reader: Found rest {message_json ['method']} request for {message_json ['path']}"
)
await handle_rest_request(websocket, message_json)
def to_geojson(geometry=None, **kwargs):
if geometry is None:
geometry = {}
elif isinstance(geometry, str):
geometry = json.loads(geometry)
return {
'type': 'Feature',
'geometry': geometry,
'properties': {k: v
for k, v in kwargs.items()}
}
async def handle_rest_response(self, request_message_id, response):
encoded_payload = None
if ('Content-Length' in response.headers):
content_length = int(response.headers['Content-Length'])
del response.headers[
'Content-Length'] # The length of content is length of the messageBody
if (content_length > 0):
raw_body = await response.get_data()
content_type = response.headers['Content-Type']
if (content_type == "application/json"):
body = json.loads(raw_body.decode('utf-8'))
else:
body = raw_body.decode('utf-8')
logger.info(
f"WSConnector: handleRestResponse: Response body from Request: {body}"
)
if (content_type == "application/json"):
encoded_payload = json.loads(raw_body)
else:
encoded_payload = raw_body.decode('utf-8')
message = {
'messageType': 'REST:RESPONSE',
'requiresResponse': False,
'inResponseTo': request_message_id,
'statusCode': response.status_code,
'reasonPhrase': None
}
if encoded_payload:
message['dataFormat'] = content_type
message['messageBody'] = encoded_payload
headers = []
for header_name, header_val in response.headers.items():
headers.append({'name': header_name, 'value': header_val})
logger.debug(
f"WSConnector: handle_rest_response: found headers: {headers}")
await self.send_message(message)
logger.debug(f"WSConnector: handle_rest_response: Response sent.")
async def recv_hello_message (self):
raw_message = await self.websocket.recv ()
message = json.loads (raw_message)
if (not message):
raise Exception (f"message does not appear to be json")
hello_message = check_json_field (message, 'message', dict, True)
message_id = check_json_field (hello_message, 'messageId', int, True)
message_type = hello_message ['messageType']
requires_response = check_json_field (hello_message, 'requiresResponse', bool, True)
if (not message_type == "CONN:HELLO"):
raise Exception (f"message does not appear to be a CONN:HELLO message (found {message_type})")
self.hello_message = message
return self.hello_message
async def dlsong():
data = await request.get_data()
data = data.decode('utf-8')
data = json.loads(data)
logging.debug(data)
try:
url, fmt = data['url'], data.get('format') or data.get('fmt')
except KeyError:
raise BadRequest
# Do something with it
print(url, fmt)
return create_task()
async def wait_for_hello_message(self):
raw_message = await self.websocket.recv()
message = json.loads(raw_message)
logger.debug(
f"ws_connector: process_hello_messages: Received message: {message}"
)
if (not message):
raise Exception(f"message does not appear to be json")
hello_message = check_json_field(message, 'message', dict, True)
message_id = check_json_field(hello_message, 'messageId', int, True)
message_type = check_json_field(hello_message, 'messageType', str,
True)
check_json_field(hello_message, 'requiresResponse', bool, False)
if (not message_type == "CONN:HELLO"):
raise Exception(
f"Unexpected message while waiting for HELLO: {message_type}")
logger.debug(
f"ws_connector: process_hello_messages: Received HELLO message")
async def count():
start = time.time()
urls = [[f'https://postman-echo.com/get?count={x}', x]
for x in range(1, 101)]
futures = [asyncio.ensure_future(fetch(url[0], url[1])) for url in urls]
output = ""
for future in futures:
try:
resp = await future
except Exception as error:
output += f'<br> Failed: {error}'
continue
else:
data = json.loads(resp['html'].decode())
now = time.time()
output += f'<br> {resp["url"]} responded with {json.dumps(data["args"])} ({now - start} seconds elapsed)'
end = time.time()
output += f'<p> This all took {(end - start)} seconds.</p>'
return output
def loads(self, value: str) -> Any:
return loads(value, object_hook=self.untag)
async def handle_hostapd_ready(self):
logger.info(f"DPPHandler.handle_hostapd_ready()")
self.ssid = self.hostapd_adapter.get_status_var('ssid')[0]
logger.info(f"DPPHandler.handle_hostapd_ready: SSID: {self.ssid}")
self.freq = self.hostapd_adapter.get_status_var('freq')
logger.info(f"DPPHandler.handle_hostapd_ready: FREQ: {self.freq}")
if self.dpp_config_key_file.exists():
try:
dpp_config_key = self.dpp_config_key_file.read_text()
logger.info(
f"DPPHandler.handle_hostapd_ready: Loaded DPP configurator key from {self.dpp_config_key_file}"
)
except Exception as ex:
logger.warning(
f"DPPHandler: handle_hostapd_ready: Caught exception reading {self.dpp_config_key_file}: {ex}"
)
return
else:
# Create a prime256v1 key
dpp_config_key = ecdsa.SigningKey.generate(
curve=ecdsa.NIST256p).to_der().hex()
self.dpp_config_key_file.write_text(dpp_config_key)
logger.info(
f"DPPHandler.handle_hostapd_ready: Saved new configurator key to {self.dpp_config_key_file}"
)
add_configurator_cmd = HostapdAdapter.DPPAddConfiguratorCLICommand(
curve="prime256v1", key=dpp_config_key)
await self.hostapd_adapter.send_command(add_configurator_cmd)
self.dpp_configurator_id = await add_configurator_cmd.get_configurator_id(
)
logger.info(
f"DPPHandler.handle_hostapd_ready: DPP Configurator ID: {self.dpp_configurator_id}"
)
try:
if self.dpp_ap_connector_file.exists():
self.dpp_ap_connector = json.loads(
self.dpp_ap_connector_file.read_text())
logger.info(
f"DPPHandler.handle_hostapd_ready: Loaded AP Connector from {self.dpp_ap_connector_file}"
)
else:
# Create the AP's connector and persist it
logger.info(
f"DPPHandler: handle_hostapd_ready: Creating a DPP Connector for the AP"
)
dpp_config_sign_cmd = HostapdAdapter.DPPConfiguratorDPPSignCLICommand(
self.dpp_configurator_id, self.ssid)
await self.hostapd_adapter.send_command(dpp_config_sign_cmd)
dpp_connector = await dpp_config_sign_cmd.get_connector()
logger.info(
f"DPPHandler: handle_hostapd_ready: Connector: {dpp_connector}"
)
dpp_c_sign_key = await dpp_config_sign_cmd.get_c_sign_key()
logger.info(
f"DPPHandler: handle_hostapd_ready: DPP c-sign-key: {dpp_c_sign_key}"
)
dpp_net_access_key = await dpp_config_sign_cmd.get_net_access_key(
)
logger.info(
f"DPPHandler: handle_hostapd_ready: Net access key: {dpp_net_access_key}"
)
self.dpp_ap_connector = {
"dpp_connector": dpp_connector,
"dpp_csign": dpp_c_sign_key,
"dpp_netaccesskey": dpp_net_access_key
}
dpp_ap_connector_json = json.dumps(self.dpp_ap_connector,
indent=3) + "\n"
self.dpp_ap_connector_file.write_text(dpp_ap_connector_json)
await self.hostapd_adapter.send_command(
HostapdAdapter.SetCLICommand(
"dpp_connector", self.dpp_ap_connector['dpp_connector']))
await self.hostapd_adapter.send_command(
HostapdAdapter.SetCLICommand(
"dpp_csign", self.dpp_ap_connector['dpp_csign']))
await self.hostapd_adapter.send_command(
HostapdAdapter.SetCLICommand(
"dpp_netaccesskey",
self.dpp_ap_connector['dpp_netaccesskey']))
except Exception as ex:
logger.warning(
f"DPPHandler: handle_hostapd_ready: Caught exception processing DPP AP connector {self.dpp_ap_connector_file}: {ex}",
exc_info=True)
return
