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()
