django-multisite2 2.0.0__py3-none-any.whl

multisite/exceptions.py

@@ -0,0 +1,57 @@
+from django.conf import settings
+
+
+class MultisiteError(Exception):
+    pass
+
+
+class MultisiteSiteDoesNotExist(Exception):
+    pass
+
+
+class MultisiteCacheError(Exception):
+    pass
+
+
+class MultisiteFallbackError(Exception):
+    pass
+
+
+class MultisiteDisallowedHost(Exception):
+    pass
+
+
+class MultisiteInvalidHostError(Exception):
+    pass
+
+
+class MultisiteServerError(Exception):
+    pass
+
+
+class MultisiteCookieDomainDepthError(Exception):
+    pass
+
+
+def debug_raise_disallowed_host_exception(e):
+    if getattr(settings, "MULTISITE_DEBUG", None):
+        raise MultisiteDisallowedHost(
+            f"DisallowedHost. To silence this exception, set MULTISITE_DEBUG=False. Got {e}."
+        )
+
+
+def debug_raise_cache_missed_exception(netloc, alias):
+    if getattr(settings, "MULTISITE_DEBUG", None):
+        raise MultisiteCacheError(
+            f"Cache missed. Got location {netloc} and Alias {alias}. "
+            "To silence this exception, set MULTISITE_DEBUG=False."
+        )
+
+
+def debug_check_status_code(response, **kwargs) -> None:
+    if response.status_code == 500 and getattr(settings, "MULTISITE_DEBUG", None):
+        raise MultisiteServerError(
+            f"HttpResponse 500. {kwargs}. Got {response}."
+            "To silence this exception, set MULTISITE_DEBUG=False."
+        )
+    return None

multisite/forms.py

@@ -0,0 +1,22 @@
+from __future__ import absolute_import, unicode_literals
+
+from django.contrib.sites.admin import SiteAdmin
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
+
+from .models import Alias
+
+
+class SiteForm(SiteAdmin.form):
+    def clean_domain(self):
+        domain = self.cleaned_data["domain"]
+
+        try:
+            alias = Alias.objects.get(domain=domain)
+        except ObjectDoesNotExist:
+            # New Site that doesn't clobber an Alias
+            return domain
+
+        if alias.site_id == self.instance.pk and alias.is_canonical:
+            return domain
+
+        raise ValidationError('Cannot overwrite non-canonical Alias: "%s"' % alias.domain)

