Add home page, health endpoints & organize routes & api_password in header support

mediaflow_proxy/main.py

@@ -1,182 +1,51 @@
 import logging
 
-from fastapi import FastAPI, Request, Depends, Security, HTTPException
-from fastapi.security import APIKeyQuery
-from pydantic import HttpUrl
+from fastapi import FastAPI, Depends, Security, HTTPException
+from fastapi.security import APIKeyQuery, APIKeyHeader
+from starlette.responses import RedirectResponse
+from starlette.staticfiles import StaticFiles
 
 from mediaflow_proxy.configs import settings
-from .handlers import handle_hls_stream_proxy, proxy_stream, get_manifest, get_playlist, get_segment, get_public_ip
+from mediaflow_proxy.routes import proxy_router
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 app = FastAPI()
-api_key_query = APIKeyQuery(name="api_password", auto_error=False)
+api_password_query = APIKeyQuery(name="api_password", auto_error=False)
+api_password_header = APIKeyHeader(name="api_password", auto_error=False)
 
 
-async def verify_api_key(api_key: str = Security(api_key_query)):
+async def verify_api_key(api_key: str = Security(api_password_query), api_key_alt: str = Security(api_password_header)):
     """
     Verifies the API key for the request.
 
     Args:
         api_key (str): The API key to validate.
+        api_key_alt (str): The alternative API key to validate.
 
     Raises:
         HTTPException: If the API key is invalid.
     """
-    if api_key != settings.api_password:
-        raise HTTPException(status_code=403, detail="Could not validate credentials")
+    if api_key == settings.api_password or api_key_alt == settings.api_password:
+        return
 
+    raise HTTPException(status_code=403, detail="Could not validate credentials")
 
-def get_proxy_headers(request: Request) -> dict:
-    """
-    Extracts proxy headers from the request query parameters.
 
-    Args:
-        request (Request): The incoming HTTP request.
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
 
-    Returns:
-        dict: A dictionary of proxy headers.
-    """
-    return {k[2:]: v for k, v in request.query_params.items() if k.startswith("h_")}
-
-
-@app.head("/proxy/hls")
-@app.get("/proxy/hls")
-async def hls_stream_proxy(
-    request: Request,
-    d: HttpUrl,
-    headers: dict = Depends(get_proxy_headers),
-    key_url: HttpUrl | None = None,
-    _: str = Depends(verify_api_key),
-):
-    """
-    Proxify HLS stream requests, fetching and processing the m3u8 playlist or streaming the content.
-
-    Args:
-        request (Request): The incoming HTTP request.
-        d (HttpUrl): The destination URL to fetch the content from.
-        key_url (HttpUrl, optional): The HLS Key URL to replace the original key URL. Defaults to None. (Useful for bypassing some sneaky protection)
-        headers (dict): The headers to include in the request.
-        _ (str): The API key to validate.
-
-    Returns:
-        Response: The HTTP response with the processed m3u8 playlist or streamed content.
-    """
-    destination = str(d)
-    return await handle_hls_stream_proxy(request, destination, headers, key_url)
 
+@app.get("/favicon.ico")
+async def get_favicon():
+    return RedirectResponse(url="/logo.png")
 
