wagtail 6.1.3__py3-none-any.whl → 6.2rc1__py3-none-any.whl

wagtail/contrib/frontend_cache/backends/cloudflare.py

@@ -0,0 +1,114 @@
+import logging
+
+import requests
+from django.core.exceptions import ImproperlyConfigured
+
+from .base import BaseBackend
+
+logger = logging.getLogger("wagtail.frontendcache")
+
+
+__all__ = ["CloudflareBackend"]
+
+
+class CloudflareBackend(BaseBackend):
+    CHUNK_SIZE = 30
+
+    def __init__(self, params):
+        super().__init__(params)
+
+        self.cloudflare_email = params.pop("EMAIL", None)
+        self.cloudflare_api_key = params.pop("TOKEN", None) or params.pop(
+            "API_KEY", None
+        )
+        self.cloudflare_token = params.pop("BEARER_TOKEN", None)
+        self.cloudflare_zoneid = params.pop("ZONEID")
+        self.cloudflare_purge_endpoint_url = (
+            "https://api.cloudflare.com/client/v4/zones/{}/purge_cache".format(
+                self.cloudflare_zoneid
+            )
+        )
+
+        if (
+            (not self.cloudflare_email and self.cloudflare_api_key)
+            or (self.cloudflare_email and not self.cloudflare_api_key)
+            or (
+                not any(
+                    [
+                        self.cloudflare_email,
+                        self.cloudflare_api_key,
+                        self.cloudflare_token,
+                    ]
+                )
+            )
+        ):
+            raise ImproperlyConfigured(
+                "The setting 'WAGTAILFRONTENDCACHE' requires both 'EMAIL' and 'API_KEY', or 'BEARER_TOKEN' to be specified."
+            )
+
+    def _purge_urls(self, urls):
+        try:
+            purge_url = (
+                "https://api.cloudflare.com/client/v4/zones/{}/purge_cache".format(
+                    self.cloudflare_zoneid
+                )
+            )
+
+            headers = {"Content-Type": "application/json"}
+
+            if self.cloudflare_token:
+                headers["Authorization"] = f"Bearer {self.cloudflare_token}"
+            else:
+                headers["X-Auth-Email"] = self.cloudflare_email
+                headers["X-Auth-Key"] = self.cloudflare_api_key
+
+            data = {"files": urls}
+
+            response = requests.delete(
+                purge_url,
+                json=data,
+                headers=headers,
+            )
+
+            try:
+                response_json = response.json()
+            except ValueError:
+                if response.status_code != 200:
+                    response.raise_for_status()
+                else:
+                    for url in urls:
+                        logger.error(
+                            "Couldn't purge '%s' from Cloudflare. Unexpected JSON parse error.",
+                            url,
+                        )
+
+        except requests.exceptions.HTTPError as e:
+            for url in urls:
+                logging.exception(
+                    "Couldn't purge '%s' from Cloudflare. HTTPError: %d",
+                    url,
+                    e.response.status_code,
+                )
+            return
+
+        if response_json["success"] is False:
+            error_messages = ", ".join(
+                [str(err["message"]) for err in response_json["errors"]]
+            )
+            for url in urls:
+                logger.error(
+                    "Couldn't purge '%s' from Cloudflare. Cloudflare errors '%s'",
+                    url,
+                    error_messages,
+                )
+            return
+
+    def purge_batch(self, urls):
+        # Break the batched URLs in to chunks to fit within Cloudflare's maximum size for
+        # the purge_cache call (https://api.cloudflare.com/#zone-purge-files-by-url)
+        for i in range(0, len(urls), self.CHUNK_SIZE):
+            chunk = urls[i : i + self.CHUNK_SIZE]
+            self._purge_urls(chunk)
+
+    def purge(self, url):
+        self._purge_urls([url])

wagtail/contrib/frontend_cache/backends/cloudfront.py