multisite/hacks.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import sys
+
+from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist
+from django.db.models.signals import post_delete, post_save
+
+__all__ = ["use_framework_for_site_cache"]
+
+from multisite.exceptions import MultisiteSiteDoesNotExist
+
+
+def use_framework_for_site_cache():
+    """Patches sites app to use the caching framework instead of a dict.
+
+    This patch has to exist because SITE_CACHE is normally a dict,
+    which is local only to the process. When running multiple
+    processes, a change to a Site will not be reflected across other
+    ones.
+    """
+    from django.contrib.sites import models
+
+    # Patch the SITE_CACHE
+    site_cache = SiteCache()
+    models.SITE_CACHE = DictCache(site_cache)
+
+    # Patch the SiteManager class
+    models.SiteManager.clear_cache = site_manager_clear_cache
+    models.SiteManager._get_site_by_id = site_manager_get_site_by_id
+
+    # Hooks to update SiteCache
+    post_save.connect(site_cache._site_changed_hook, sender=models.Site)
+    post_delete.connect(site_cache._site_deleted_hook, sender=models.Site)
+
+
+def site_manager_clear_cache(self):
+    """Clears the ``Site`` object cache.
+
+    Override `SiteManager.clear_cache` so it doesn't clobber
+    SITE_CACHE
+    """
+    models = sys.modules.get(self.__class__.__module__)
+    models.SITE_CACHE.clear()
+
+
+def site_manager_get_site_by_id(self, site_id):
+    """Patch _get_site_by_id to retrieve the site from the cache at
+    the beginning of the method to avoid a race condition.
+
+    Override SiteManager._get_site_by_id
+    """
+    models = sys.modules.get(self.__class__.__module__)
+    site = models.SITE_CACHE.get(site_id)
+    if site is None:
+        try:
+            site = self.get(pk=site_id)
+        except ObjectDoesNotExist as e:
+            raise MultisiteSiteDoesNotExist(f"{e} Got site_id={site_id}.")
+        models.SITE_CACHE[site_id] = site
+    return site
+
+
+class SiteCache:
+    """Wrapper for SITE_CACHE that assigns a key_prefix."""
+
+    def __init__(self, cache=None):
+        from django.core.cache import caches
+
+        if cache is None:
+            cache_alias = getattr(settings, "CACHE_MULTISITE_ALIAS", "default")
+            self._key_prefix = getattr(
+                settings,
+                "CACHE_MULTISITE_KEY_PREFIX",
+                settings.CACHES[cache_alias].get("KEY_PREFIX", ""),
+            )
+            cache = caches[cache_alias]
+        else:
+            self._key_prefix = getattr(
+                settings, "CACHE_MULTISITE_KEY_PREFIX", cache.key_prefix
+            )
+        self._cache = cache
+
+    def _get_cache_key(self, key):
+        return "sites.%s.%s" % (self.key_prefix, key)
+
+    def _clean_site(self, site):
+        # Force site.id to be an int, not a SiteID object.
+        site.id = int(site.id)
+        return site
+
+    @property
+    def key_prefix(self):
+        return self._key_prefix
+
+    def get(self, key, *args, **kwargs):
+        return self._cache.get(key=self._get_cache_key(key), *args, **kwargs)
+
+    def set(self, key, value, *args, **kwargs):
+        self._cache.set(
+            key=self._get_cache_key(key), value=self._clean_site(value), *args, **kwargs
+        )
+
+    def delete(self, key, *args, **kwargs):
+        self._cache.delete(key=self._get_cache_key(key), *args, **kwargs)
+
+    def __contains__(self, key, *args, **kwargs):
+        return self._cache.__contains__(key=self._get_cache_key(key), *args, **kwargs)
+
+    def clear(self, *args, **kwargs):
+        self._cache.clear(*args, **kwargs)
+
+    def _site_changed_hook(self, sender, instance, raw, *args, **kwargs):
+        if raw:
+            return
+        self.set(key=instance.pk, value=instance)
+
+    def _site_deleted_hook(self, sender, instance, *args, **kwargs):
+        self.delete(key=instance.pk)
+
+
+class DictCache:
+    """Add dictionary protocol to `django.core.cache.backends.
+    BaseCache`.
+    """
+
+    def __init__(self, cache):
+        self._cache = cache
+
+    def __getitem__(self, key):
+        """x.__getitem__(y) <==> x[y]"""
+        hash(key)  # Raise TypeError if unhashable
+        result = self._cache.get(key=key)
+        if result is None:
+            raise KeyError(key)
+        return result
+
+    def __setitem__(self, key, value):
+        """x.__setitem__(i, y) <==> x[i]=y"""
+        hash(key)  # Raise TypeError if unhashable
+        self._cache.set(key=key, value=value)
+
+    def __delitem__(self, key):
+        """x.__delitem__(y) <==> del x[y]"""
+        hash(key)  # Raise TypeError if unhashable
+        self._cache.delete(key=key)
+
+    def __contains__(self, item):
+        """D.__contains__(k) -> True if D has a key k, else False."""
+        hash(item)  # Raise TypeError if unhashable
+        return self._cache.__contains__(key=item)
+
+    def clear(self):
+        """D.clear() -> None.  Remove all items from D."""
+        self._cache.clear()
+
+    def get(self, key, default=None, version=None):
+        """D.key(k[, d]) -> k if D has a key k, else d.
+
+        Defaults to None.
+        """
+        hash(key)  # Raise TypeError if unhashable
+        return self._cache.get(key=key, default=default, version=version)

multisite/management/commands/update_public_suffix_list.py

@@ -0,0 +1,33 @@
+from __future__ import absolute_import, print_function, unicode_literals
+
+import logging
+import tempfile
+
+import tldextract
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    def handle(self, **options):
+        self.setup_logging(verbosity=options.get("verbosity", 1))
+
+        cache_dir = getattr(
+            settings, "MULTISITE_PUBLIC_SUFFIX_LIST_CACHE_DIR", tempfile.gettempdir()
+        )
+        self.log("Updating {cache_dir}".format(cache_dir=cache_dir))
+
+        extract = tldextract.TLDExtract(cache_dir=cache_dir)
+        extract.update(fetch_now=True)
+        self.log("Done.")
+
+    def setup_logging(self, verbosity):
+        self.verbosity = int(verbosity)
+
+        # Connect to tldextract's logger
+        self.logger = logging.getLogger("tldextract")
+        if self.verbosity < 2:
+            self.logger.setLevel(logging.CRITICAL)
+
+    def log(self, msg):
+        self.logger.info(msg)

