Esempio n. 1
0
def get_response_for_resource_path(
    request: Request,
    tail: str,
    files_list_html: str,
    source_folder_name: str,
    files_handler: FilesHandler,
    source_folder_full_path: str,
    discovery: bool,
    cache_time: int,
    extensions: Set[str],
    root_path: str,
    index_document: Optional[str],
) -> Response:
    resource_path = os.path.join(source_folder_name, tail)

    if "../" in tail:
        # verify that a relative path doesn't go outside of the
        # static root folder
        abs_path = os.path.abspath(resource_path)
        if not str(abs_path).lower().startswith(source_folder_full_path.lower()):
            # outside of the static folder!
            raise NotFound()

    if not os.path.exists(resource_path) or os.path.islink(resource_path):
        raise NotFound()

    if os.path.isdir(resource_path):
        # Request for a path that matches a folder: e.g. /foo/
        if discovery:
            return get_files_list_html_response(
                files_list_html,
                tail.rstrip("/"),
                list(get_files_to_serve(Path(resource_path.rstrip("/")), extensions)),
                root_path,
            )
        else:
            if index_document is not None:
                # try returning the default index document
                return get_response_for_resource_path(
                    request,
                    index_document,
                    files_list_html,
                    source_folder_name,
                    files_handler,
                    source_folder_full_path,
                    discovery,
                    cache_time,
                    extensions,
                    root_path,
                    None,
                )
            raise NotFound()

    file_extension = get_file_extension_from_name(resource_path)

    if file_extension not in extensions:
        raise NotFound()

    return get_response_for_file(files_handler, request, resource_path, cache_time)
Esempio n. 2
0
def get_files_to_serve(
        source_folder: Path,
        extensions: Set[str],
        root_folder: Optional[Path] = None) -> Iterable[Dict[str, str]]:
    assert source_folder.exists(), "The source folder path must exist"
    assert source_folder.is_dir(), "The source folder path must be a directory"

    if not root_folder:
        root_folder = source_folder

    names = os.listdir(source_folder)
    names.sort()
    dirs, nondirs = [], []

    for name in names:
        full_path = source_folder / name
        if os.path.isdir(full_path):
            dirs.append(full_path)
        else:
            nondirs.append(full_path)

    items = dirs + nondirs
    items = (item for item in items if not os.path.islink(item))

    yield {
        "rel_path": "../",
        "full_path": str(source_folder),
        "is_dir": True,
    }

    for item in items:
        item_path = str(item)

        if item.is_dir():
            yield {
                "rel_path": item_path[len(str(root_folder)) + 1:],
                "full_path": item_path,
                "is_dir": True,
            }
        else:
            extension = get_file_extension_from_name(item_path)

            if extension in extensions:
                yield {
                    "rel_path": item_path[len(str(root_folder)) + 1:],
                    "full_path": item_path,
                    "is_dir": False,
                }
Esempio n. 3
0
def test_get_file_extension_from_name(full_path, expected_result):
    assert get_file_extension_from_name(full_path) == expected_result