async def get(self) -> StreamResponse: """Get file by hash of file from storage Request ------ <file_hash> str: should be contain only numbers and letters ------ Response ------ streaming bytes data """ file_hash = self.request.match_info['file_hash'].lower() if not file_hash: raise ValidationError(message='file_hash is empty') file_manager = self._create_file_manager() try: file_reader = await file_manager.get_file_reader(file_hash) response = StreamResponse(status=HTTPStatus.OK, headers={ 'Content-disposition': f'attachment; filename={file_hash}' }) response.enable_chunked_encoding() await response.prepare(self.request) async for chunk in file_reader(): await response.write(chunk) await response.write_eof() return response except FileNotFoundError: raise HTTPNotFound
async def export_plumbing(request, sql, *sql_args, filename, none_message, modify_records=None): response = StreamResponse(headers={ 'Content-Disposition': f'attachment;filename={filename}.csv' }) response.content_type = 'text/csv' await response.prepare(request) try: response_file = ResponsePseudoFile(response) writer = None async with request['conn'].transaction(): async for record in request['conn'].cursor(sql, *sql_args): if modify_records: data = modify_records(record) else: data = record if writer is None: writer = DictWriter(response_file, fieldnames=list(data.keys())) writer.writeheader() writer.writerow({k: '' if v is None else str(v) for k, v in data.items()}) await response_file.write_response() if writer is None: writer = DictWriter(response_file, fieldnames=['message']) writer.writeheader() writer.writerow({'message': none_message}) await response_file.write_response() except Exception: # pragma no cover logger.exception('error generating export, filename: %s', filename) return response
async def get_recipe_image(req: Request): # get recipe by id try: r = recipe.get_by_id(req.match_info.get("id")) except RecipeError: return json_response(RECIPE_ERRORS.DOES_NOT_EXIST) try: resp = StreamResponse( status=200, reason='OK', headers={'Content-Type': r._recipe.image.content_type}) await resp.prepare(req) size = 0 out = r._recipe.image.get() while True: chunk = out.readchunk() if not chunk: break size += len(chunk) await resp.write(chunk) _LOGGER.info(size) await resp.write_eof() return resp """ content = r._recipe.image.read() content_type = r._recipe.image.content_type return Response(body=content, headers=MultiDict({'CONTENT-TYPE': content_type})) """ except AttributeError: return Response(status=404)
async def ndjsonify(async_iterator, request): response = StreamResponse(status=200, reason='OK') response.headers['Content-Type'] = 'application/x-ndjson' await response.prepare(request) async for element in async_iterator: text = json_dumps(element) + '\n' await response.write(text.encode('utf-8')) return response
async def sitemap(request): response = StreamResponse() response.content_type = 'application/xml' await response.prepare(request) await response.write( b'<?xml version="1.0" encoding="UTF-8"?>\n' b'<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n') try: company_domain = await request['conn'].fetchval( 'SELECT domain FROM companies WHERE id=$1', request['company_id']) async def write_url(uri_, latest_update_, priority): await response.write( (f'<url>' f'<loc>https://{company_domain}/{uri_}</loc>' f'<lastmod>{latest_update_:%Y-%m-%d}</lastmod>' f'<changefreq>daily</changefreq>' f'<priority>{priority:0.1f}</priority>' f'</url>\n').encode()) cats = {} async with request['conn'].transaction(): async for ( cat_uri, uri, latest_update, highlight) in request['conn'].cursor(sitemap_events_sql): cat_latest_update = cats.get(cat_uri) if cat_latest_update is None or latest_update > cat_latest_update: cats[cat_uri] = latest_update await write_url(uri, latest_update, 0.7 if highlight else 0.5) for cat_uri, latest_update in cats.items(): await write_url(cat_uri, latest_update, 0.9) if cats: await write_url('', max(cats.values()), 1) else: await write_url('', date.today(), 1) except Exception: # pragma no cover logger.exception('error generating sitemap') await response.write(b'</urlset>\n') return response
async def impl(request: Request, handler: Handler) -> StreamResponse: is_options = request.method == "OPTIONS" is_preflight = is_options and "Access-Control-Request-Method" in request.headers if is_preflight: resp = StreamResponse() else: resp = await handler(request) origin = request.headers.get("Origin") if not origin: return resp resp.headers["Access-Control-Allow-Origin"] = "*" resp.headers["Access-Control-Expose-Headers"] = "*" if is_options: resp.headers["Access-Control-Allow-Headers"] = ", ".join( allow_headers) resp.headers["Access-Control-Allow-Methods"] = ", ".join( ("OPTIONS", "POST")) return resp
async def request_server(self, request: Request): guid = str(uuid.uuid4()) wrapped_request = await WrappedRequest.from_request(guid, request) if self.ws is None: return web.Response(status=502, text='502 - Service not available') try: self.responses[guid] = response = StreamResponse() response.original_request = request self.responses_finalized[guid] = response_finalized = Future() await self.ws.send_json(dataclasses.asdict(wrapped_request)) await asyncio.wait_for(response_finalized, timeout=RESPONSE_TIMEOUT_MS) await response.write_eof() return response finally: if guid in self.responses: del self.responses[guid] if guid in self.responses_finalized: del self.responses_finalized[guid]
async def _stream_handler(self, request: Request) -> typing.Optional[Response]: message_id: str = request.match_info["message_id"] if not message_id.isdigit(): return Response(status=401) token: str = request.match_info["token"] if not token.isdigit(): return Response(status=401) if not self._check_token(int(message_id), int(token)): return Response(status=403) range_header = request.headers.get("Range") if range_header is None: offset = 0 data_to_skip = False max_size = None else: try: offset, data_to_skip, max_size = parse_http_range( range_header, self._config.block_size) except ValueError: return Response(status=400) if data_to_skip > self._config.block_size: return Response(status=500) try: message = await self._mtproto.get_message(int(message_id)) except ValueError: return Response(status=404) if not isinstance(message.media, MessageMediaDocument): return Response(status=404) if not isinstance(message.media.document, Document): return Response(status=404) size = message.media.document.size read_after = offset + data_to_skip if read_after > size: return Response(status=400) if (max_size is not None) and (size < max_size): return Response(status=400) if max_size is None: max_size = size stream = StreamResponse( status=206 if (read_after or (max_size != size)) else 200) self._write_upnp_headers(stream) stream.headers.setdefault("Content-Range", f"bytes {read_after}-{max_size}/{size}") stream.headers.setdefault("Accept-Ranges", "bytes") stream.headers.setdefault("Content-Length", str(size)) try: filename = mtproto_filename(message) except TypeError: filename = f"file_{message.media.document.id}" self._write_filename_header(stream, filename) await stream.prepare(request) while offset < max_size: block = await self._mtproto.get_block(message, offset, self._config.block_size) new_offset = offset + len(block) if data_to_skip: block = block[data_to_skip:] data_to_skip = False if new_offset > max_size: block = block[:-(new_offset - max_size)] offset = new_offset if request.transport.is_closing(): break await stream.write(block) await stream.write_eof()
async def _stream_handler(self, request: Request) -> typing.Optional[Response]: _message_id: str = request.match_info["message_id"] if not _message_id.isdigit(): return Response(status=401) _token: str = request.match_info["token"] if not _token.isdigit(): return Response(status=401) token = int(_token) del _token message_id = int(_message_id) del _message_id local_token = serialize_token(message_id, token) if not self._check_local_token(local_token): return Response(status=403) range_header = request.headers.get("Range") if range_header is None: offset = 0 data_to_skip = False max_size = None else: try: offset, data_to_skip, max_size = parse_http_range( range_header, self._config.block_size) except ValueError: return Response(status=400) if data_to_skip > self._config.block_size: return Response(status=500) try: message = await self._mtproto.get_message(int(message_id)) except ValueError: return Response(status=404) if not isinstance(message.media, MessageMediaDocument): return Response(status=404) if not isinstance(message.media.document, Document): return Response(status=404) size = message.media.document.size read_after = offset + data_to_skip if read_after > size: return Response(status=400) if (max_size is not None) and (size < max_size): return Response(status=400) if max_size is None: max_size = size stream = StreamResponse( status=206 if (read_after or (max_size != size)) else 200) self._write_http_range_headers(stream, read_after, size, max_size) try: filename = mtproto_filename(message) except TypeError: filename = f"file_{message.media.document.id}" self._write_filename_header(stream, filename) self._write_upnp_headers(stream) await stream.prepare(request) while offset < max_size: self._feed_timeout(message_id, message.from_id, local_token, size) block = await self._mtproto.get_block(message, offset, self._config.block_size) new_offset = offset + len(block) if data_to_skip: block = block[data_to_skip:] data_to_skip = False if new_offset > max_size: block = block[:-(new_offset - max_size)] if request.transport is None: break self._feed_stream_trasport(local_token, request.transport) if request.transport.is_closing(): break await stream.write(block) self._feed_downloaded_blocks(offset, local_token) offset = new_offset await stream.write_eof()