def _do_stream(self, message, payload, camera_mac, stream): response = aiohttp.Response(self.writer, 200, http_version=message.version) try: self._context = yield from controller.stream_camera( camera_mac, stream, response) except NoSuchCamera: response = aiohttp.Response(self.writer, 404) response.send_headers() response.write_eof() return except CameraInUse: response = aiohttp.Response(self.writer, 409) response.send_headers() response.write_eof() return while (self._context.streaming and controller.ws_server.is_camera_managed(camera_mac)): yield from asyncio.sleep(1) self._log.debug('Closing HTTP streaming connection for %s' % camera_mac) response.write_eof() self._context.controller.streaming_stopped(self._context)
def _do_say(self, message, payload): text = yield from payload.read() event = {'speak': text.decode()} if WS_WRITER: if ARGS.tone: play_sound(ARGS.tone) WS_WRITER.send(json.dumps(event).encode()) LOG.debug('Queued %r' % text) resp = aiohttp.Response(self.writer, 200) else: LOG.error('No waiting speaker!') resp = aiohttp.Response(self.writer, 500) resp.send_headers() return resp
def _get_static(self, message): fn = message.path.split('/')[-1] fn = os.path.join('static', fn) try: with open(fn) as f: resp = aiohttp.Response(self.writer, 200) resp.send_headers() resp.write(f.read().encode()) LOG.debug('200 GET %s' % fn) except FileNotFoundError: resp = aiohttp.Response(self.writer, 404) resp.send_headers() LOG.error('404 GET %s' % fn) return resp
def handle_request(self, message, payload): if properties.get('close', False): return for hdr, val in message.headers.items(): if (hdr == 'EXPECT') and (val == '100-continue'): self.transport.write(b'HTTP/1.0 100 Continue\r\n\r\n') break if router is not None: body = yield from payload.read() rob = router( self, properties, self.transport, message, body) rob.dispatch() else: response = aiohttp.Response(self.writer, 200, message.version) text = b'Test message' response.add_header('Content-type', 'text/plain') response.add_header('Content-length', str(len(text))) response.send_headers() response.write(text) response.write_eof()
def handle_request(self, message, payload): if properties.get('close', False): return if properties.get('noresponse', False): yield from asyncio.sleep(99999) for hdr, val in message.headers: if (hdr == 'EXPECT') and (val == '100-continue'): self.transport.write(b'HTTP/1.0 100 Continue\r\n\r\n') break if router is not None: body = bytearray() try: while True: body.extend((yield from payload.read())) except aiohttp.EofStream: pass rob = router(self, properties, self.transport, message, bytes(body)) rob.dispatch() else: response = aiohttp.Response(self.transport, 200, message.version) text = b'Test message' response.add_header('Content-type', 'text/plain') response.add_header('Content-length', str(len(text))) response.send_headers() response.write(text) response.write_eof()
async def handle_request(self, message, payload): # /avatar/token/<acctid>/<backendid>/<userid> parts = message.path.split('/') status_code = 404 ct = "text/html" msg = b"<h1>Not found</h1>" if len(parts) == 6: # ('', 'avatar', 'token', id, id, id) _, ns, token, acctid, backendid, userid = parts if ns == 'avatar': account = manager.get_by_id(int(acctid)) be = account.get_backend_by_id(int(backendid)) user = be.get_user_by_id(int(userid)) msg = user.get_avatar() status_code = 200 ct = "image/png" response = aiohttp.Response( self.writer, status_code, http_version=message.version ) response.add_header('Content-Type', ct) response.add_header('Content-Length', str(len(msg))) response.send_headers() response.write(msg) await response.write_eof()
def start_response(self, status, headers, exc_info=None): if exc_info: try: if self.status: raise exc_info[1] finally: exc_info = None status_code = int(status.split(' ', 1)[0]) self.status = status resp = self.response = aiohttp.Response(self.writer, status_code, self.message.version, self.message.should_close) resp.HOP_HEADERS = self.HOP_HEADERS resp.add_headers(*headers) if resp.has_chunked_hdr: resp.enable_chunked_encoding() # send headers immediately for websocket connection if status_code == 101 and resp.upgrade and resp.websocket: resp.send_headers() else: resp._send_headers = True return self.response.write
def handle_request(self, message, payload): websock_chan_id = message.headers.get('websock-chan-id') upgrade = 'websocket' in message.headers.get('UPGRADE', '').lower() if upgrade: status, headers, parser, writer = websocket.do_handshake( message.method, message.headers, self.transport) resp = aiohttp.Response(self.writer, status, http_version=message.version) resp.add_headers(*headers) resp.send_headers() connection = yield from asyncio_redis.Connection.create( host='127.0.0.1', port=6379) subscriber = yield from connection.start_subscribe() yield from subscriber.subscribe([str(websock_chan_id)]) while True: try: data = yield from subscriber.next_published() print(data) writer.send(data.value.encode()) except Exception as e: print(e) break self.clients[websock_chan_id].remove(writer)
def handle_request(self, message, payload): """Handle a single HTTP request. Subclass should override this method. By default it always returns 404 response. :param message: Request headers :type message: aiohttp.protocol.HttpRequestParser :param payload: Request payload :type payload: aiohttp.streams.FlowControlStreamReader """ now = self._loop.time() response = aiohttp.Response(self.writer, 404, http_version=message.version, close=True) body = b'Page Not Found!' response.add_header(hdrs.CONTENT_TYPE, 'text/plain') response.add_header(hdrs.CONTENT_LENGTH, str(len(body))) response.send_headers() response.write(body) drain = response.write_eof() self.keep_alive(False) self.log_access(message, None, response, self._loop.time() - now) return drain
def handle_request(self, message, payload): if self.auth_passwd: auth_secret = message.headers.get('AUTHORIZATION') if not auth_secret or auth_secret[:6].upper( ) != 'BASIC ' or auth_secret[6:] not in self.auth_passwd: response = aiohttp.Response(self.writer, 401, http_version=message.version) response.SERVER_SOFTWARE = 'HTTPd' response.add_header('WWW-Authenticate', 'Basic realm="%s"' % self.auth_realm) response.add_header('Content-Length', '0') response.send_headers() yield from response.write_eof() return url = message.path if url.startswith(self.path_prefix): url = url[len(self.path_prefix):] else: return (yield from self.send_404(message, payload, url)) if not url or url == '/': return (yield from self.send_homepage(message, payload)) elif url == '/about/empty.js': return (yield from self.send_empty_js(message, payload)) elif url.startswith('/about/openwepro.js?'): return (yield from self.send_js(message, payload)) target_url = self.parse_url(url, False) if target_url is None: return (yield from self.send_404(message, payload, url)) else: return (yield from self.do_http_proxy(message, payload, target_url)) return (yield from self.send_404(message, payload, url))
def handle_request(self, message, payload): params = parse_qs(message.path[2:]) question = params.get("question", [None])[0] logging.debug("params: %r, question: %s", params, question) if not message.path.startswith("/?") or question is None: answer = "Invalid request" code = 404 else: _knowledge_engine = knowledge_engine.KnowledgeEngine() answer = yield from _knowledge_engine.getAnswer(question) code = 200 logging.debug("Will send response '%s', code %d", answer, code) content = "{}\r\n".format(answer).encode(config.ENCODING) response = aiohttp.Response(self.writer, code, http_version=message.version) response.add_header("ContentType", "text/plain; charset={}".format(config.ENCODING)) response.add_header("ContentLength", str(len(answer))) response.send_headers() response.write(content) yield from response.write_eof()
def handle_request(self, message, payload): """Handle a single http request. Subclass should override this method. By default it always returns 404 response. info: aiohttp.RequestLine instance message: aiohttp.RawHttpMessage instance """ now = time.time() response = aiohttp.Response(self.writer, 404, http_version=message.version, close=True) body = b'Page Not Found!' response.add_headers(('Content-Type', 'text/plain'), ('Content-Length', str(len(body)))) response.send_headers() response.write(body) drain = response.write_eof() self.keep_alive(False) self.log_access(message, None, response, time.time() - now) return drain
def handle_error(self, status=500, message=None, payload=None, exc=None, headers=None, reason=None): """Handle errors. Returns HTTP response with specific status code. Logs additional information. It always closes current connection.""" now = self._loop.time() try: if self.transport is None: # client has been disconnected during writing. return () if status == 500: self.log_exception("Error handling request") try: if reason is None or reason == '': reason, msg = RESPONSES[status] else: msg = reason except KeyError: status = 500 reason, msg = '???', '' if self.debug and exc is not None: try: tb = traceback.format_exc() tb = html_escape(tb) msg += '<br><h2>Traceback:</h2>\n<pre>{}</pre>'.format(tb) except: pass html = DEFAULT_ERROR_MESSAGE.format(status=status, reason=reason, message=msg).encode('utf-8') response = aiohttp.Response(self.writer, status, close=True) response.add_header(hdrs.CONTENT_TYPE, 'text/html; charset=utf-8') response.add_header(hdrs.CONTENT_LENGTH, str(len(html))) if headers is not None: for name, value in headers: response.add_header(name, value) response.send_headers() response.write(html) # disable CORK, enable NODELAY if needed self.writer.set_tcp_nodelay(True) drain = response.write_eof() self.log_access(message, None, response, self._loop.time() - now) return drain finally: self.keep_alive(False)
def send_response(self, status, http_version, headers = None, text = b''): response = aiohttp.Response(self.writer, status, http_version = http_version) if isinstance(headers, list): for name, value in headers: response.add_header(name, value) response.add_header('Content-Length', str(len(text))) response.send_headers() response.write(text) yield from response.write_eof()
async def handle_request(self, message, payload): response = aiohttp.Response( self.writer, 200, http_version=message.version ) response.add_header('Content-Type', 'text/html') response.add_header('Content-Length', '18') response.send_headers() response.write(b'<h1>It Works!</h1>') await response.write_eof()
async def handle_request(self, message, payload): response = aiohttp.Response(self.writer, 200, http_version=message.version) response.add_header('Content-Type', 'text/html') response.add_header('Content-Length', str(len(PAYLOAD))) response.send_headers() response.write(PAYLOAD) await response.write_eof()
def send_homepage(self, message, payload): response = aiohttp.Response(self.writer, 200, http_version=message.version) response.add_header('Content-Type', 'text/html; charset=utf-8') response.add_header('Content-Length', str(len(self.clienthtml))) response.send_headers() response.write(self.clienthtml) yield from response.write_eof()
def handle_request(self, message, payload): response = aiohttp.Response(self.writer, 200, message.version) text = b'Test message' response.add_header('Content-type', 'text/plain') response.add_header('Content-length', str(len(text))) response.send_headers() response.write(text) response.write_eof()
def make_response(self, code, *headers, content_type=None): content_type = content_type if content_type else "text/html" response = aiohttp.Response(self.writer, code) response.add_header('Transfer-Encoding', 'chunked') response.add_header('Content-Type', content_type) for k, v in headers: response.add_header(k, v) response.send_headers() return response
def send_response(self, code, version, text=b""): response = aiohttp.Response( self.writer, code, http_version=version ) response.add_header("Content-type", "text/xml") response.add_header("Content-length", str(len(text))) response.send_headers() response.write(text) yield from response.write_eof()
def send_404(self, message, payload, url): responseHtml = b'<h1>Error 404: Not Found</h1>' response = aiohttp.Response(self.writer, 404, http_version=message.version) response.add_header('Content-Type', 'text/html; charset=utf-8') response.add_header('Content-Length', str(len(responseHtml))) response.send_headers() response.write(responseHtml) yield from response.write_eof()
def send_empty_js(self, message, payload): response = aiohttp.Response(self.writer, 200, http_version=message.version) response.add_header('Cache-Control', 'max-age=604800') response.add_header('Content-Type', 'application/javascript; charset=utf-8') response.add_header('Content-Length', '6') response.send_headers() response.write(b'void 0') yield from response.write_eof()
def handle_request(self, message, payload): print('method = {!r}; path = {!r}; version = {!r}'.format( message.method, message.path, message.version)) if message.method == 'POST' and message.path == '/rpc': if not 'Authorization' in message.headers: response = aiohttp.Response(self.writer, 401, http_version=message.version) response.add_header('Content-Length', '0') response.add_header('WWW-Authenticate', 'Token') response.send_headers() return authorization = message.headers.get('Authorization').split(' ') if authorization[0] != 'Token' or not constant_time_equals( authorization[1], self.auth_token): response = aiohttp.Response(self.writer, 403, http_version=message.version) response.add_header('Content-Length', '0') response.send_headers() return # authorization passed, process the request. data = yield from payload.read() response = aiohttp.Response(self.writer, 200, http_version=message.version) result = self.process_request(data) response.add_header('Content-Length', str(len(result))) response.send_headers() response.write(result) else: response = aiohttp.Response(self.writer, 405, http_version=message.version) response.add_header('Accept', 'POST') response.send_headers()
def handle_request(self, message, payload): response = aiohttp.Response(self.writer, 200, http_version=message.version) response.add_header('Content-type', 'application/json') response.send_headers() response.write( json.dumps( sorted([(k, v) for k, v in self.last_check_dict.items()], key=lambda x: x[1].get('time'))).encode('ascii')) yield from response.write_eof()
def handle_error(self, status=500, message=None, payload=None, exc=None, headers=None): now = time.time() if isinstance(exc, errors.RESTError): resp_impl = aiohttp.Response(self.writer, status, close=True) resp_impl.add_header('Host', self.hostname) exc.write_response(resp_impl) self.log_access(message, None, resp_impl, time.time() - now) self.keep_alive(False) else: super().handle_error(status, message, payload, exc=exc, headers=headers)
async def process_parallel(self, message: RawRequestMessage, payload) -> aiohttp.Response: """Try process a request parallel. Returns True in case of processed parallel, otherwise False.""" # Checking the opportunity of parallel downloading. if message.method != hdrs.METH_GET or not need_file_to_parallel( message.path): return None head = await self.get_file_head(message.path) if head is None: return None accept_ranges = head.get(hdrs.ACCEPT_RANGES).lower() == 'bytes' if not accept_ranges: return None content_length = head.get(hdrs.CONTENT_LENGTH) if content_length is None: return None content_length = int(content_length) if content_length <= 0: return None # All checks pass, start a parallel downloading. # TODO: log as access, not as debug. self.log_debug("PARALLEL GET {!r} [{!s} bytes]".format( message.path, content_length)) # Get additional file info. content_type = head.get(hdrs.CONTENT_TYPE) # Prepare a response to a client. client_res = aiohttp.Response(self.writer, 200, http_version=message.version) client_res.add_header(hdrs.CONTENT_LENGTH, str(content_length)) if content_type: client_res.add_header(hdrs.CONTENT_TYPE, content_type) client_res.send_headers() pd = ParallelDownloader(message.path, content_length, parallels=self._parallels, chunk_size=self._chunk_size, loop=self._loop) try: await pd.download() await pd.read(lambda chunk: client_res.write(chunk)) client_res.write_eof() except Exception as exc: self.log_debug("CANCELLED PARALLEL GET {!r}.".format(message.path)) raise finally: await pd.clear() return client_res
def _r(request, *args, **kwargs): status, headers, parser, writer, _ = websocket.do_handshake( request.message.method, request.message.headers, request.handler.transport) resp = aiohttp.Response(request.handler.writer, status, http_version=request.message.version) resp.add_headers(*headers) resp.send_headers() request.writer = writer request.reader = request.handler.reader.set_parser(parser) yield from fn(request, *args, **kwargs)
async def handle_limit(self, message, domain, gen_time): dt = await self._limiter.rate_limit(domain, int(gen_time)) resp_text = '{"delay":%i}' % dt resp_body = resp_text.encode('utf-8') response = aiohttp.Response(self.writer, 200, http_version=message.version) response.add_header('Content-Type', 'application/json') response.add_header('Content-Length', str(len(resp_body))) response.send_headers() response.write(resp_body) await response.write_eof()
def handle_request(self, message, payload): response = aiohttp.Response(self.writer, 200, http_version=message.version) response.add_header('Content-Type', 'text/html') response.send_headers() if message.path == '/': response.write(render('main page').encode('utf-8')) elif message.path == '/close': asyncio.get_event_loop().stop() else: response.write(render(message.path[1:]).encode('utf-8')) yield from response.write_eof()
def handle_request(self, message, payload): response = aiohttp.Response(self.writer, 200, http_version=message.version) n = int(message.path.partition('/')[2]) response.add_header('Content-Type', 'text/plain') # response.add_header('Content-Length', '18') response.send_headers() for i in range(n): response.write( b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n' ) yield from response.write_eof()