-@app.head("/proxy/stream")
-@app.get("/proxy/stream")
-async def proxy_stream_endpoint(
-    request: Request, d: HttpUrl, headers: dict = Depends(get_proxy_headers), _: str = Depends(verify_api_key)
-):
-    """
-    Proxies stream requests to the given video URL.
 
-    Args:
-        request (Request): The incoming HTTP request.
-        d (HttpUrl): The URL of the video to stream.
-        headers (dict): The headers to include in the request.
-        _: str: The API key to validate.
+app.include_router(proxy_router, prefix="/proxy", tags=["proxy"], dependencies=[Depends(verify_api_key)])
+app.mount("/", StaticFiles(directory="static", html=True), name="static")
 
-    Returns:
-        Response: The HTTP response with the streamed content.
-    """
-    headers.update({"range": headers.get("range", "bytes=0-")})
-    return await proxy_stream(request.method, str(d), headers)
-
-
-@app.get("/proxy/mpd/manifest")
-async def manifest_endpoint(
-    request: Request,
-    d: HttpUrl,
-    headers: dict = Depends(get_proxy_headers),
-    key_id: str = None,
-    key: str = None,
-    _: str = Depends(verify_api_key),
-):
-    """
-    Retrieves and processes the MPD manifest, converting it to an HLS manifest.
 
-    Args:
-        request (Request): The incoming HTTP request.
-        d (HttpUrl): The URL of the MPD manifest.
-        headers (dict): The headers to include in the request.
-        key_id (str, optional): The DRM key ID. Defaults to None.
-        key (str, optional): The DRM key. Defaults to None.
-        _: str: The API key to validate.
-
-    Returns:
-        Response: The HTTP response with the HLS manifest.
-    """
-    return await get_manifest(request, str(d), headers, key_id, key)
-
-
-@app.get("/proxy/mpd/playlist")
-async def playlist_endpoint(
-    request: Request,
-    d: HttpUrl,
-    profile_id: str,
-    headers: dict = Depends(get_proxy_headers),
-    key_id: str = None,
-    key: str = None,
-    _: str = Depends(verify_api_key),
-):
-    """
-    Retrieves and processes the MPD manifest, converting it to an HLS playlist for a specific profile.
+if __name__ == "__main__":
+    import uvicorn
 
-    Args:
-        request (Request): The incoming HTTP request.
-        d (HttpUrl): The URL of the MPD manifest.
-        profile_id (str): The profile ID to generate the playlist for.
-        headers (dict): The headers to include in the request.
-        key_id (str, optional): The DRM key ID. Defaults to None.
-        key (str, optional): The DRM key. Defaults to None.
-        _: str: The API key to validate.
-
-    Returns:
-        Response: The HTTP response with the HLS playlist.
-    """
-    return await get_playlist(request, str(d), profile_id, headers, key_id, key)
-
-
-@app.get("/proxy/mpd/segment")
-async def segment_endpoint(
-    init_url: HttpUrl,
-    segment_url: HttpUrl,
-    mime_type: str,
-    headers: dict = Depends(get_proxy_headers),
-    key_id: str = None,
-    key: str = None,
-    _: str = Depends(verify_api_key),
-):
-    """
-    Retrieves and processes a media segment, decrypting it if necessary.
-
-    Args:
-        init_url (HttpUrl): The URL of the initialization segment.
-        segment_url (HttpUrl): The URL of the media segment.
-        mime_type (str): The MIME type of the segment.
-        headers (dict): The headers to include in the request.
-        key_id (str, optional): The DRM key ID. Defaults to None.
-        key (str, optional): The DRM key. Defaults to None.
-        _: str: The API key to validate.
-
-    Returns:
-        Response: The HTTP response with the processed segment.
-    """
-    return await get_segment(str(init_url), str(segment_url), mime_type, headers, key_id, key)
-
-
-@app.get("/proxy/ip")
-async def get_mediaflow_proxy_public_ip(_: str = Depends(verify_api_key)):
-    """
-    Retrieves the public IP address of the MediaFlow proxy server.
-
-    Args:
-        _: str: The API key to validate.
-
-    Returns:
-        Response: The HTTP response with the public IP address in the form of a JSON object. {"ip": "xxx.xxx.xxx.xxx"}
-    """
-    return await get_public_ip()
+    uvicorn.run(app, host="127.0.0.1", port=8888)

mediaflow_proxy/routes.py

