async def websocket_handshake(self, request): # let the websockets package do the handshake with the client headers = [] def get_header(k): return request.headers.get(k, '') def set_header(k, v): headers.append((k, v)) try: key = handshake.check_request(get_header) handshake.build_response(set_header, key) except InvalidHandshake: raise InvalidUsage('Invalid websocket request') # write the 101 response back to the client rv = b'HTTP/1.1 101 Switching Protocols\r\n' for k, v in headers: rv += k.encode('utf-8') + b': ' + v.encode('utf-8') + b'\r\n' rv += b'\r\n' request.transport.write(rv) # hook up the websocket protocol self.websocket = WebSocketCommonProtocol( max_size=self.websocket_max_size, max_queue=self.websocket_max_queue) self.websocket.connection_made(request.transport) return self.websocket
def switch_protocols(): ws_protocol = WebSocketCommonProtocol() transport._protocol = ws_protocol ws_protocol.connection_made(transport) # Ensure aiohttp doesn't interfere. http_protocol.transport = None asyncio. async (run_ws_handler(ws_protocol))
async def websocket_handshake(self, request, subprotocols=None): # let the websockets package do the handshake with the client headers = {} try: key = handshake.check_request(request.headers) handshake.build_response(headers, key) except InvalidHandshake: raise InvalidUsage("Invalid websocket request") subprotocol = None if subprotocols and "Sec-Websocket-Protocol" in request.headers: # select a subprotocol client_subprotocols = [ p.strip() for p in request.headers["Sec-Websocket-Protocol"].split(",") ] for p in client_subprotocols: if p in subprotocols: subprotocol = p headers["Sec-Websocket-Protocol"] = subprotocol break # write the 101 response back to the client rv = b"HTTP/1.1 101 Switching Protocols\r\n" for k, v in headers.items(): rv += k.encode("utf-8") + b": " + v.encode("utf-8") + b"\r\n" rv += b"\r\n" request.transport.write(rv) # hook up the websocket protocol self.websocket = WebSocketCommonProtocol( close_timeout=self.websocket_timeout, max_size=self.websocket_max_size, max_queue=self.websocket_max_queue, read_limit=self.websocket_read_limit, write_limit=self.websocket_write_limit, ping_interval=self.websocket_ping_interval, ping_timeout=self.websocket_ping_timeout, ) # we use WebSocketCommonProtocol because we don't want the handshake # logic from WebSocketServerProtocol; however, we must tell it that # we're running on the server side self.websocket.is_client = False self.websocket.side = "server" self.websocket.subprotocol = subprotocol self.websocket.connection_made(request.transport) self.websocket.connection_open() return self.websocket
async def websocket_handshake(self, request, subprotocols=None): # let the websockets package do the handshake with the client headers = [] def get_header(k): return request.headers.get(k, '') def set_header(k, v): headers.append((k, v)) try: key = handshake.check_request(get_header) handshake.build_response(set_header, key) except InvalidHandshake: raise InvalidUsage('Invalid websocket request') subprotocol = None if subprotocols and 'Sec-Websocket-Protocol' in request.headers: # select a subprotocol client_subprotocols = [ p.strip() for p in request.headers['Sec-Websocket-Protocol'].split(',') ] for p in client_subprotocols: if p in subprotocols: subprotocol = p set_header('Sec-Websocket-Protocol', subprotocol) break # write the 101 response back to the client rv = b'HTTP/1.1 101 Switching Protocols\r\n' for k, v in headers: rv += k.encode('utf-8') + b': ' + v.encode('utf-8') + b'\r\n' rv += b'\r\n' request.transport.write(rv) # hook up the websocket protocol self.websocket = WebSocketCommonProtocol( timeout=self.websocket_timeout, max_size=self.websocket_max_size, max_queue=self.websocket_max_queue, read_limit=self.websocket_read_limit, write_limit=self.websocket_write_limit) self.websocket.subprotocol = subprotocol self.websocket.connection_made(request.transport) self.websocket.connection_open() return self.websocket
async def websocket_handshake(self, request, subprotocols=None): headers = {} try: key = handshake.check_request(request.headers) handshake.build_response(headers, key) except InvalidHandshake: msg = "Invalid websocket request received." if self.debug: msg += "\n" + traceback.format_exc() self.logger.error(msg) self.on_response(msg) raise RuntimeError(msg) subprotocol = None if subprotocols and "Sec-Websocket-Protocol" in request.headers: # select a subprotocol client_subprotocols = [ p.strip() for p in request.headers["Sec-Websocket-Protocol"].split(",") ] for p in client_subprotocols: if p in subprotocols: subprotocol = p headers["Sec-Websocket-Protocol"] = subprotocol break # write the 101 response back to the client rv = b"HTTP/1.1 101 Switching Protocols\r\n" for k, v in headers.items(): rv += k.encode("utf-8") + b": " + v.encode("utf-8") + b"\r\n" rv += b"\r\n" request.transport.write(rv) # hook up the websocket protocol self.websocket = WebSocketCommonProtocol( timeout=self.config.ws_timeout, max_size=self.config.ws_max_size, max_queue=self.config.ws_max_queue, read_limit=self.config.ws_read_limit, write_limit=self.config.ws_write_limit, ) self.websocket.subprotocol = subprotocol self.websocket.connection_made(request.transport) self.websocket.connection_open() return self.websocket
async def websocket_handshake(self, request, subprotocols=None): # let the websockets package do the handshake with the client headers = {} try: key = handshake.check_request(request.headers) handshake.build_response(headers, key) except InvalidHandshake: raise InvalidUsage("Invalid websocket request") subprotocol = None if subprotocols and "Sec-Websocket-Protocol" in request.headers: # select a subprotocol client_subprotocols = [ p.strip() for p in request.headers["Sec-Websocket-Protocol"].split(",") ] for p in client_subprotocols: if p in subprotocols: subprotocol = p headers["Sec-Websocket-Protocol"] = subprotocol break # write the 101 response back to the client rv = b"HTTP/1.1 101 Switching Protocols\r\n" for k, v in headers.items(): rv += k.encode("utf-8") + b": " + v.encode("utf-8") + b"\r\n" rv += b"\r\n" request.transport.write(rv) # hook up the websocket protocol self.websocket = WebSocketCommonProtocol( timeout=self.websocket_timeout, max_size=self.websocket_max_size, max_queue=self.websocket_max_queue, read_limit=self.websocket_read_limit, write_limit=self.websocket_write_limit, ) self.websocket.subprotocol = subprotocol self.websocket.connection_made(request.transport) self.websocket.connection_open() return self.websocket
def data_received(self, data): try: if self.enabled: self.websocket.data_received(data) else: self.parser.feed_data(data) except HttpParserError as err: logger.debug(err) import ipdb; ipdb.set_trace() exception = panic_exceptions.InvalidUsage('Bad Request') self.write_error(exception) except HttpParserUpgrade as err: logger.debug(err) self.enabled = True response = panic_response.Response(b'') try: key = handshake.check_request(lambda x: self.headers.get(x).value) handshake.build_response(response.assimilate, key) except InvalidHandshake: exception = panic_exceptions.InvalidUsage('Invalid websocket request') self.write_error(exception) else: self.transport.write(response.channel('1.1')) self.websocket = WebSocketCommonProtocol( timeout=self.timeout, max_size=self.max_size, max_queue=self.max_queue, read_limit=self.read_limit, write_limit=self.write_limit) self.websocket.subprotocol = None #subprotocol self.websocket.connection_made(self.transport) self.websocket.connection_open() self._request_handler_task = self.params.loop.create_task( self.params.request_handler(self.request, self.websocket, self.transport))