xitzin 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

xitzin/__init__.py

@@ -22,6 +22,7 @@ Example:
 
 from .application import Xitzin
 from .cgi import CGIConfig, CGIHandler, CGIScript
+from .middleware import VirtualHostMiddleware
 from .scgi import SCGIApp, SCGIConfig, SCGIHandler
 from .exceptions import (
     BadRequest,
@@ -55,6 +56,8 @@ __all__ = [
     "Input",
     "Redirect",
     "Link",
+    # Middleware
+    "VirtualHostMiddleware",
     # CGI support
     "CGIConfig",
     "CGIHandler",

xitzin/application.py

@@ -399,6 +399,69 @@ class Xitzin:
 
         self.mount(path, handler, name=name)
 
+    def vhost(
+        self,
+        hosts: dict[str, "Xitzin"],
+        *,
+        default_app: "Xitzin | None" = None,
+        fallback_status: int = 53,
+        fallback_handler: Callable[[Request], Any] | None = None,
+    ) -> None:
+        """Configure virtual hosting for this application.
+
+        This is a convenience method that creates and registers VirtualHostMiddleware.
+        The middleware routes requests to different apps based on hostname.
+
+        Args:
+            hosts: Mapping of hostname patterns to Xitzin apps.
+                Patterns can be exact ("example.com") or wildcards ("*.example.com").
+                Exact matches are checked first, then wildcards in definition order.
+            default_app: Default app when no pattern matches.
+            fallback_status: Status code for unmatched hosts (default: 53).
+                Common values: 53 (Proxy Refused), 51 (Not Found), 59 (Bad Request).
+            fallback_handler: Custom handler for unmatched hosts.
+                Takes precedence over default_app and fallback_status.
+
+        Example:
+            main_app = Xitzin(title="Main")
+            blog_app = Xitzin(title="Blog")
+            api_app = Xitzin(title="API")
+
+            @blog_app.gemini("/")
+            def blog_home(request: Request):
+                return "# Blog Home"
+
+            @api_app.gemini("/")
+            def api_home(request: Request):
+                return "# API Home"
+
+            @main_app.gemini("/")
+            def main_home(request: Request):
+                return "# Main Home"
+
+            # Configure as gateway
+            main_app.vhost({
+                "blog.example.com": blog_app,
+                "*.api.example.com": api_app,
+            }, default_app=main_app)
+
+            main_app.run()
+        """
+        from .middleware import VirtualHostMiddleware
+
+        vhost_mw = VirtualHostMiddleware(
+            hosts,
+            default_app=default_app,
+            fallback_status=fallback_status,
+            fallback_handler=fallback_handler,
+        )
+
+        @self.middleware
+        async def virtual_host_dispatcher(
+            request: Request, call_next: Callable[..., Any]
+        ) -> GeminiResponse:
+            return await vhost_mw(request, call_next)
+
     def on_startup(self, handler: Callable[[], Any]) -> Callable[[], Any]:
         """Register a startup event handler.
 
@@ -559,64 +622,56 @@ class Xitzin:
         """
         request = Request(raw_request, self)
 
-        try:
-            # Check mounted routes first
-            mount_match = self._router.match_mount(request.path)
-            if mount_match is not None:
-                mounted_route, path_info = mount_match
-
-                # Build middleware chain for mounted handler
-                async def call_mounted_handler(req: Request) -> GeminiResponse:
+        # Build middleware chain around the entire routing logic
+        async def route_and_handle(req: Request) -> GeminiResponse:
+            try:
+                # Check mounted routes first
+                mount_match = self._router.match_mount(req.path)
+                if mount_match is not None:
+                    mounted_route, path_info = mount_match
                     result = await mounted_route.call_handler(req, path_info)
                     return convert_response(result, req)
 
-                # Apply middleware
-                handler = call_mounted_handler
-                for mw in reversed(self._middleware):
-                    handler = self._wrap_middleware(mw, handler)
-
-                return await handler(request)
+                # Match regular route
+                match = self._router.match(req.path)
+                if match is None:
+                    raise NotFound(f"No route matches: {req.path}")
 
-            # Match regular route
-            match = self._router.match(request.path)
-            if match is None:
-                raise NotFound(f"No route matches: {request.path}")
+                route, params = match
 
-            route, params = match
+                # Handle input flow
+                if route.input_prompt and not req.query:
+                    return Input(
+                        route.input_prompt, route.sensitive_input
+                    ).to_gemini_response()
 
-            # Handle input flow
-            if route.input_prompt and not request.query:
-                return Input(
-                    route.input_prompt, route.sensitive_input
-                ).to_gemini_response()
+                # Add query to params for input routes
+                if route.input_prompt and req.query:
+                    params["query"] = req.query
 
-            # Add query to params for input routes
-            if route.input_prompt and request.query:
-                params["query"] = request.query
-
-            # Build middleware chain
-            async def call_handler(req: Request) -> GeminiResponse:
+                # Call the handler
                 result = await route.call_handler(req, params)
                 return convert_response(result, req)
 
-            # Apply middleware (in reverse order so first registered runs first)
-            handler = call_handler
-            for mw in reversed(self._middleware):
-                handler = self._wrap_middleware(mw, handler)
+            except GeminiException as e:
+                return GeminiResponse(status=e.status_code, meta=e.message)
+            except Exception:
+                # Log the error and return a generic failure
+                import traceback
 
-            return await handler(request)
+                traceback.print_exc()
+                return GeminiResponse(
+                    status=StatusCode.TEMPORARY_FAILURE,
+                    meta="Internal server error",
+                )
 
-        except GeminiException as e:
-            return GeminiResponse(status=e.status_code, meta=e.message)
-        except Exception:
-            # Log the error and return a generic failure
-            import traceback
+        # Apply middleware around the entire routing logic
+        # This allows middleware to intercept requests before routing
+        handler = route_and_handle
+        for mw in reversed(self._middleware):
+            handler = self._wrap_middleware(mw, handler)
 
-            traceback.print_exc()
-            return GeminiResponse(
-                status=StatusCode.TEMPORARY_FAILURE,
-                meta="Internal server error",
-            )
+        return await handler(request)
 
     async def _handle_titan_request(
         self, raw_request: NauyacaTitanRequest
@@ -627,41 +682,42 @@ class Xitzin:
         """
         request = TitanRequest(raw_request, self)
 
-        try:
-            # Match Titan route
-            match = self._router.match_titan(request.path)
-            if match is None:
-                raise NotFound(f"No Titan route matches: {request.path}")
+        # Build middleware chain around the entire routing logic
+        async def route_and_handle(req: TitanRequest) -> GeminiResponse:
+            try:
+                # Match Titan route
+                match = self._router.match_titan(req.path)
+                if match is None:
+                    raise NotFound(f"No Titan route matches: {req.path}")
 
-            route, params = match
+                route, params = match
 
-            # Validate auth token if required
-            if route.auth_tokens is not None:
-                if not request.token or request.token not in route.auth_tokens:
-                    raise CertificateRequired("Valid authentication token required")
+                # Validate auth token if required
+                if route.auth_tokens is not None:
+                    if not req.token or req.token not in route.auth_tokens:
+                        raise CertificateRequired("Valid authentication token required")
 
-            # Build middleware chain
-            async def call_handler(req: TitanRequest) -> GeminiResponse:
+                # Call the handler
                 result = await route.call_handler(req, params)
                 return convert_response(result, req)
 
-            # Apply middleware (in reverse order so first registered runs first)
-            handler = call_handler
-            for mw in reversed(self._middleware):
-                handler = self._wrap_middleware(mw, handler)
+            except GeminiException as e:
+                return GeminiResponse(status=e.status_code, meta=e.message)
+            except Exception:
+                import traceback
 
-            return await handler(request)
+                traceback.print_exc()
+                return GeminiResponse(
+                    status=StatusCode.TEMPORARY_FAILURE,
+                    meta="Internal server error",
+                )
 
-        except GeminiException as e:
-            return GeminiResponse(status=e.status_code, meta=e.message)
-        except Exception:
-            import traceback
+        # Apply middleware around the entire routing logic
+        handler = route_and_handle
+        for mw in reversed(self._middleware):
+            handler = self._wrap_middleware(mw, handler)
 
-            traceback.print_exc()
-            return GeminiResponse(
-                status=StatusCode.TEMPORARY_FAILURE,
-                meta="Internal server error",
-            )
+        return await handler(request)
 
     def _wrap_middleware(
         self,

xitzin/middleware.py

@@ -7,6 +7,7 @@ and modify responses before they are sent to clients.
 from __future__ import annotations
 
 import asyncio
+import re
 import time
 from abc import ABC
 from collections import OrderedDict
@@ -18,6 +19,7 @@ from nauyaca.protocol.response import GeminiResponse
 from nauyaca.protocol.status import StatusCode
 
 if TYPE_CHECKING:
+    from .application import Xitzin
     from .requests import Request
 
 # Type alias for middleware call_next function
@@ -382,3 +384,185 @@ class UserSessionMiddleware(BaseMiddleware):
                 currsize=len(self._async_cache),
             )
         return self._sync_cached_loader.cache_info()
+
+
+class VirtualHostMiddleware(BaseMiddleware):
+    """Middleware for hostname-based virtual hosting.
+
+    Routes requests to different Xitzin applications based on the hostname
+    in the request URL. Supports exact hostname matches and wildcard patterns.
+
+    Example:
+        from xitzin import Xitzin
+        from xitzin.middleware import VirtualHostMiddleware
+
+        blog_app = Xitzin(title="Blog")
+        api_app = Xitzin(title="API")
+        main_app = Xitzin(title="Gateway")
+
+        @blog_app.gemini("/")
+        def blog_home(request):
+            return "# Blog Home"
+
+        @api_app.gemini("/")
+        def api_home(request):
+            return "# API Home"
+
+        @main_app.gemini("/")
+        def main_home(request):
+            return "# Main Home"
+
+        # Create virtual host middleware
+        vhost_mw = VirtualHostMiddleware({
+            "blog.example.com": blog_app,
+            "*.api.example.com": api_app,
+        }, default_app=main_app)
+
+        @main_app.middleware
+        async def vhost(request, call_next):
+            return await vhost_mw(request, call_next)
+
+        main_app.run()
+    """
+
+    def __init__(
+        self,
+        hosts: dict[str, "Xitzin"],
+        *,
+        default_app: "Xitzin | None" = None,
+        fallback_status: int = 53,
+        fallback_handler: (
+            Callable[["Request"], Any] | Callable[["Request"], Awaitable[Any]] | None
+        ) = None,
+    ) -> None:
+        """Create virtual host middleware.
+
+        Args:
+            hosts: Mapping of hostname patterns to Xitzin apps.
+                Keys can be exact hostnames ("example.com") or wildcard patterns
+                ("*.example.com"). Exact matches are checked first, then wildcards
+                in definition order.
+            default_app: Default app to use when no pattern matches.
+                Takes precedence over fallback_status.
+            fallback_status: Status code to return when no match and no default_app.
+                Defaults to 53 (Proxy Request Refused). Common values:
+                - 53: Proxy Request Refused (default)
+                - 51: Not Found
+                - 59: Bad Request
+            fallback_handler: Custom handler function for unmatched hosts.
+                Receives the request and must return a response. Takes precedence
+                over both default_app and fallback_status. Can be sync or async.
+        """
+        self._default_app = default_app
+        self._fallback_status = fallback_status
+        self._fallback_handler = fallback_handler
+        self._is_fallback_async = (
+            iscoroutinefunction(fallback_handler) if fallback_handler else False
+        )
+
+        # Separate exact and wildcard patterns for efficiency
+        self._exact_hosts: dict[str, "Xitzin"] = {}
+        self._wildcard_patterns: list[tuple[re.Pattern[str], "Xitzin"]] = []
+
+        for pattern, app in hosts.items():
+            if pattern.startswith("*."):
+                compiled = self._compile_wildcard_pattern(pattern)
+                if compiled:
+                    self._wildcard_patterns.append((compiled, app))
+            else:
+                self._exact_hosts[pattern.lower()] = app
+
+    def _compile_wildcard_pattern(self, pattern: str) -> re.Pattern[str] | None:
+        """Convert wildcard pattern to regex.
+
+        Supports patterns like:
+        - *.example.com -> matches "blog.example.com", "api.example.com"
+
+        Args:
+            pattern: Wildcard pattern string starting with "*.".
+
+        Returns:
+            Compiled regex pattern, or None if invalid.
+        """
+        if not pattern.startswith("*."):
+            return None
+
+        # Extract domain part after "*."
+        domain = pattern[2:]
+        # Escape special regex chars in domain
+        domain_escaped = re.escape(domain)
+        # Replace the wildcard with a pattern that matches any non-dot chars
+        regex = f"^[^.]+\\.{domain_escaped}$"
+
+        return re.compile(regex, re.IGNORECASE)
+
+    def _match_hostname(self, hostname: str) -> "Xitzin | None":
+        """Find the app for a given hostname.
+
+        Checks exact matches first, then wildcard patterns in order.
+
+        Args:
+            hostname: The hostname from the request.
+
+        Returns:
+            Matching Xitzin app, or None if no match.
+        """
+        hostname_lower = hostname.lower()
+
+        # Try exact match first
+        if hostname_lower in self._exact_hosts:
+            return self._exact_hosts[hostname_lower]
+
+        # Try wildcard patterns
+        for pattern, app in self._wildcard_patterns:
+            if pattern.match(hostname_lower):
+                return app
+
+        return None
+
+    async def before_request(
+        self, request: "Request"
+    ) -> "Request | GeminiResponse | None":
+        """Route request to appropriate app based on hostname."""
+        from .requests import TitanRequest
+        from .responses import convert_response
+
+        hostname = request.hostname
+
+        # Find matching app
+        app = self._match_hostname(hostname)
+
+        # Handle no match
+        if app is None:
+            # Priority 1: Custom fallback handler
+            if self._fallback_handler:
+                if self._is_fallback_async:
+                    result = await self._fallback_handler(request)
+                else:
+                    loop = asyncio.get_running_loop()
+                    result = await loop.run_in_executor(
+                        None, self._fallback_handler, request
+                    )
+                return convert_response(result, request)
+
+            # Priority 2: Default app
+            if self._default_app:
+                app = self._default_app
+            else:
+                # Priority 3: Fallback status
+                return GeminiResponse(
+                    status=StatusCode(self._fallback_status),
+                    meta="Host not configured for this server",
+                )
+
+        # If the matched app is the same as the request's app, return None
+        # to continue processing through the normal route chain (avoid recursion)
+        if request._app is not None and app is request._app:
+            return None
+
+        # Dispatch to matched app
+        if isinstance(request, TitanRequest):
+            response = await app._handle_titan_request(request._raw_request)
+        else:
+            response = await app._handle_request(request._raw_request)
+        return response

{xitzin-0.4.0.dist-info → xitzin-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: xitzin
-Version: 0.4.0
+Version: 0.5.0
 Summary: A Gemini Application Framework
 Keywords: gemini,protocol,framework,async,geminispace
 Author: Alan Velasco

{xitzin-0.4.0.dist-info → xitzin-0.5.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-xitzin/__init__.py,sha256=GMfAmzBJ6TMZJWfF38r1k0y-vswOdLw9xfWpPfYMcqc,1851
-xitzin/application.py,sha256=axL5G4lRz0KTNLsNQkCGxWD0MGDpIH6Xe9OKkxJlJw8,27851
+xitzin/__init__.py,sha256=EqdQIoz53LTfw5UMeFF-PZmBLa9tHUFrgU4Y2brt2yA,1943
+xitzin/application.py,sha256=ZTAsNQWaZsXf4CIXh7LP3t5KZUsHCgW5HmqYSs-mydU,30004
 xitzin/auth.py,sha256=hHhrP_fYToY6J6CCU8vgAsWbYn6K16LUxkeDMzZTF2Q,5304
 xitzin/cgi.py,sha256=nggSuQ0gXIKdBKWHqH_CNZ6UlVGaB3VAOu3ZRPc43ek,18046
 xitzin/exceptions.py,sha256=82z-CjyC0FwFbo9hGTjjmurlL_Vd4rTVdgkmQoFLXT0,3883
-xitzin/middleware.py,sha256=dZhrbOJPCrrbMiwrbRzxElsC7UDrWc7lvnQ5c0xBHts,12542
+xitzin/middleware.py,sha256=rES7C1gujvP-1evpXfqng9uZ91rzJdqfob-nvGBtTAo,19042
 xitzin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xitzin/requests.py,sha256=1mbm5F8oywLPNpSdh2inn7K1IEeI3H5meOwj8jldi1Q,7783
 xitzin/responses.py,sha256=QVH4B-qVHP7hxi0hIrOJhdCiHDf4PDCpSZ1fAD8iNkk,6525
@@ -13,6 +13,6 @@ xitzin/sqlmodel.py,sha256=lZvDzYAgnG8S2K-EYnx6PkO7D68pjM06uQLSKUZ9yY4,4500
 xitzin/tasks.py,sha256=_smEXy-THge8wmQqWDtX3iUmAmoHniw_qqZBlKjCdqA,4597
 xitzin/templating.py,sha256=spjxb05wgwKA4txOMbWJuwEVMaoLovo13_ukbXAcBDY,6040
 xitzin/testing.py,sha256=wMiToopD2TAqTsreVqOrIUNCayORNQQennxR_GwMBSY,10980
-xitzin-0.4.0.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
-xitzin-0.4.0.dist-info/METADATA,sha256=Zv-Rde7LWIcf_FQfclXu77BzGipWf6_n0fOXVzkvk0A,3456
-xitzin-0.4.0.dist-info/RECORD,,
+xitzin-0.5.0.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+xitzin-0.5.0.dist-info/METADATA,sha256=vOmiKWl7qO1EAvFzFuQgRAK1QHJbMCulY_KoEKH_-3c,3456
+xitzin-0.5.0.dist-info/RECORD,,

{xitzin-0.4.0.dist-info → xitzin-0.5.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.26
+Generator: uv 0.9.28
 Root-Is-Purelib: true
 Tag: py3-none-any