multisite/middleware/__init__.py

@@ -0,0 +1,4 @@
+from .cookie_domain_middleware import CookieDomainMiddleware
+from .dynamic_site_middleware import DynamicSiteMiddleware
+
+__all__ = ["CookieDomainMiddleware", "DynamicSiteMiddleware"]

multisite/middleware/cookie_domain_middleware.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import tempfile
+
+import tldextract
+from django.conf import settings
+
+__all__ = ["CookieDomainMiddleware"]
+
+from multisite.exceptions import MultisiteCookieDomainDepthError
+
+
+def get_cookie_domain_depth():
+    return getattr(settings, "MULTISITE_COOKIE_DOMAIN_DEPTH", 0)
+
+
+def get_public_suffix_list_cache_dir():
+    return getattr(settings, "MULTISITE_PUBLIC_SUFFIX_LIST_CACHE_DIR", None)
+
+
+class CookieDomainMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+        try:
+            self.depth = int(get_cookie_domain_depth())
+        except ValueError:
+            raise MultisiteCookieDomainDepthError(
+                f"Invalid MULTISITE_COOKIE_DOMAIN_DEPTH. Got {get_cookie_domain_depth()}"
+            )
+        if self.depth < 0:
+            raise MultisiteCookieDomainDepthError(
+                f"Invalid MULTISITE_COOKIE_DOMAIN_DEPTH. Got {get_cookie_domain_depth()}"
+            )
+        self.psl_cache_dir = get_public_suffix_list_cache_dir()
+        if self.psl_cache_dir is None:
+            self.psl_cache_dir = tempfile.gettempdir()
+        self._tldextract = None
+
+    def __call__(self, request):
+        response = self.get_response(request)
+        matched = self.match_cookies(response)
+        if not matched:
+            return response  # No cookies to edit
+
+        parsed = self.tldextract(request.get_host())
+        if not parsed.suffix:
+            return response  # IP address or local path
+        if not parsed.domain:
+            return response  # Only TLD
+
+        subdomains = parsed.subdomain.split(".") if parsed.subdomain else []
+        if not self.depth:
+            subdomains = [""]
+        elif len(subdomains) < self.depth:
+            return response  # Not enough subdomain parts
+        else:
+            subdomains = [""] + subdomains[-self.depth :]
+
+        domain = ".".join(subdomains + [parsed.domain, parsed.suffix])
+
+        for morsel in matched:
+            morsel["domain"] = domain
+        return response
+
+    def tldextract(self, url):
+        if self._tldextract is None:
+            self._tldextract = tldextract.TLDExtract(cache_dir=self.psl_cache_dir)
+        return self._tldextract(url)
+
+    @staticmethod
+    def match_cookies(response):
+        return [c for c in response.cookies.values() if not c["domain"]]

