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