def test_using_gzip_if_header_present_and_file_available(loop):
request = make_mocked_request(
'GET', 'http://python.org/logo.png', headers={
hdrs.ACCEPT_ENCODING: 'gzip'
}
)
gz_filepath = mock.Mock()
gz_filepath.open = mock.mock_open()
gz_filepath.is_file.return_value = True
gz_filepath.stat.return_value = mock.MagicMock()
gz_filepath.stat.st_size = 1024
filepath = mock.Mock()
filepath.name = 'logo.png'
filepath.open = mock.mock_open()
filepath.with_name.return_value = gz_filepath
file_sender = FileResponse(filepath)
file_sender._sendfile = make_mocked_coro(None)
loop.run_until_complete(file_sender.prepare(request))
assert not filepath.open.called
assert gz_filepath.open.called
def test_gzip_if_header_not_present_and_file_not_available(loop: Any) -> None:
request = make_mocked_request("GET",
"http://python.org/logo.png",
headers={})
gz_filepath = mock.Mock()
gz_filepath.open = mock.mock_open()
gz_filepath.is_file.return_value = False
filepath = mock.Mock()
filepath.name = "logo.png"
filepath.open = mock.mock_open()
filepath.with_name.return_value = gz_filepath
filepath.stat.return_value = mock.MagicMock()
filepath.stat.st_size = 1024
file_sender = FileResponse(filepath)
file_sender._sendfile = make_mocked_coro(None) # type: ignore[assignment]
loop.run_until_complete(file_sender.prepare(request))
assert filepath.open.called
assert not gz_filepath.open.called
def handle_file(self, request, filename, from_index=None):
"""Handle file requests."""
try:
filepath = self._directory.joinpath(filename).resolve()
if not self._follow_symlinks:
filepath.relative_to(self._directory)
except (ValueError, FileNotFoundError) as error:
# relatively safe
raise HTTPNotFound() from error
except Exception as error:
# perm error or other kind!
request.app.logger.exception(error)
raise HTTPNotFound() from error
# on opening a dir, load it's contents if allowed
if filepath.is_dir():
if filename.endswith('/') or not filename:
ret = yield from self.handle_file(request,
filename + 'index.html',
from_index=filename)
else:
ret = yield from self.handle_file(request,
filename + '/index.html',
from_index=filename)
elif filepath.is_file():
ct, encoding = mimetypes.guess_type(str(filepath))
encoding = encoding or 'utf-8'
if ct == 'text/html' and self.modify_html:
if sys.version_info[0] == 3 and sys.version_info[1] <= 5:
# Python 3.4 and 3.5 do not accept pathlib.Path objects in calls to open()
filepath = str(filepath)
with open(filepath, 'r', encoding=encoding) as fh:
text = fh.read()
text = self.transform_html(text)
ret = Response(text=text,
content_type=ct,
charset=encoding)
else:
ret = FileResponse(filepath, chunk_size=self._chunk_size)
elif from_index:
filepath = self._directory.joinpath(from_index).resolve()
try:
return Response(text=self._directory_as_html(filepath),
content_type="text/html")
except PermissionError:
raise HTTPForbidden
else:
raise HTTPNotFound
return ret
def test_gzip_if_header_not_present_and_file_available(loop):
request = make_mocked_request('GET',
'http://python.org/logo.png',
headers={})
gz_filepath = mock.Mock()
gz_filepath.open = mock.mock_open()
gz_filepath.is_file.return_value = True
filepath = mock.Mock()
filepath.name = 'logo.png'
filepath.open = mock.mock_open()
filepath.with_name.return_value = gz_filepath
filepath.stat.return_value = mock.MagicMock()
filepath.stat.st_size = 1024
file_sender = FileResponse(filepath)
file_sender._sendfile = make_mocked_coro(None)
loop.run_until_complete(file_sender.prepare(request))
assert filepath.open.called
assert not gz_filepath.open.called
async def _handle(self, request: Request) -> StreamResponse:
rel_url = request.match_info['filename']
try:
filename = Path(rel_url)
if filename.anchor:
# rel_url is an absolute name like
# /static/\\machine_name\c$ or /static/D:\path
# where the static dir is totally different
raise HTTPForbidden()
# alternative directories is the first place for searching
alt = False
directory = self._directory
if self.canonical in self._directory_alt:
for v in self._directory_alt[self.canonical]:
filepath = v.joinpath(filename).resolve()
if filepath.exists():
directory = v
alt = True
break
if not alt:
filepath = directory.joinpath(filename).resolve()
if not self._follow_symlinks:
filepath.relative_to(directory)
except (ValueError, FileNotFoundError) as error:
# relatively safe
raise HTTPNotFound() from error
except HTTPForbidden:
raise
except Exception as error:
# perm error or other kind!
request.app.logger.exception(error)
raise HTTPNotFound() from error
# on opening a dir, load its contents if allowed
if filepath.is_dir():
if self._show_index:
try:
return Response(text=self._directory_as_html(filepath),
content_type="text/html")
except PermissionError:
raise HTTPForbidden()
else:
raise HTTPForbidden()
elif filepath.is_file():
return FileResponse(filepath, chunk_size=self._chunk_size)
else:
raise HTTPNotFound
def test_using_gzip_if_header_present_and_file_available(loop) -> None:
request = make_mocked_request("GET",
"http://python.org/logo.png",
headers={hdrs.ACCEPT_ENCODING: "gzip"})
gz_filepath = mock.Mock()
gz_filepath.open = mock.mock_open()
gz_filepath.is_file.return_value = True
gz_filepath.stat.return_value = mock.MagicMock()
gz_filepath.stat.st_size = 1024
filepath = mock.Mock()
filepath.name = "logo.png"
filepath.open = mock.mock_open()
filepath.with_name.return_value = gz_filepath
file_sender = FileResponse(filepath)
file_sender._sendfile = make_mocked_coro(None)
loop.run_until_complete(file_sender.prepare(request))
assert not filepath.open.called
assert gz_filepath.open.called
async def spa_static_handler(request):
"""
Handler suitable for use with single page apps.
Use with web.get(r'/{path:.*}', spa_static_handler, name='static')
modified from aiohttp_web_urldispatcher.StaticResource_handle
"""
request_path = request.match_info['path'].lstrip('/')
directory = request.app['static_dir']
csp_headers = request.app.get('static_headers') or {}
if request_path == '':
return FileResponse(directory / 'index.html', headers=csp_headers)
# probably other paths to return 404 for?
if request_path.startswith('.well-known/'):
raise HTTPNotFound()
try:
filename = Path(request_path)
if filename.anchor: # pragma: no cover
# shouldn't happen on linux, but keep it just in case
# request_path is an absolute name like
# /static/\\machine_name\c$ or /static/D:\path
# where the static dir is totally different
raise RuntimeError('request path has anchor')
filepath = directory.joinpath(filename).resolve()
filepath.relative_to(directory)
except Exception: # pragma: no cover
logger.warning('error resolving path %r', request_path, exc_info=True)
filepath = directory
if filepath.is_file():
return FileResponse(filepath, headers=csp_headers)
else:
return FileResponse(directory / 'index.html', headers=csp_headers)
async def handler(request: web.Request) -> web.Response:
result = compiled_pattern.match(request.path)
filename = result.groupdict()['filename'] if result else ''
filepath = '{}{}'.format(path, filename)
try:
if os.path.commonprefix((os.path.realpath(filepath), os.path.realpath(path))) != os.path.realpath(path) or os.path.isdir(filepath) or not os.path.exists(filepath):
raise web.HTTPNotFound() # type: ignore
pathlib.Path(filepath).open('r')
response = FileResponse(path=filepath, # type: ignore
chunk_size=256 * 1024) # type: web.Response
return response
except PermissionError as e:
raise web.HTTPForbidden() # type: ignore
async def get_file(request: web.Request) -> FileResponse:
"""For worker to pull file for calculating file hash task
request headers:
* X-DISTRIBUTED-WORKER-NAME: worker's name, worker should been registered
already. required
responses:
* 200 OK: file response
* 202 Accepted: wait for processing files timeout and make request again
* 204 No Content: no more files
* 400 Bad Request: missing worker name header
* 400 Bad Request: worker not registered yet
"""
master = request.app["master"]
worker_name = _get_worker_name(request)
_ensure_worker_registered(master, worker_name)
try:
file_path = master.files_queue.get_nowait()
except asyncio.QueueEmpty:
# try to get timeout task
timeout_file = master.get_earlist_timeout_file()
if timeout_file:
_worker_name, file_path, _ = timeout_file
# remove old processing file
master.remove_current_processing_file(_worker_name, file_path)
else:
# try to find out any processing files
if not master.has_processing_files():
# no more files
raise web.HTTPNoContent()
else:
# tell workers to wait until processing files timeout
raise web.HTTPAccepted(
text=("wait for processing files timeout and make request"
" again"))
master.new_processing_file(worker_name, file_path)
master.files_queue.task_done()
full_path = master.home.get_full_path(file_path)
headers = {constants.HTTP_HEADER_X_FILE_PATH: file_path}
return FileResponse(full_path, headers=headers)
async def static(request):
request_path = request.match_info['path'].lstrip('/')
directory: Path = request.app['output_dir'].resolve()
if request_path == '':
filepath = directory / 'index.html'
else:
try:
filepath = (directory / request_path).resolve()
filepath.relative_to(directory)
except Exception as exc:
# perm error or other kind!
raise HTTPNotFound() from exc
for _ in range(20):
if filepath.exists():
break
await asyncio.sleep(0.1)
if filepath.is_file():
return FileResponse(filepath)
else:
raise HTTPNotFound()
async def get_static(self, request: Request) -> FileResponse:
"""
Load static content for OpenAPI UI.
"""
file_name = request.match_info['filename']
# Check file exists and is a known content type.
content_type = {
'ss': 'text/css',
'js': 'application/javascript',
'ng': 'image/png',
}.get(file_name[-2:])
file_path = self.static_path / file_name
if not (content_type and file_path.exists()):
raise HttpError(HTTPStatus.NOT_FOUND, 42)
return FileResponse(file_path, headers={
'Content-Type': content_type,
'Content-Encoding': 'gzip', # Content is pre-gzipped
'Cache-Control': 'public, max-age=300',
})
async def serve_livereload_js(self, request):
"""Handle requests to /livereload.js and serve the JS file."""
return FileResponse(LRJS_PATH)
async def download_hmm_profiles(request):
return FileResponse(HMM_PROFILES)