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