@@ -0,0 +1,99 @@
+import logging
+import uuid
+from collections import defaultdict
+from urllib.parse import urlparse
+from warnings import warn
+
+from django.core.exceptions import ImproperlyConfigured
+
+from wagtail.utils.deprecation import RemovedInWagtail70Warning
+
+from .base import BaseBackend
+
+logger = logging.getLogger("wagtail.frontendcache")
+
+
+__all__ = ["CloudfrontBackend"]
+
+
+class CloudfrontBackend(BaseBackend):
+    def __init__(self, params):
+        import boto3
+
+        super().__init__(params)
+
+        self.client = boto3.client(
+            "cloudfront",
+            aws_access_key_id=params.get("AWS_ACCESS_KEY_ID"),
+            aws_secret_access_key=params.get("AWS_SECRET_ACCESS_KEY"),
+            aws_session_token=params.get("AWS_SESSION_TOKEN"),
+        )
+
+        try:
+            self.cloudfront_distribution_id = params.pop("DISTRIBUTION_ID")
+        except KeyError:
+            raise ImproperlyConfigured(
+                "The setting 'WAGTAILFRONTENDCACHE' requires the object 'DISTRIBUTION_ID'."
+            )
+
+        # Add known hostnames for hostname validation (if not already defined)
+        # RemovedInWagtail70Warning
+        if isinstance(self.cloudfront_distribution_id, dict):
+            if "HOSTNAMES" in params:
+                self.hostnames.extend(self.cloudfront_distribution_id.keys())
+            else:
+                self.hostnames = list(self.cloudfront_distribution_id.keys())
+
+    def purge_batch(self, urls):
+        paths_by_distribution_id = defaultdict(list)
+
+        for url in urls:
+            url_parsed = urlparse(url)
+            distribution_id = None
+
+            if isinstance(self.cloudfront_distribution_id, dict):
+                warn(
+                    "Using a `DISTRIBUTION_ID` mapping is deprecated - use `HOSTNAMES` in combination with multiple backends instead.",
+                    category=RemovedInWagtail70Warning,
+                )
+                host = url_parsed.hostname
+                if host in self.cloudfront_distribution_id:
+                    distribution_id = self.cloudfront_distribution_id.get(host)
+                else:
+                    logger.warning(
+                        "Couldn't purge '%s' from CloudFront. Hostname '%s' not found in the DISTRIBUTION_ID mapping",
+                        url,
+                        host,
+                    )
+            else:
+                distribution_id = self.cloudfront_distribution_id
+
+            if distribution_id:
+                paths_by_distribution_id[distribution_id].append(url_parsed.path)
+
+        for distribution_id, paths in paths_by_distribution_id.items():
+            self._create_invalidation(distribution_id, paths)
+
+    def purge(self, url):
+        self.purge_batch([url])
+
+    def _create_invalidation(self, distribution_id, paths):
+        import botocore
+
+        try:
+            self.client.create_invalidation(
+                DistributionId=distribution_id,
+                InvalidationBatch={
+                    "Paths": {"Quantity": len(paths), "Items": paths},
+                    "CallerReference": str(uuid.uuid4()),
+                },
+            )
+        except botocore.exceptions.ClientError as e:
+            for path in paths:
+                logger.error(
+                    "Couldn't purge path '%s' from CloudFront (DistributionId=%s). ClientError: %s %s",
+                    path,
+                    distribution_id,
+                    e.response["Error"]["Code"],
+                    e.response["Error"]["Message"],
+                )

wagtail/contrib/frontend_cache/backends/http.py