@@ -0,0 +1,148 @@
+from fastapi import Request, Depends, APIRouter
+from pydantic import HttpUrl
+
+from .handlers import handle_hls_stream_proxy, proxy_stream, get_manifest, get_playlist, get_segment, get_public_ip
+
+proxy_router = APIRouter()
+
+
+def get_proxy_headers(request: Request) -> dict:
+    """
+    Extracts proxy headers from the request query parameters.
+
+    Args:
+        request (Request): The incoming HTTP request.
+
+    Returns:
+        dict: A dictionary of proxy headers.
+    """
+    return {k[2:]: v for k, v in request.query_params.items() if k.startswith("h_")}
+
+
+@proxy_router.head("/hls")
+@proxy_router.get("/hls")
+async def hls_stream_proxy(
+    request: Request,
+    d: HttpUrl,
+    headers: dict = Depends(get_proxy_headers),
+    key_url: HttpUrl | None = None,
+):
+    """
+    Proxify HLS stream requests, fetching and processing the m3u8 playlist or streaming the content.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        d (HttpUrl): The destination URL to fetch the content from.
+        key_url (HttpUrl, optional): The HLS Key URL to replace the original key URL. Defaults to None. (Useful for bypassing some sneaky protection)
+        headers (dict): The headers to include in the request.
+
+    Returns:
+        Response: The HTTP response with the processed m3u8 playlist or streamed content.
+    """
+    destination = str(d)
+    return await handle_hls_stream_proxy(request, destination, headers, key_url)
+
+
+@proxy_router.head("/stream")
+@proxy_router.get("/stream")
+async def proxy_stream_endpoint(request: Request, d: HttpUrl, headers: dict = Depends(get_proxy_headers)):
+    """
+    Proxies stream requests to the given video URL.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        d (HttpUrl): The URL of the video to stream.
+        headers (dict): The headers to include in the request.
+
+    Returns:
+        Response: The HTTP response with the streamed content.
+    """
+    headers.update({"range": headers.get("range", "bytes=0-")})
+    return await proxy_stream(request.method, str(d), headers)
+
+
+@proxy_router.get("/mpd/manifest")
+async def manifest_endpoint(
+    request: Request,
+    d: HttpUrl,
+    headers: dict = Depends(get_proxy_headers),
+    key_id: str = None,
+    key: str = None,
+):
+    """
+    Retrieves and processes the MPD manifest, converting it to an HLS manifest.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        d (HttpUrl): The URL of the MPD manifest.
+        headers (dict): The headers to include in the request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the HLS manifest.
+    """
+    return await get_manifest(request, str(d), headers, key_id, key)
+
+
+@proxy_router.get("/mpd/playlist")
+async def playlist_endpoint(
+    request: Request,
+    d: HttpUrl,
+    profile_id: str,
+    headers: dict = Depends(get_proxy_headers),
+    key_id: str = None,
+    key: str = None,
+):
+    """
+    Retrieves and processes the MPD manifest, converting it to an HLS playlist for a specific profile.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        d (HttpUrl): The URL of the MPD manifest.
+        profile_id (str): The profile ID to generate the playlist for.
+        headers (dict): The headers to include in the request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the HLS playlist.
+    """
+    return await get_playlist(request, str(d), profile_id, headers, key_id, key)
+
+
+@proxy_router.get("/mpd/segment")
+async def segment_endpoint(
+    init_url: HttpUrl,
+    segment_url: HttpUrl,
+    mime_type: str,
+    headers: dict = Depends(get_proxy_headers),
+    key_id: str = None,
+    key: str = None,
+):
+    """
+    Retrieves and processes a media segment, decrypting it if necessary.
+
+    Args:
+        init_url (HttpUrl): The URL of the initialization segment.
+        segment_url (HttpUrl): The URL of the media segment.
+        mime_type (str): The MIME type of the segment.
+        headers (dict): The headers to include in the request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the processed segment.
+    """
+    return await get_segment(str(init_url), str(segment_url), mime_type, headers, key_id, key)
+
+
+@proxy_router.get("/ip")
+async def get_mediaflow_proxy_public_ip():
+    """
+    Retrieves the public IP address of the MediaFlow proxy server.
+
+    Returns:
+        Response: The HTTP response with the public IP address in the form of a JSON object. {"ip": "xxx.xxx.xxx.xxx"}
+    """
+    return await get_public_ip()

static/index.html

@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MediaFlow Proxy</title>
+    <link rel="icon" href="/logo.png" type="image/x-icon">
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            line-height: 1.6;
+            color: #333;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+            background-color: #f9f9f9;
+        }
+
+        header {
+            background-color: #90aacc;
+            color: #fff;
+            padding: 10px 0;
+            text-align: center;
+        }
+
+        header img {
+            width: 200px;
+            height: 200px;
+            vertical-align: middle;
+            border-radius: 15px;
+        }
+
+        header h1 {
+            display: inline;
+            margin-left: 20px;
+            font-size: 36px;
+        }
+
+        .feature {
+            background-color: #f4f4f4;
+            border-left: 4px solid #3498db;
+            padding: 10px;
+            margin-bottom: 10px;
+        }
+
+        a {
+            color: #3498db;
+        }
+    </style>
+</head>
+<body>
+<header>
+    <img src="/logo.png" alt="MediaFlow Proxy Logo">
+    <h1>MediaFlow Proxy</h1>
+</header>
+<p>A high-performance proxy server for streaming media, supporting HTTP(S), HLS, and MPEG-DASH with real-time DRM decryption.</p>
+
+<h2>Key Features</h2>
+<div class="feature">Convert MPEG-DASH streams (DRM-protected and non-protected) to HLS</div>
+<div class="feature">Support for Clear Key DRM-protected MPD DASH streams</div>
+<div class="feature">Handle both live and video-on-demand (VOD) DASH streams</div>
+<div class="feature">Proxy HTTP/HTTPS links with custom headers</div>
+<div class="feature">Proxy and modify HLS (M3U8) streams in real-time with custom headers and key URL modifications for bypassing some sneaky restrictions.</div>
+<div class="feature">Protect against unauthorized access and network bandwidth abuses</div>
+
+<h2>Getting Started</h2>
+<p>Visit the <a href="https://github.com/mhdzumair/mediaflow-proxy">GitHub repository</a> for installation instructions and documentation.</p>
+
+<h2>Premium Hosted Service</h2>
+<p>For a hassle-free experience, check out <a href="https://store.elfhosted.com/product/mediaflow-proxy">premium hosted service on ElfHosted</a>.</p>
+
+<h2>API Documentation</h2>
+<p>Explore the <a href="/docs">Swagger UI</a> for comprehensive details about the API endpoints and their usage.</p>
+
+</body>
+</html>