multisite/middleware/dynamic_site_middleware.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from hashlib import md5 as md5_constructor
+from urllib.parse import urlsplit, urlunsplit
+
+from django.conf import settings
+from django.contrib.sites.models import SITE_CACHE, Site
+from django.core import mail
+from django.core.cache import caches
+from django.core.exceptions import DisallowedHost
+from django.db.models.signals import post_delete, post_init, pre_save
+from django.http import HttpResponse, HttpResponsePermanentRedirect
+
+from ..exceptions import (
+    MultisiteError,
+    MultisiteInvalidHostError,
+    debug_check_status_code,
+    debug_raise_cache_missed_exception,
+    debug_raise_disallowed_host_exception,
+)
+from ..models import Alias
+
+__all__ = ["DynamicSiteMiddleware"]
+
+from ..utils import (
+    get_cache_multisite_alias,
+    get_cache_multisite_prefix,
+    get_fallback_kwargs,
+    get_fallback_view_or_404,
+)
+
+
+class DynamicSiteMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+        if not hasattr(settings.SITE_ID, "set"):
+            raise MultisiteError(
+                "Invalid type for settings.SITE_ID: %s" % type(settings.SITE_ID).__name__
+            )
+
+        self.cache_alias = get_cache_multisite_alias()
+        self.key_prefix = get_cache_multisite_prefix() or settings.CACHES[
+            self.cache_alias
+        ].get("KEY_PREFIX", "")
+
+        self.cache = caches[self.cache_alias]
+        post_init.connect(
+            self.site_domain_cache_hook, sender=Site, dispatch_uid="multisite_post_init"
+        )
+        pre_save.connect(self.site_domain_changed_hook, sender=Site)
+        post_delete.connect(self.site_deleted_hook, sender=Site)
+
+    def __call__(self, request):
+        # if 500 here -> Site ObjectDoesNotExist was raised by get_current_site()
+        # debug_check_status_code(response, request=request)
+        try:
+            netloc = request.get_host().lower()
+        except DisallowedHost as e:
+            debug_raise_disallowed_host_exception(e)
+            settings.SITE_ID.reset()
+            response = self.fallback_view(request)
+        else:
+            cache_key = self.get_cache_key(netloc)
+            if (alias := self.cache.get(cache_key)) is not None:
+                # found Alias
+                self.cache.set(cache_key, alias)
+                settings.SITE_ID.set(alias.site_id)
+                response = self.redirect_to_canonical(request, alias)
+            elif (alias := self.get_alias(netloc)) is None:
+                # Cache missed, fallback using settings.MULTISITE_FALLBACK
+                debug_raise_cache_missed_exception(netloc, alias)
+                settings.SITE_ID.reset()
+                response = self.fallback_view(request)
+            else:
+                # found Site
+                self.cache.set(cache_key, alias)
+                settings.SITE_ID.set(alias.site_id)
+                SITE_CACHE[settings.SITE_ID] = alias.site  # Pre-populate SITE_CACHE
+                response = self.redirect_to_canonical(request, alias)
+                # debug_check_status_code(response, netloc=netloc, alias=alias, site=alias.site)
+        return response or self.get_response(request)
+
+    @staticmethod
+    def redirect_to_canonical(request, alias: Alias) -> HttpResponse | None:
+        if not alias.redirect_to_canonical or alias.is_canonical:
+            response = None
+        else:
+            url = urlsplit(request.build_absolute_uri(request.get_full_path()))
+            url = urlunsplit(
+                (url.scheme, alias.site.domain, url.path, url.query, url.fragment)
+            )
+            response = HttpResponsePermanentRedirect(url)
+        return response
+
+    def get_cache_key(self, netloc):
+        """Returns a cache key based on ``netloc``."""
+        netloc = md5_constructor(netloc.encode("utf-8"), usedforsecurity=False)
+        return "multisite.alias.%s.%s" % (self.key_prefix, netloc.hexdigest())
+
+    @staticmethod
+    def netloc_parse(netloc):
+        """Returns ``(host, port)`` for ``netloc`` of the form
+        ``'host:port'``.
+
+        If netloc does not have a port number, ``port`` will be None.
+        """
+        if ":" in netloc:
+            return netloc.rsplit(":", 1)
+        else:
+            return netloc, None
+
+    def get_alias(self, netloc) -> Alias | None:
+        """Returns Alias matching ``netloc``. Otherwise,
+        returns None.
+        """
+        host, port = self.netloc_parse(netloc)
+        try:
+            alias = Alias.objects.resolve(host=host, port=port)
+        except MultisiteInvalidHostError:
+            alias = None
+        if alias is None:
+            # Running under TestCase or runserver?
+            alias = self.get_development_alias(netloc)
+        return alias
+
+    @staticmethod
+    def fallback_view(request) -> HttpResponse:
+        """Runs the fallback view function in
+        ``settings.MULTISITE_FALLBACK``.
+
+        If ``MULTISITE_FALLBACK`` is None, raises an Http404 error.
+
+        If ``MULTISITE_FALLBACK`` is callable, will treat that
+        callable as a view that returns an HttpResponse.
+
+        If ``MULTISITE_FALLBACK`` is a string, will resolve it to a
+        view that returns an HttpResponse.
+
+        In order to use a generic view that takes additional
+        parameters, ``settings.MULTISITE_FALLBACK_KWARGS`` may be a
+        dictionary of additional keyword arguments.
+        """
+        view = get_fallback_view_or_404()
+        kwargs = get_fallback_kwargs()
+        if hasattr(view, "as_view"):
+            return view.as_view(**kwargs)(request)
+        return view(request, **kwargs)
+
+    @staticmethod
+    def get_development_alias(netloc) -> Alias:
+        """Returns valid Alias when in development mode. Otherwise,
+        returns None.
+
+        Development mode is either:
+        - Running tests, i.e. manage.py test
+        - Running locally in `settings.DEBUG` = True, where the
+          hostname is a top-level name, i.e. localhost
+        """
+        alias = None
+        # When running tests, django.core.mail.outbox exists and
+        # netloc == 'testserver'
+        is_testserver = hasattr(mail, "outbox") and netloc in (
+            "testserver",
+            "adminsite.com",
+        )
+        # When using runserver, assume that host will only have one path
+        # component. This covers 'localhost' and your machine name.
+        is_local_debug = settings.DEBUG and len(netloc.split(".")) == 1
+        if is_testserver or is_local_debug:
+            try:
+                # Prefer the default SITE_ID
+                site_id = settings.SITE_ID.get_default()
+            except ValueError:
+                # Fallback to the first Site object
+                alias = Alias.canonical.order_by("site")[0]
+            else:
+                alias = Alias.canonical.get(site=site_id)
+        return alias
+
+    @classmethod
+    def site_domain_cache_hook(cls, sender, instance, *args, **kwargs):
+        """Caches `Site.domain` in the object for
+        site_domain_changed_hook.
+        """
+        instance._domain_cache = instance.domain
+
+    def site_domain_changed_hook(self, sender, instance, raw, *args, **kwargs):
+        """Clears the cache if `Site.domain` has changed."""
+        if raw or instance.pk is None:
+            return
+
+        original = getattr(instance, "_domain_cache", None)
+        if original != instance.domain:
+            self.cache.clear()
+
+    def site_deleted_hook(self, *args, **kwargs):
+        """Clears the cache if Site was deleted."""
+        self.cache.clear()