@@ -0,0 +1,64 @@
+import logging
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlsplit, urlunsplit
+from urllib.request import Request, urlopen
+
+from wagtail import __version__
+
+from .base import BaseBackend
+
+logger = logging.getLogger("wagtail.frontendcache")
+
+
+__all__ = ["PurgeRequest", "HTTPBackend"]
+
+
+class PurgeRequest(Request):
+    def get_method(self):
+        return "PURGE"
+
+
+class HTTPBackend(BaseBackend):
+    def __init__(self, params):
+        super().__init__(params)
+        location_url_parsed = urlsplit(params.pop("LOCATION"))
+        self.cache_scheme = location_url_parsed.scheme
+        self.cache_netloc = location_url_parsed.netloc
+
+    def purge(self, url):
+        url_parsed = urlsplit(url)
+        host = url_parsed.hostname
+
+        # Append port to host if it is set in the original URL
+        if url_parsed.port:
+            host += ":" + str(url_parsed.port)
+
+        request = PurgeRequest(
+            url=urlunsplit(
+                [
+                    self.cache_scheme,
+                    self.cache_netloc,
+                    url_parsed.path,
+                    url_parsed.query,
+                    url_parsed.fragment,
+                ]
+            ),
+            headers={
+                "Host": host,
+                "User-Agent": "Wagtail-frontendcache/" + __version__,
+            },
+        )
+
+        try:
+            urlopen(request)
+        except HTTPError as e:
+            logger.error(
+                "Couldn't purge '%s' from HTTP cache. HTTPError: %d %s",
+                url,
+                e.code,
+                e.reason,
+            )
+        except URLError as e:
+            logger.error(
+                "Couldn't purge '%s' from HTTP cache. URLError: %s", url, e.reason
+            )

wagtail/contrib/frontend_cache/tests.py

@@ -5,7 +5,7 @@ import requests
 from azure.mgmt.cdn import CdnManagementClient
 from azure.mgmt.frontdoor import FrontDoorManagementClient
 from django.core.exceptions import ImproperlyConfigured
