| 1 |
import re |
| 2 |
from typing import Callable, TypeAlias, cast |
| 3 |
|
| 4 |
from asgiref.sync import iscoroutinefunction, sync_to_async |
| 5 |
from django.conf import settings |
| 6 |
from django.db.models import Q |
| 7 |
from django.http import Http404, HttpRequest, HttpResponse |
| 8 |
from django.shortcuts import redirect |
| 9 |
from django.urls import clear_url_caches, set_urlconf |
| 10 |
from django.utils.decorators import sync_and_async_middleware |
| 11 |
|
| 12 |
from django_pgschemas.models import TenantModel as TenantModelBase |
| 13 |
from django_pgschemas.routing.info import DomainInfo, HeadersInfo, SessionInfo |
| 14 |
from django_pgschemas.routing.models import get_primary_domain_for_tenant |
| 15 |
from django_pgschemas.routing.urlresolvers import get_urlconf_from_schema |
| 16 |
from django_pgschemas.schema import Schema, activate, activate_public |
| 17 |
from django_pgschemas.settings import get_tenant_header, get_tenant_session_key |
| 18 |
from django_pgschemas.utils import get_domain_model, get_tenant_model, remove_www |
| 19 |
|
| 20 |
|
| 21 |
def strip_tenant_from_path_factory(prefix: str) -> Callable[[str], str]: |
| 22 |
def strip_tenant_from_path(path: str) -> str: |
| 23 |
return re.sub(r"^/{}/".format(prefix), "/", path) |
| 24 |
|
| 25 |
return strip_tenant_from_path |
| 26 |
|
| 27 |
|
| 28 |
ResponseHandler: TypeAlias = Callable[[HttpRequest], HttpResponse] |
| 29 |
|
| 30 |
|
| 31 |
def route_domain(request: HttpRequest) -> HttpResponse | None: |
| 32 |
hostname = remove_www(request.get_host().split(":")[0]) |
| 33 |
|
| 34 |
activate_public() |
| 35 |
tenant: Schema | None = None |
| 36 |
|
| 37 |
# Checking for static tenants |
| 38 |
for schema, data in settings.TENANTS.items(): |
| 39 |
if schema in ["public", "default"]: |
| 40 |
continue |
| 41 |
if hostname in data.get("DOMAINS", []): |
| 42 |
tenant = Schema.create( |
| 43 |
schema_name=schema, |
| 44 |
routing=DomainInfo(domain=hostname), |
| 45 |
) |
| 46 |
break |
| 47 |
|
| 48 |
# Checking for dynamic tenants |
| 49 |
else: |
| 50 |
DomainModel = get_domain_model() |
| 51 |
|
| 52 |
prefix = request.path.split("/")[1] |
| 53 |
domain = None |
| 54 |
|
| 55 |
if DomainModel is not None: |
| 56 |
try: |
| 57 |
domain = DomainModel.objects.select_related("tenant").get( |
| 58 |
domain=hostname, folder=prefix |
| 59 |
) |
| 60 |
except DomainModel.DoesNotExist: |
| 61 |
try: |
| 62 |
domain = DomainModel.objects.select_related("tenant").get( |
| 63 |
domain=hostname, folder="" |
| 64 |
) |
| 65 |
except DomainModel.DoesNotExist: |
| 66 |
pass |
| 67 |
|
| 68 |
if domain is not None: |
| 69 |
tenant = cast(TenantModelBase, domain.tenant) |
| 70 |
tenant.routing = DomainInfo(domain=hostname) |
| 71 |
request.strip_tenant_from_path = lambda x: x |
| 72 |
|
| 73 |
if prefix and domain.folder == prefix: |
| 74 |
tenant.routing = DomainInfo(domain=hostname, folder=prefix) |
| 75 |
request.strip_tenant_from_path = strip_tenant_from_path_factory(prefix) |
| 76 |
clear_url_caches() # Required to remove previous tenant prefix from cache (#8) |
| 77 |
|
| 78 |
if domain.redirect_to_primary: |
| 79 |
primary_domain = get_primary_domain_for_tenant(tenant) |
| 80 |
if primary_domain: |
| 81 |
path = request.strip_tenant_from_path(request.path) |
| 82 |
return redirect(primary_domain.absolute_url(path), permanent=True) |
| 83 |
|
| 84 |
# Checking fallback domains |
| 85 |
if not tenant: |
| 86 |
for schema, data in settings.TENANTS.items(): |
| 87 |
if schema in ["public", "default"]: |
| 88 |
continue |
| 89 |
if hostname in data.get("FALLBACK_DOMAINS", []): |
| 90 |
tenant = Schema.create( |
| 91 |
schema_name=schema, |
| 92 |
routing=DomainInfo(domain=hostname), |
| 93 |
) |
| 94 |
break |
| 95 |
|
| 96 |
# No tenant found from domain / folder |
| 97 |
if not tenant: |
| 98 |
raise Http404("No tenant for hostname '%s'" % hostname) |
| 99 |
|
| 100 |
urlconf = get_urlconf_from_schema(tenant) |
| 101 |
|
| 102 |
request.tenant = tenant |
| 103 |
request.urlconf = urlconf |
| 104 |
set_urlconf(urlconf) |
| 105 |
|
| 106 |
activate(tenant) |
| 107 |
return None |
| 108 |
|
| 109 |
|
| 110 |
def route_session(request: HttpRequest) -> HttpResponse | None: |
| 111 |
tenant_session_key = get_tenant_session_key() |
| 112 |
|
| 113 |
if not hasattr(request, "session") or not ( |
| 114 |
tenant_ref := request.session.get(tenant_session_key) |
| 115 |
): |
| 116 |
return None |
| 117 |
|
| 118 |
tenant: Schema | None = None |
| 119 |
|
| 120 |
# Checking for static tenants |
| 121 |
for schema, data in settings.TENANTS.items(): |
| 122 |
if schema in ["public", "default"]: |
| 123 |
continue |
| 124 |
if tenant_ref == schema or tenant_ref == data.get("SESSION_KEY"): |
| 125 |
tenant = Schema.create(schema_name=schema) |
| 126 |
break |
| 127 |
|
| 128 |
# Checking for dynamic tenants |
| 129 |
else: |
| 130 |
if (TenantModel := get_tenant_model()) is not None: |
| 131 |
tenant = TenantModel._default_manager.filter( |
| 132 |
Q(pk__iexact=tenant_ref) | Q(schema_name=tenant_ref) |
| 133 |
).first() |
| 134 |
|
| 135 |
if tenant is not None: |
| 136 |
tenant.routing = SessionInfo(reference=tenant_ref) |
| 137 |
request.tenant = tenant |
| 138 |
activate(tenant) |
| 139 |
|
| 140 |
return None |
| 141 |
|
| 142 |
|
| 143 |
def route_headers(request: HttpRequest) -> HttpResponse | None: |
| 144 |
tenant_header = get_tenant_header() |
| 145 |
|
| 146 |
if not (tenant_ref := request.headers.get(tenant_header)): |
| 147 |
return None |
| 148 |
|
| 149 |
tenant: Schema | None = None |
| 150 |
|
| 151 |
# Checking for static tenants |
| 152 |
for schema, data in settings.TENANTS.items(): |
| 153 |
if schema in ["public", "default"]: |
| 154 |
continue |
| 155 |
if tenant_ref == schema or tenant_ref == data.get("HEADER"): |
| 156 |
tenant = Schema.create(schema_name=schema) |
| 157 |
break |
| 158 |
|
| 159 |
# Checking for dynamic tenants |
| 160 |
else: |
| 161 |
if (TenantModel := get_tenant_model()) is not None: |
| 162 |
tenant = TenantModel._default_manager.filter( |
| 163 |
Q(pk__iexact=tenant_ref) | Q(schema_name=tenant_ref) |
| 164 |
).first() |
| 165 |
|
| 166 |
if tenant is not None: |
| 167 |
tenant.routing = HeadersInfo(reference=tenant_ref) |
| 168 |
request.tenant = tenant |
| 169 |
activate(tenant) |
| 170 |
|
| 171 |
return None |
| 172 |
|
| 173 |
|
| 174 |
def middleware_factory( |
| 175 |
handler: Callable[[HttpRequest], HttpResponse | None], |
| 176 |
) -> Callable[[ResponseHandler], ResponseHandler]: |
| 177 |
@sync_and_async_middleware |
| 178 |
def middleware(get_response: ResponseHandler) -> ResponseHandler: |
| 179 |
if iscoroutinefunction(get_response): |
| 180 |
async_base_middleware = sync_to_async(handler) |
| 181 |
|
| 182 |
async def sync_middleware(request: HttpRequest) -> HttpResponse | None: |
| 183 |
if response := await async_base_middleware(request): |
| 184 |
return response |
| 185 |
|
| 186 |
return await get_response(request) |
| 187 |
|
| 188 |
return sync_middleware |
| 189 |
|
| 190 |
else: |
| 191 |
|
| 192 |
def async_middleware(request: HttpRequest) -> HttpResponse | None: |
| 193 |
if response := handler(request): |
| 194 |
return response |
| 195 |
|
| 196 |
return get_response(request) |
| 197 |
|
| 198 |
return async_middleware |
| 199 |
|
| 200 |
return middleware |
| 201 |
|
| 202 |
|
| 203 |
DomainRoutingMiddleware = middleware_factory(route_domain) |
| 204 |
SessionRoutingMiddleware = middleware_factory(route_session) |
| 205 |
HeadersRoutingMiddleware = middleware_factory(route_headers) |