multisite/migrations/0001_initial.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, unicode_literals
+
+from django.db import migrations, models
+
+import multisite.models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("sites", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Alias",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        verbose_name="ID",
+                        serialize=False,
+                        auto_created=True,
+                        primary_key=True,
+                    ),
+                ),
+                (
+                    "domain",
+                    models.CharField(
+                        help_text='Either "domain" or "domain:port"',
+                        unique=True,
+                        max_length=100,
+                        verbose_name="domain name",
+                    ),
+                ),
+                (
+                    "is_canonical",
+                    models.NullBooleanField(
+                        default=None,
+                        validators=[multisite.models.validators.validate_true_or_none],
+                        editable=False,
+                        help_text="Does this domain name match the one in site?",
+                        verbose_name="is canonical?",
+                    ),
+                ),
+                (
+                    "redirect_to_canonical",
+                    models.BooleanField(
+                        default=True,
+                        help_text="Should this domain name redirect to the one in site?",
+                        verbose_name="redirect to canonical?",
+                    ),
+                ),
+                (
+                    "site",
+                    models.ForeignKey(
+                        related_name="aliases",
+                        to="sites.Site",
+                        on_delete=models.CASCADE,
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name_plural": "aliases",
+            },
+        ),
+        migrations.AlterUniqueTogether(
+            name="alias",
+            unique_together=set([("is_canonical", "site")]),
+        ),
+    ]

multisite/migrations/0002_alter_alias_id_alter_alias_is_canonical.py

@@ -0,0 +1,32 @@
+# Generated by Django 4.0.4 on 2022-05-12 23:39
+
+from django.db import migrations, models
+
+import multisite.models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("multisite", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="alias",
+            name="id",
+            field=models.BigAutoField(
+                auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+            ),
+        ),
+        migrations.AlterField(
+            model_name="alias",
+            name="is_canonical",
+            field=models.BooleanField(
+                default=False,
+                editable=False,
+                help_text="Does this domain name match the one in site?",
+                validators=[multisite.models.validators.validate_true_or_none],
+                verbose_name="is canonical?",
+            ),
+        ),
+    ]