-from django.test import TestCase
+from django.test import SimpleTestCase, TestCase
 from django.test.utils import override_settings
 
 from wagtail.contrib.frontend_cache.backends import (
@@ -19,6 +19,7 @@ from wagtail.contrib.frontend_cache.backends import (
 from wagtail.contrib.frontend_cache.utils import get_backends
 from wagtail.models import Page
 from wagtail.test.testapp.models import EventIndex
+from wagtail.utils.deprecation import RemovedInWagtail70Warning
 
 from .utils import (
     PurgeBatch,
@@ -29,7 +30,7 @@ from .utils import (
 )
 
 
-class TestBackendConfiguration(TestCase):
+class TestBackendConfiguration(SimpleTestCase):
     def test_default(self):
         backends = get_backends()
 
@@ -81,6 +82,8 @@ class TestBackendConfiguration(TestCase):
                 "cloudfront": {
                     "BACKEND": "wagtail.contrib.frontend_cache.backends.CloudfrontBackend",
                     "DISTRIBUTION_ID": "frontend",
+                    "AWS_ACCESS_KEY_ID": "my-access-key-id",
+                    "AWS_SECRET_ACCESS_KEY": "my-secret-access-key",
                 },
             }
         )
@@ -90,6 +93,12 @@ class TestBackendConfiguration(TestCase):
 
         self.assertEqual(backends["cloudfront"].cloudfront_distribution_id, "frontend")
 
+        credentials = backends["cloudfront"].client._request_signer._credentials
+
+        self.assertEqual(credentials.method, "explicit")
+        self.assertEqual(credentials.access_key, "my-access-key-id")
+        self.assertEqual(credentials.secret_key, "my-secret-access-key")
+
     def test_azure_cdn(self):
         backends = get_backends(
             backend_settings={
@@ -172,7 +181,7 @@ class TestBackendConfiguration(TestCase):
         self.assertIs(client._config.credential, mock_credentials)
 
     @mock.patch(
-        "wagtail.contrib.frontend_cache.backends.AzureCdnBackend._make_purge_call"
+        "wagtail.contrib.frontend_cache.backends.azure.AzureCdnBackend._make_purge_call"
     )
     def test_azure_cdn_purge(self, make_purge_call_mock):
         backends = get_backends(
@@ -214,7 +223,7 @@ class TestBackendConfiguration(TestCase):
         self.assertEqual(call_args[1], ["/home/events/christmas/?test=1", "/blog/"])
 
     @mock.patch(
-        "wagtail.contrib.frontend_cache.backends.AzureFrontDoorBackend._make_purge_call"
+        "wagtail.contrib.frontend_cache.backends.azure.AzureFrontDoorBackend._make_purge_call"
     )
     def test_azure_front_door_purge(self, make_purge_call_mock):
         backends = get_backends(
@@ -285,7 +294,7 @@ class TestBackendConfiguration(TestCase):
             log_output.output[0],
         )
 
-    @mock.patch("wagtail.contrib.frontend_cache.backends.urlopen")
+    @mock.patch("wagtail.contrib.frontend_cache.backends.http.urlopen")
     def _test_http_with_side_effect(self, urlopen_mock, urlopen_side_effect):
         # given a backends configuration with one HTTP backend
         backends = get_backends(
@@ -323,7 +332,7 @@ class TestBackendConfiguration(TestCase):
             )
 
     @mock.patch(
-        "wagtail.contrib.frontend_cache.backends.CloudfrontBackend._create_invalidation"
+        "wagtail.contrib.frontend_cache.backends.cloudfront.CloudfrontBackend._create_invalidation"
     )
     def test_cloudfront_distribution_id_mapping(self, _create_invalidation):
         backends = get_backends(
@@ -336,15 +345,31 @@ class TestBackendConfiguration(TestCase):
                 },
             }
         )
-        backends.get("cloudfront").purge(
-            "http://www.wagtail.org/home/events/christmas/"
-        )
-        backends.get("cloudfront").purge("http://torchbox.com/blog/")
+        with self.assertWarnsMessage(
+            RemovedInWagtail70Warning,
+            "Using a `DISTRIBUTION_ID` mapping is deprecated - use `HOSTNAMES` in combination with multiple backends instead.",
+        ):
+            backends.get("cloudfront").purge(
+                "http://www.wagtail.org/home/events/christmas/"
+            )
+
+        with self.assertWarnsMessage(
+            RemovedInWagtail70Warning,
+            "Using a `DISTRIBUTION_ID` mapping is deprecated - use `HOSTNAMES` in combination with multiple backends instead.",
+        ):
+            backends.get("cloudfront").purge("http://torchbox.com/blog/")
 
         _create_invalidation.assert_called_once_with(
             "frontend", ["/home/events/christmas/"]
         )
 
+        self.assertTrue(
+            backends.get("cloudfront").invalidates_hostname("www.wagtail.org")
+        )
+        self.assertFalse(
+            backends.get("cloudfront").invalidates_hostname("torchbox.com")
+        )
+
     def test_multiple(self):
         backends = get_backends(
             backend_settings={
@@ -396,17 +421,11 @@ PURGED_URLS = []
 
 
 class MockBackend(BaseBackend):
-    def __init__(self, config):
-        pass
-
     def purge(self, url):
         PURGED_URLS.append(url)
 
 
 class MockCloudflareBackend(CloudflareBackend):
-    def __init__(self, config):
-        pass
-
     def _purge_urls(self, urls):
         if len(urls) > self.CHUNK_SIZE:
             raise Exception("Cloudflare backend is not chunking requests as expected")
@@ -465,11 +484,34 @@ class TestCachePurgingFunctions(TestCase):
             ],
         )
 
+    @override_settings(
+        WAGTAILFRONTENDCACHE={
+            "varnish": {
+                "BACKEND": "wagtail.contrib.frontend_cache.tests.MockBackend",
+                "HOSTNAMES": ["example.com"],
+            },
+        }
+    )
+    def test_invalidate_specific_location(self):
+        with self.assertLogs(level="INFO") as log_output:
+            purge_url_from_cache("http://localhost/foo")
+
+        self.assertEqual(PURGED_URLS, [])
+        self.assertIn(
+            "Unable to find purge backend for localhost",
+            log_output.output[0],
+        )
+
+        purge_url_from_cache("http://example.com/foo")
+        self.assertEqual(PURGED_URLS, ["http://example.com/foo"])
+
 
 @override_settings(
     WAGTAILFRONTENDCACHE={
         "cloudflare": {
             "BACKEND": "wagtail.contrib.frontend_cache.tests.MockCloudflareBackend",
+            "ZONEID": "zone",
+            "BEARER_TOKEN": "token",
         },
     }
 )
@@ -634,7 +676,7 @@ class TestPurgeBatchClass(TestCase):
             ],
         )
 
