def test_write_non_byteish(self):
resp = StreamResponse()
self.loop.run_until_complete(
resp.prepare(self.make_request('GET', '/')))
with self.assertRaises(AssertionError):
resp.write(123)
async def download(self):
file = self.field.get(self.context)
if file is None:
raise AttributeError('No field value')
resp = StreamResponse(headers=multidict.MultiDict({
'CONTENT-DISPOSITION': 'attachment; filename="%s"' % file.filename
}))
resp.content_type = file.contentType
if file.size:
resp.content_length = file.size
buf = BytesIO()
downloader = await file.download(buf)
await resp.prepare(self.request)
# response.start(request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download {}%.".format(int(status.progress() * 100)))
buf.seek(0)
data = buf.read()
resp.write(data)
await resp.drain()
buf.seek(0)
buf.truncate()
return resp
async def get(self, user: dict):
file = await self.fetch_file(int(self.request.match_info['file']))
if not file:
raise HTTPNotFound
headers = {
'Content-Type':
parse_data_key(file['ext'], 'files'),
'Content-Disposition':
'attachment; filename={file}'.format(file=file['nombre'])
}
response = StreamResponse(status=200, reason='OK', headers=headers)
chunks = tuple(get_chunks(file['contenido']))
await response.prepare(self.request)
for i in range(0, len(chunks)):
try:
response.write(chunks[i])
await response.drain()
except Exception as e:
print(repr(e))
del file, chunks
return response
async def download(self, video):
resp = StreamResponse(
status=200,
headers={
'Content-Disposition':
f'attachment; filename="{video.get("filename", "video.mv4")}"'
})
resp.content_length = video['size']
resp.content_type = 'video/' + self.get_video_ext(video)
# request all data...
written = 0
await resp.prepare(self.request)
while True:
data = await downloader.get_range(video,
written,
written + (1024 * 1024 * 5),
preload_end=False)
if data:
written += len(data)
resp.write(data)
try:
await asyncio.sleep(0.001)
await resp.drain()
except concurrent.futures.CancelledError:
pass
else:
break
return resp
async def tick(request):
if 'text/event-stream' not in request.headers.getall('ACCEPT', []):
raise HTTPNotAcceptable(
reason="'text/event-stream' not found in Accept headers.")
resp = StreamResponse(status=200,
reason='OK',
headers={
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive'
})
log.debug('Opening new event stream on request: %s', request)
await resp.prepare(request)
request.app.connections.add(resp)
resp.should_stop = False
try:
while not resp.should_stop:
ts = time.monotonic()
payload = json.dumps({'data': ts})
resp.write(build_message(payload, id=ts, event='tick'))
await resp.drain()
await asyncio.sleep(1)
finally:
request.app.connections.remove(resp)
return resp
async def report_msg_home(request):
resp = StreamResponse()
data = await request.json()
global running_state
global last_history_time
print("report_msg_home: " + data['url'])
# print(data['body'])
last_history_time = time.clock()
msglist_str = re.findall('var msgList = \'(\{.*?\})\'\;', data['body'])
if len(msglist_str) > 0:
msglist_str = msglist_str[0]
msglist_str = msglist_str.replace('"', '"').replace('\\', '')
biz_arr = re.findall('__biz=(.*?)\&', data['url'])
if len(biz_arr) > 0:
biz = biz_arr[0]
else:
biz = ''
msglist = json.loads(msglist_str)
save_data(biz, msglist['list'])
resp.content_type = 'text/plain'
await resp.prepare(request)
if running_state == STATE_IN_TRANSACTION:
# inject javascript code so that it redirects to a new Wechat Account Home
running_state = STATE_RUNNING
resp.write(
("https://mp.weixin.qq.com/mp/profile_ext?action=home&__biz=" +
bizs.pop() + "&scene=124#wechat_redirect").encode('utf8'))
else:
resp.write("NULL".encode('utf8'))
await resp.write_eof()
return resp
async def hello(request):
resp = StreamResponse()
name = request.match_info.get('name', 'Anonymous')
answer = ('Hello, ' + name).encode('utf8')
resp.content_length = len(answer)
await resp.prepare(request)
resp.write(answer)
await resp.write_eof()
return resp
async def hello(request):
resp = StreamResponse()
name = request.match_info.get('name', 'Anonymous')
answer = ('Hello, ' + name).encode('utf8')
resp.content_length = len(answer)
await resp.prepare(request)
resp.write(answer)
await resp.write_eof()
return resp
def hello(request):
resp = StreamResponse()
name = request.match_info.get('name', 'Anonymous')
answer = ('Hello, ' + name).encode('utf8')
resp.content_length = len(answer)
resp.start(request)
resp.write(answer)
yield from resp.write_eof()
return resp
def hello(request):
resp = StreamResponse(request)
name = request.match_info.get('name', 'Anonimous')
answer = ('Hello, ' + name).encode('utf8')
resp.content_length = len(answer)
resp.send_headers()
resp.write(answer)
yield from resp.write_eof()
return resp
def intro(request):
txt = textwrap.dedent("""\
Type {url}/hello/John {url}/simple or {url}/change_body
in browser url bar
""").format(url='127.0.0.1:8080')
binary = txt.encode('utf8')
resp = StreamResponse(request)
resp.content_length = len(binary)
resp.write(binary)
return resp
def intro(request):
txt = textwrap.dedent("""\
Type {url}/hello/John {url}/simple or {url}/change_body
in browser url bar
""").format(url='127.0.0.1:8080')
binary = txt.encode('utf8')
resp = StreamResponse(request)
resp.content_length = len(binary)
resp.write(binary)
return resp
def test___repr___after_eof():
resp = StreamResponse()
yield from resp.prepare(make_request('GET', '/'))
assert resp.prepared
resp.write(b'data')
yield from resp.write_eof()
assert not resp.prepared
resp_repr = repr(resp)
assert resp_repr == '<StreamResponse OK eof>'
def test___repr___after_eof():
resp = StreamResponse()
yield from resp.prepare(make_request('GET', '/'))
assert resp.prepared
resp.write(b'data')
yield from resp.write_eof()
assert not resp.prepared
resp_repr = repr(resp)
assert resp_repr == '<StreamResponse OK eof>'
def test_cannot_write_eof_twice(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
resp.write(b'data')
self.writer.drain.return_value = ()
self.loop.run_until_complete(resp.write_eof())
self.assertTrue(self.writer.write.called)
self.writer.write.reset_mock()
self.loop.run_until_complete(resp.write_eof())
self.assertFalse(self.writer.write.called)
def test_cannot_write_eof_twice(self):
resp = StreamResponse()
self.loop.run_until_complete(resp.prepare(self.make_request("GET", "/")))
resp.write(b"data")
self.writer.drain.return_value = ()
self.loop.run_until_complete(resp.write_eof())
self.assertTrue(self.writer.write.called)
self.writer.write.reset_mock()
self.loop.run_until_complete(resp.write_eof())
self.assertFalse(self.writer.write.called)
def test_cannot_write_eof_twice(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
resp.write(b'data')
self.writer.drain.return_value = ()
self.loop.run_until_complete(resp.write_eof())
self.assertTrue(self.writer.write.called)
self.writer.write.reset_mock()
self.loop.run_until_complete(resp.write_eof())
self.assertFalse(self.writer.write.called)
def test_cannot_write_after_eof(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
resp.write(b'data')
self.writer.drain.return_value = ()
self.loop.run_until_complete(resp.write_eof())
self.writer.write.reset_mock()
with self.assertRaises(RuntimeError):
resp.write(b'next data')
self.assertFalse(self.writer.write.called)
def test_cannot_write_after_eof(self):
resp = StreamResponse()
self.loop.run_until_complete(resp.prepare(self.make_request("GET", "/")))
resp.write(b"data")
self.writer.drain.return_value = ()
self.loop.run_until_complete(resp.write_eof())
self.writer.write.reset_mock()
with self.assertRaises(RuntimeError):
resp.write(b"next data")
self.assertFalse(self.writer.write.called)
def test_write_deprecated(loop, stream):
writer = http_writer.PayloadWriter(stream, loop)
request = make_request('GET', '/', payload_writer=writer)
response = StreamResponse()
yield from response.prepare(request)
with pytest.warns(DeprecationWarning) as ctx:
response.write(b'data')
# Assert the warning points at us and not at _CoroGuard.
assert ctx.list[0].filename == __file__
def test_cannot_write_after_eof(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
resp.write(b'data')
self.writer.drain.return_value = ()
self.loop.run_until_complete(resp.write_eof())
self.writer.write.reset_mock()
with self.assertRaises(RuntimeError):
resp.write(b'next data')
self.assertFalse(self.writer.write.called)
def test_cannot_write_after_eof():
resp = StreamResponse()
writer = mock.Mock()
yield from resp.prepare(make_request('GET', '/', writer=writer))
resp.write(b'data')
writer.drain.return_value = ()
yield from resp.write_eof()
writer.write.reset_mock()
with pytest.raises(RuntimeError):
resp.write(b'next data')
assert not writer.write.called
def test_cannot_write_eof_twice():
resp = StreamResponse()
writer = mock.Mock()
yield from resp.prepare(make_request('GET', '/', writer=writer))
resp.write(b'data')
writer.drain.return_value = ()
yield from resp.write_eof()
assert writer.write.called
writer.write.reset_mock()
yield from resp.write_eof()
assert not writer.write.called
def test_cannot_write_after_eof():
resp = StreamResponse()
writer = mock.Mock()
yield from resp.prepare(make_request('GET', '/', writer=writer))
resp.write(b'data')
writer.drain.return_value = ()
yield from resp.write_eof()
writer.write.reset_mock()
with pytest.raises(RuntimeError):
resp.write(b'next data')
assert not writer.write.called
def test_cannot_write_eof_twice():
resp = StreamResponse()
writer = mock.Mock()
yield from resp.prepare(make_request('GET', '/', writer=writer))
resp.write(b'data')
writer.drain.return_value = ()
yield from resp.write_eof()
assert writer.write.called
writer.write.reset_mock()
yield from resp.write_eof()
assert not writer.write.called
def test_repr_after_eof():
resp = StreamResponse()
writer = mock.Mock()
yield from resp.prepare(make_request('GET', '/', writer=writer))
assert resp.prepared
resp.write(b'data')
writer.drain.return_value = ()
yield from resp.write_eof()
assert not resp.prepared
resp_repr = repr(resp)
assert resp_repr == '<StreamResponse OK not started>'
async def test_cannot_write_after_eof():
resp = StreamResponse()
writer = mock.Mock()
resp_impl = await resp.prepare(make_request('GET', '/', writer=writer))
resp_impl.write_eof = make_mocked_coro(None)
resp.write(b'data')
await resp.write_eof()
writer.write.reset_mock()
with pytest.raises(RuntimeError):
resp.write(b'next data')
assert not writer.write.called
async def handle(request):
server = request.app['server']
car = server.car
_width = int(request.query.get('width', 1280)) # noqa: F841
_height = int(request.query.get('height', 720)) # noqa: F841
response = StreamResponse()
response.headers[
'Content-Type'] = 'multipart/x-mixed-replace; boundary=frame'
response.headers['Cache-Control'] = 'no-cache'
response.headers['Connection'] = 'keep-alive'
# response.enable_chunked_encoding()
await response.prepare(request)
while True:
try:
image = car.get_camera_image()
response.write(b'--frame\r\n')
response.write(b'Content-Type: image/jpeg\r\n\r\n')
response.write(image.tobytes())
response.write(b'\r\n')
await response.drain()
await asyncio.sleep(1 / server.cfg.camera.framerate)
except asyncio.CancelledError as e:
break
except Exception as e:
# https://github.com/aio-libs/aiohttp/issues/1893
logger.exception(e)
break
await response.write_eof()
return response
async def __call__(self):
if hasattr(self.context, '_file_path'):
with open(self.context._file_path, 'rb') as f:
filename = basename(self.context._file_path)
resp = StreamResponse(headers=aiohttp.MultiDict({
'CONTENT-DISPOSITION': 'attachment; filename="%s"' % filename
}))
resp.content_type = mimetypes.guess_type(self.context._file_path)
data = f.read()
resp.content_length = len(data)
await resp.prepare(self.request)
resp.write(data)
return resp
async def __call__(self):
if hasattr(self.context, 'file_path'):
filepath = str(self.context.file_path.absolute())
filename = self.context.file_path.name
with open(filepath, 'rb') as f:
resp = StreamResponse(headers={
'CONTENT-DISPOSITION': 'attachment; filename="%s"' % filename
})
resp.content_type = mimetypes.guess_type(filename)
data = f.read()
resp.content_length = len(data)
await resp.prepare(self.request)
resp.write(data)
return resp
async def test_cannot_write_eof_twice():
resp = StreamResponse()
writer = mock.Mock()
resp_impl = await resp.prepare(make_request('GET', '/'))
resp_impl.write = make_mocked_coro(None)
resp_impl.write_eof = make_mocked_coro(None)
resp.write(b'data')
assert resp_impl.write.called
await resp.write_eof()
resp_impl.write.reset_mock()
await resp.write_eof()
assert not writer.write.called
async def tick(request):
#print('what??')
if 'text/event-stream' not in request.headers.getall('ACCEPT', []):
raise HTTPNotAcceptable(
reason="'text/event-stream' not found in Accept headers.")
resp = StreamResponse(status=200,
reason='OK',
headers={
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive'
})
log.debug('Opening new event stream on request: %s', request)
await resp.prepare(request)
request.app.connections.add(resp)
resp.should_stop = False
try:
while not resp.should_stop:
ts = time.monotonic()
print('ã…Žã…Žã…Ž')
#fut = asyncio.open_connection('utylee.dlinkddns.com', 1117, loop=loop)
'''
try:
reader, writer = await asyncio.wait_for(fut, timeout=3)
except:
ts = 'exception, maybe Timeout...'
print(ts)
return
'''
'''
writer.write('utyleeping'.encode())
rbuf = await reader.read(100)
print(f'rbuf:{rbuf}')
ts = rbuf.decode()
'''
payload = json.dumps({'data': ts})
resp.write(build_message(payload, id=ts, event='tick'))
await resp.drain()
await asyncio.sleep(5)
finally:
request.app.connections.remove(resp)
return resp
def test_write_coro(loop, stream):
writer = http_writer.PayloadWriter(stream, loop)
request = make_request('GET', '/', payload_writer=writer)
response = StreamResponse()
yield from response.prepare(request)
yield from response.write(b'data')
def test_cannot_write_eof_twice():
resp = StreamResponse()
writer = mock.Mock()
resp_impl = yield from resp.prepare(make_request('GET', '/'))
resp_impl.write = mock.Mock()
resp_impl.write_eof = mock.Mock()
resp_impl.write_eof.return_value = ()
resp.write(b'data')
assert resp_impl.write.called
yield from resp.write_eof()
resp_impl.write.reset_mock()
yield from resp.write_eof()
assert not writer.write.called
def test_cannot_write_eof_twice():
resp = StreamResponse()
writer = mock.Mock()
resp_impl = yield from resp.prepare(make_request('GET', '/'))
resp_impl.write = mock.Mock()
resp_impl.write_eof = mock.Mock()
resp_impl.write_eof.return_value = ()
resp.write(b'data')
assert resp_impl.write.called
yield from resp.write_eof()
resp_impl.write.reset_mock()
yield from resp.write_eof()
assert not writer.write.called
async def report_url(request):
resp = StreamResponse()
data = await request.json()
url = data['url']
print("url reported: " + url)
biz = re.findall('__biz=(.*?)\&', url)
if len(biz) == 0:
await resp.prepare(request)
return resp
biz = biz[0]
print('----------------\r\n' + biz + '\r\n----------------\r\n')
mysql_mgr.enqueue_biz(biz, '')
bizs.add(biz)
biz = biz.encode('utf8')
resp.content_type = 'text/plain'
await resp.prepare(request)
resp.write(biz)
await resp.write_eof()
return resp
async def serve_file(self, fi):
filepath = str(fi.file_path.absolute())
filename = fi.file_path.name
with open(filepath, 'rb') as f:
resp = StreamResponse()
resp.content_type, _ = mimetypes.guess_type(filename)
disposition = 'filename="{}"'.format(filename)
if 'text' not in resp.content_type:
disposition = 'attachment; ' + disposition
resp.headers['CONTENT-DISPOSITION'] = disposition
data = f.read()
resp.content_length = len(data)
await resp.prepare(self.request)
resp.write(data)
return resp
async def download(self):
file = self.field.get(self.context)
if file is None:
raise AttributeError('No field value')
resp = StreamResponse(headers=multidict.MultiDict({
'CONTENT-DISPOSITION':
'attachment; filename="%s"' % file.filename
}))
resp.content_type = file.contentType
resp.content_type = 'application/octet-stream'
resp.content_length = file._size
downloader = await file.download(None)
await resp.prepare(self.request)
async with downloader['Body'] as stream:
data = await stream.read(CHUNK_SIZE)
while data:
resp.write(data)
data = await stream.read(CHUNK_SIZE)
return resp
async def __call__(self):
request = self.request
video = await get_video(self.request.GET['id'])
if video is None:
return HTTPNotFound()
status = 200
if 'Range' in request.headers:
status = 206
if status == 200:
return await self.download(video)
else:
range_val = request.headers['Range']
start, _, end = range_val.replace('bytes=', '').partition('-')
start = int(start)
if not end:
end = min(start + CHUNK_SIZE, int(video['size']) - 1)
end = int(end)
resp = StreamResponse(headers={
'Accept-Ranges':
'Bytes',
'Content-Range':
f'bytes {start}-{end}/{video["size"]}',
},
status=206)
resp.content_type = 'video/' + self.get_video_ext(video)
resp.content_length = (end - start) + 1
await resp.prepare(request)
data = await downloader.get_range(video, start, end + 1)
resp.write(data)
try:
await asyncio.sleep(0.001)
await resp.drain()
except concurrent.futures.CancelledError:
pass
return resp
def test_write_returns_drain():
resp = StreamResponse()
yield from resp.prepare(make_request('GET', '/'))
assert () == resp.write(b'data')
def test_write_non_byteish(self):
req = self.make_request('GET', '/')
resp = StreamResponse(req)
with self.assertRaises(TypeError):
resp.write(123)
def test_write_returns_drain(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
self.assertEqual((), resp.write(b'data'))
def test_write_returns_empty_tuple_on_empty_data(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
self.assertEqual((), resp.write(b''))
def test_write_non_byteish():
resp = StreamResponse()
yield from resp.prepare(make_request('GET', '/'))
with pytest.raises(AssertionError):
resp.write(123)
def test_write_before_sending_headers(self):
req = self.make_request('GET', '/')
resp = StreamResponse(req)
resp.write(b'data')
self.assertTrue(self.writer.write.called)
def test_write_non_byteish(self):
resp = StreamResponse()
resp.start(self.make_request('GET', '/'))
with self.assertRaises(AssertionError):
resp.write(123)
def test_write_before_start(self):
resp = StreamResponse()
with self.assertRaises(RuntimeError):
resp.write(b'data')
def test_write_returns_drain():
resp = StreamResponse()
yield from resp.prepare(make_request('GET', '/'))
assert () == resp.write(b'data')
def test_write_returns_empty_tuple_on_empty_data():
resp = StreamResponse()
yield from resp.prepare(make_request('GET', '/'))
assert () == resp.write(b'')
def test_write_returns_empty_tuple_on_empty_data(self):
resp = StreamResponse()
self.loop.run_until_complete(resp.prepare(self.make_request("GET", "/")))
self.assertEqual((), resp.write(b""))
def _test_write_returns_drain():
resp = StreamResponse()
yield from resp.prepare(make_request('GET', '/'))
with mock.patch('aiohttp.http_writer.noop') as noop:
assert noop == resp.write(b'data')
def test_write_before_start():
resp = StreamResponse()
with pytest.raises(RuntimeError):
resp.write(b'data')
def test_write_returns_empty_tuple_on_empty_data():
resp = StreamResponse()
yield from resp.prepare(make_request('GET', '/'))
assert () == resp.write(b'')
def test_write_non_byteish(self):
resp = StreamResponse()
self.loop.run_until_complete(resp.prepare(self.make_request("GET", "/")))
with self.assertRaises(AssertionError):
resp.write(123)
async def stream(request):
client_guid = str(uuid4())
sentry.tags_context({"client_guid": client_guid})
if request.headers.get("accept") != "text/event-stream":
return Response(status=406)
if request.method != "GET":
return Response(status=405)
token = request.query.get("token")
if not token:
return Response(status=401)
build_ids = frozenset(request.query.get("build") or [])
repo_ids = frozenset(request.query.get("repo") or [])
token = auth.parse_token(token)
if not token:
return Response(status=401)
if "uid" in token:
sentry.user_context({"id": token["uid"]})
current_app.logger.debug("pubsub.client.connected guid=%s tenant=%s",
client_guid, token)
loop = request.app.loop
parts = urlparse(current_app.config["REDIS_URL"])
conn = await aioredis.create_redis(
address=(parts.hostname or "localhost", parts.port or "6379"),
db=parts.path.split("1", 1)[:-1] or 0,
password=parts.password,
loop=loop,
)
try:
queue = asyncio.Queue(loop=loop)
res = await conn.subscribe("builds")
asyncio.ensure_future(worker(res[0], queue, token, repo_ids,
build_ids))
resp = StreamResponse(status=200, reason="OK")
resp.headers["Content-Type"] = "text/event-stream"
resp.headers["Cache-Control"] = "no-cache"
resp.headers["Connection"] = "keep-alive"
if "Origin" in request.headers and is_valid_origin(request):
resp.headers["Access-Control-Allow-Origin"] = request.headers.get(
"Origin")
resp.headers["Access-Control-Expose-Headers"] = "*"
resp.enable_chunked_encoding()
await resp.prepare(request)
# loop.create_task(ping(loop, resp, client_guid))
# resp.write(b'retry: 100\r\n\r\n')
while True:
event = await queue.get()
if event is None:
break
buffer = io.BytesIO()
if event.id:
buffer.write(b"id: %s\r\n" % (event.id.encode("utf-8"), ))
if event.event:
buffer.write(b"event: %s\r\n" % (event.event.encode("utf-8")))
if event.data:
buffer.write(b"data: %s\r\n" %
(json.dumps(event.data).encode("utf-8")))
buffer.write(b"\r\n")
resp.write(buffer.getvalue())
queue.task_done()
current_app.logger.debug("pubsub.event.sent qsize=%s",
queue.qsize())
# Yield to the scheduler so other processes do stuff.
await resp.drain()
await resp.write_eof()
return resp
finally:
conn.close()
await conn.wait_closed()
current_app.logger.debug("client.disconnected guid=%s",
client_guid,
exc_info=True)
def _test_write_returns_empty_tuple_on_empty_data():
resp = StreamResponse()
yield from resp.prepare(make_request('GET', '/'))
with mock.patch('aiohttp.http_writer.noop') as noop:
assert noop.return_value == resp.write(b'')