-    @mock.patch("wagtail.contrib.frontend_cache.backends.requests.delete")
+    @mock.patch("wagtail.contrib.frontend_cache.backends.cloudflare.requests.delete")
     def test_http_error_on_cloudflare_purge_batch(self, requests_delete_mock):
         backend_settings = {
             "cloudflare": {

wagtail/contrib/frontend_cache/utils.py

@@ -1,6 +1,7 @@
 import logging
 import re
-from urllib.parse import urlparse, urlunparse
+from collections import defaultdict
+from urllib.parse import urlsplit, urlunsplit
 
 from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
@@ -79,13 +80,12 @@ def purge_urls_from_cache(urls, backend_settings=None, backends=None):
         # Purge the given url for each managed language
         for isocode in languages:
             for url in urls:
-                up = urlparse(url)
-                new_url = urlunparse(
+                up = urlsplit(url)
+                new_url = urlunsplit(
                     (
                         up.scheme,
                         up.netloc,
                         re.sub(langs_regex, "/%s/" % isocode, up.path),
-                        up.params,
                         up.query,
                         up.fragment,
                     )
@@ -100,11 +100,29 @@ def purge_urls_from_cache(urls, backend_settings=None, backends=None):
 
         urls = new_urls
 
-    for backend_name, backend in get_backends(backend_settings, backends).items():
-        for url in urls:
-            logger.info("[%s] Purging URL: %s", backend_name, url)
+    urls_by_hostname = defaultdict(list)
 
-        backend.purge_batch(urls)
+    for url in urls:
+        urls_by_hostname[urlsplit(url).netloc].append(url)
+
+    backends = get_backends(backend_settings, backends)
+
+    for hostname, urls in urls_by_hostname.items():
+        backends_for_hostname = {
+            backend_name: backend
+            for backend_name, backend in backends.items()
+            if backend.invalidates_hostname(hostname)
+        }
+
+        if not backends_for_hostname:
+            logger.info("Unable to find purge backend for %s", hostname)
+            continue
+
+        for backend_name, backend in backends_for_hostname.items():
+            for url in urls:
+                logger.info("[%s] Purging URL: %s", backend_name, url)
+
+            backend.purge_batch(urls)
 
 
 def _get_page_cached_urls(page):

wagtail/contrib/redirects/filters.py

@@ -1,13 +1,27 @@
 import django_filters
 from django import forms
+from django.db.models import QuerySet
 from django.utils.translation import gettext as _
 
 from wagtail.admin.filters import WagtailFilterSet
 from wagtail.contrib.redirects.models import Redirect
-from wagtail.models import Site
+from wagtail.models import Page, Site
+
+
+def get_redirect_pages_queryset(request) -> QuerySet[Page]:
+    redirect_page_pks = (
+        Redirect.objects.filter(redirect_page__isnull=False)
+        .order_by()
+        .values_list("redirect_page", flat=True)
+        .distinct()
+    )
+    return Page.objects.filter(pk__in=redirect_page_pks)
 
 
 class RedirectsReportFilterSet(WagtailFilterSet):
+    redirect_page = django_filters.ModelChoiceFilter(
+        field_name="redirect_page", queryset=get_redirect_pages_queryset
+    )
     is_permanent = django_filters.ChoiceFilter(
         label=_("Type"),
         method="filter_type",