pulumi-django-azure 1.0.28__py3-none-any.whl → 1.0.59__py3-none-any.whl

pulumi_django_azure/management/commands/fix_cache_control.py

@@ -0,0 +1,119 @@
+import os
+
+from azure.storage.blob import BlobServiceClient
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+from pulumi_django_azure.azure_helper import AZURE_CREDENTIAL
+
+DEFAULT_CACHE_CONTROL = "public,max-age=31536000,immutable"
+
+
+class Command(BaseCommand):
+    help = "Loops over all files in the static and media containers and applies the cache-control setting if it is not set yet."
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--cache-control",
+            action="store",
+            default=DEFAULT_CACHE_CONTROL,
+            help="The cache-control setting to apply to the blobs",
+        )
+
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show what would be updated without actually updating the blobs",
+        )
+
+    def handle(self, *args, **options):
+        dry_run = options["dry_run"]
+        cache_control = options["cache_control"]
+        # Get storage account name and containers from settings
+        storage_account_name = getattr(settings, "AZURE_ACCOUNT_NAME", None)
+        if not storage_account_name:
+            self.stderr.write(self.style.ERROR("AZURE_ACCOUNT_NAME is not set in settings."))
+            return
+
+        # Get containers from environment variables
+        media_container = os.getenv("AZURE_STORAGE_CONTAINER_MEDIA")
+        static_container = os.getenv("AZURE_STORAGE_CONTAINER_STATICFILES")
+
+        containers = []
+        if media_container:
+            containers.append(("media", media_container))
+        if static_container:
+            containers.append(("static", static_container))
+
+        if not containers:
+            self.stderr.write(
+                self.style.ERROR("No containers configured (AZURE_STORAGE_CONTAINER_MEDIA or AZURE_STORAGE_CONTAINER_STATICFILES).")
+            )
+            return
+
+        # Get cache-control setting
+        self.stdout.write(f"Using cache-control: {cache_control}")
+
+        # Create BlobServiceClient
+        account_url = f"https://{storage_account_name}.blob.core.windows.net"
+        blob_service_client = BlobServiceClient(account_url=account_url, credential=AZURE_CREDENTIAL)
+
+        total_updated = 0
+        total_skipped = 0
+        total_errors = 0
+
+        for container_type, container_name in containers:
+            self.stdout.write(f"\nProcessing {container_type} container: {container_name}")
+            try:
+                container_client = blob_service_client.get_container_client(container_name)
+
+                # List all blobs in the container
+                blobs = container_client.list_blobs()
+                blob_count = 0
+
+                for blob in blobs:
+                    blob_count += 1
+                    blob_client = blob_service_client.get_blob_client(container=container_name, blob=blob.name)
+
+                    # Get current blob properties
+                    try:
+                        properties = blob_client.get_blob_properties()
+                        content_settings = properties.content_settings
+                        current_cache_control = content_settings.cache_control if content_settings else None
+
+                        # Check if cache-control is already set
+                        if current_cache_control:
+                            if dry_run:
+                                self.stdout.write(f"  [SKIP] {blob.name} (already has cache-control: {current_cache_control})")
+                            total_skipped += 1
+                        else:
+                            # Set cache-control if not set
+                            if dry_run:
+                                self.stdout.write(f"  [WOULD UPDATE] {blob.name}")
+                            else:
+                                # Create new content settings with the new cache-control
+                                content_settings.cache_control = cache_control
+                                blob_client.set_http_headers(content_settings=content_settings)
+                                self.stdout.write(f"  [UPDATED] {blob.name}")
+                            total_updated += 1
+
+                    except Exception as e:
+                        self.stderr.write(self.style.ERROR(f"  [ERROR] {blob.name}: {str(e)}"))
+                        total_errors += 1
+
+                self.stdout.write(f"Processed {blob_count} blobs in {container_name}")
+
+            except Exception as e:
+                self.stderr.write(self.style.ERROR(f"Error processing container {container_name}: {str(e)}"))
+                total_errors += 1
+
+        # Summary
+        self.stdout.write("\n" + "=" * 60)
+        self.stdout.write("Summary:")
+        if dry_run:
+            self.stdout.write(f"  Would update: {total_updated} blobs")
+        else:
+            self.stdout.write(f"  Updated: {total_updated} blobs")
+        self.stdout.write(f"  Skipped (already set): {total_skipped} blobs")
+        self.stdout.write(f"  Errors: {total_errors} blobs")
+        self.stdout.write("=" * 60)

pulumi_django_azure/management/commands/purge_cache.py

@@ -1,5 +1,6 @@
 from django.core.cache import cache
 from django.core.management.base import BaseCommand
+from django_redis import get_redis_connection
 
 
 class Command(BaseCommand):
@@ -10,6 +11,13 @@ class Command(BaseCommand):
 
         try:
             cache.clear()
-            self.stdout.write(self.style.SUCCESS("Successfully purged cache."))
+            self.stdout.write(self.style.SUCCESS("Successfully purged cache using cache.clear()."))
         except Exception as e:
-            self.stdout.write(self.style.ERROR(f"Failed to purge cache: {e}"))
+            self.stdout.write(self.style.ERROR(f"Failed to purge cache using cache.clear(): {e}"))
+
+        try:
+            redis_conn = get_redis_connection("default")
+            redis_conn.flushall()
+            self.stdout.write(self.style.SUCCESS("Successfully purged cache using redis flushall()."))
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"Failed to purge cache using redis flushall(): {e}"))

pulumi_django_azure/management/commands/purge_cdn.py

@@ -1,7 +1,7 @@
 import os
 
 from azure.mgmt.cdn import CdnManagementClient
-from azure.mgmt.cdn.models import PurgeParameters
+from azure.mgmt.cdn.models import AfdPurgeParameters
 from django.conf import settings
 from django.core.management.base import BaseCommand
 
@@ -23,7 +23,10 @@ class Command(BaseCommand):
         resource_group = os.getenv("WEBSITE_RESOURCE_GROUP")
         profile_name = os.getenv("CDN_PROFILE")
         endpoint_name = os.getenv("CDN_ENDPOINT")
-        content_paths = ["/*"]
+        cdn_host = os.getenv("CDN_HOST")
+        media_container = os.getenv("AZURE_STORAGE_CONTAINER_MEDIA")
+        static_container = os.getenv("AZURE_STORAGE_CONTAINER_STATICFILES")
+        content_paths = [f"/{media_container}/*", f"/{static_container}/*"]
 
         # Ensure all required environment variables are set
         if not all([resource_group, profile_name, endpoint_name]):
@@ -35,11 +38,14 @@ class Command(BaseCommand):
 
         try:
             # Purge the CDN endpoint
-            purge_operation = cdn_client.endpoints.begin_purge_content(
+            purge_operation = cdn_client.afd_endpoints.begin_purge_content(
                 resource_group_name=resource_group,
                 profile_name=profile_name,
                 endpoint_name=endpoint_name,
-                content_file_paths=PurgeParameters(content_paths=content_paths),
+                contents=AfdPurgeParameters(
+                    domains=[cdn_host],
+                    content_paths=content_paths,
+                ),
             )
 
             # Check if the --wait argument was provided

pulumi_django_azure/management/commands/test_redis.py

@@ -0,0 +1,248 @@
+"""
+Management command to test Redis connectivity and functionality.
+"""
+
+import time
+
+from django.conf import settings
+from django.core.cache import cache
+from django.core.management.base import BaseCommand, CommandError
+
+
+class Command(BaseCommand):
+    help = "Test Redis connectivity and basic functionality"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--detailed",
+            action="store_true",
+            help="Show detailed Redis information and run comprehensive tests",
+        )
+        parser.add_argument(
+            "--quiet",
+            action="store_true",
+            help="Only show errors and final status",
+        )
+
+    def handle(self, *args, **options):
+        verbosity = 0 if options["quiet"] else (2 if options["detailed"] else 1)
+
+        if verbosity >= 1:
+            self.stdout.write("Testing Redis connectivity...")
+            self.stdout.write("-" * 50)
+
+        try:
+            # Test basic connectivity
+            self._test_basic_connectivity(verbosity)
+
+            # Test basic cache operations
+            self._test_cache_operations(verbosity)
+
+            # If detailed mode, run additional tests
+            if options["detailed"]:
+                self._test_detailed_operations(verbosity)
+                self._show_cache_info(verbosity)
+
+            if verbosity >= 1:
+                self.stdout.write(self.style.SUCCESS("✓ All Redis tests passed successfully!"))
+
+        except Exception as e:
+            if verbosity >= 1:
+                self.stdout.write(self.style.ERROR(f"✗ Redis test failed: {str(e)}"))
+            raise CommandError(f"Redis connectivity test failed: {str(e)}") from e
+
+    def _test_basic_connectivity(self, verbosity):
+        """Test basic Redis connectivity."""
+        if verbosity >= 2:
+            self.stdout.write("Testing basic connectivity...")
+
+        try:
+            # Try to set and get a simple value
+            cache.set("redis_test_key", "test_value", 30)
+            value = cache.get("redis_test_key")
+
+            if value != "test_value":
+                raise Exception("Failed to retrieve test value from cache")
+
+            # Clean up
+            cache.delete("redis_test_key")
+
+            if verbosity >= 2:
+                self.stdout.write(self.style.SUCCESS("  ✓ Basic connectivity test passed"))
+
+        except Exception as e:
+            raise Exception(f"Basic connectivity test failed: {str(e)}") from e
+
+    def _test_cache_operations(self, verbosity):
+        """Test various cache operations."""
+        if verbosity >= 2:
+            self.stdout.write("Testing cache operations...")
+
+        test_data = {
+            "string_test": "Hello Redis!",
+            "number_test": 42,
+            "dict_test": {"key": "value", "nested": {"data": True}},
+            "list_test": [1, 2, 3, "four", 5.0],
+        }
+
+        try:
+            # Test different data types
+            for key, value in test_data.items():
+                cache.set(f"test_{key}", value, 60)
+                retrieved_value = cache.get(f"test_{key}")
+
+                if retrieved_value != value:
+                    raise Exception(f"Data mismatch for {key}: expected {value}, got {retrieved_value}")
+
+                if verbosity >= 2:
+                    self.stdout.write(f"  ✓ {key}: {type(value).__name__} data test passed")
+
+            # Test cache.get_or_set
+            default_value = "default_from_function"
+            result = cache.get_or_set("test_get_or_set", default_value, 60)
+            if result != default_value:
+                raise Exception("get_or_set test failed")
+
+            if verbosity >= 2:
+                self.stdout.write("  ✓ get_or_set operation test passed")
+
+            # Test cache.add (should fail on existing key)
+            if cache.add("test_string_test", "should_not_override"):
+                raise Exception("add() should have failed on existing key")
+
+            if verbosity >= 2:
+                self.stdout.write("  ✓ add operation test passed")
+
+            # Test cache expiration
+            cache.set("test_expiration", "will_expire", 1)
+            time.sleep(1.1)  # Wait for expiration
+            expired_value = cache.get("test_expiration")
+            if expired_value is not None:
+                raise Exception("Cache expiration test failed - value should have expired")
+
+            if verbosity >= 2:
+                self.stdout.write("  ✓ Cache expiration test passed")
+
+            # Clean up test keys
+            for key in test_data:
+                cache.delete(f"test_{key}")
+            cache.delete("test_get_or_set")
+
+            if verbosity >= 2:
+                self.stdout.write(self.style.SUCCESS("  ✓ All cache operations tests passed"))
+
+        except Exception as e:
+            raise Exception(f"Cache operations test failed: {str(e)}") from e
+
+    def _test_detailed_operations(self, verbosity):
+        """Run detailed Redis operations tests."""
+        if verbosity >= 2:
+            self.stdout.write("Running detailed operations...")
+
+        try:
+            # Test cache.get_many and set_many
+            test_data = {
+                "bulk_key_1": "value_1",
+                "bulk_key_2": "value_2",
+                "bulk_key_3": "value_3",
+            }
+
+            cache.set_many(test_data, 60)
+            retrieved_data = cache.get_many(test_data.keys())
+
+            for key, expected_value in test_data.items():
+                if retrieved_data.get(key) != expected_value:
+                    raise Exception(f"Bulk operation failed for key {key}")
+
+            if verbosity >= 2:
+                self.stdout.write("  ✓ Bulk operations (set_many/get_many) test passed")
+
+            # Test cache.delete_many
+            cache.delete_many(test_data.keys())
+            remaining_data = cache.get_many(test_data.keys())
+            if any(remaining_data.values()):
+                raise Exception("delete_many operation failed")
+
+            if verbosity >= 2:
+                self.stdout.write("  ✓ Bulk delete (delete_many) test passed")
+
+            # Test cache versioning if supported
+            try:
+                cache.set("version_test", "version_1", 60, version=1)
+                cache.set("version_test", "version_2", 60, version=2)
+
+                v1_value = cache.get("version_test", version=1)
+                v2_value = cache.get("version_test", version=2)
+
+                if v1_value == "version_1" and v2_value == "version_2":
+                    if verbosity >= 2:
+                        self.stdout.write("  ✓ Cache versioning test passed")
+                else:
+                    if verbosity >= 2:
+                        self.stdout.write("  ! Cache versioning not supported or failed")
+
+                cache.delete("version_test", version=1)
+                cache.delete("version_test", version=2)
+
+            except Exception:
+                if verbosity >= 2:
+                    self.stdout.write("  ! Cache versioning not supported")
+
+        except Exception as e:
+            raise Exception(f"Detailed operations test failed: {str(e)}") from e
+
+    def _show_cache_info(self, verbosity):
+        """Show information about the cache configuration."""
+        if verbosity >= 2:
+            self.stdout.write("\nCache Configuration Information:")
+            self.stdout.write("-" * 35)
+
+            # Show cache backend information
+            cache_config = getattr(settings, "CACHES", {}).get("default", {})
+            backend = cache_config.get("BACKEND", "Unknown")
+            location = cache_config.get("LOCATION", "Not specified")
+
+            self.stdout.write(f"Backend: {backend}")
+            self.stdout.write(f"Location: {location}")
+
+            # Show cache options if any
+            options = cache_config.get("OPTIONS", {})
+            if options:
+                self.stdout.write("Options:")
+                for key, value in options.items():
+                    # Don't show sensitive information like passwords
+                    if "password" in key.lower() or "secret" in key.lower():
+                        value = "***hidden***"
+                    self.stdout.write(f"  {key}: {value}")
+
+            # Try to get cache stats if available
+            try:
+                if hasattr(cache, "_cache") and hasattr(cache._cache, "get_stats"):
+                    stats = cache._cache.get_stats()
+                    if stats:
+                        self.stdout.write("\nCache Statistics:")
+                        for stat_key, stat_value in stats.items():
+                            self.stdout.write(f"  {stat_key}: {stat_value}")
+            except Exception:
+                pass  # Stats not available
+
+            # Test if we can determine Redis info
+            try:
+                # Try to access Redis client directly if using django-redis
+                if hasattr(cache, "_cache") and hasattr(cache._cache, "_client"):
+                    client = cache._cache._client
+                    if hasattr(client, "connection_pool"):
+                        pool = client.connection_pool
+                        self.stdout.write("\nConnection Pool Info:")
+                        self.stdout.write(f"  Max connections: {getattr(pool, 'max_connections', 'Unknown')}")
+                        self.stdout.write(f"  Connection class: {getattr(pool, 'connection_class', 'Unknown')}")
+
+                        connection_kwargs = getattr(pool, "connection_kwargs", {})
+                        if connection_kwargs:
+                            self.stdout.write("  Connection parameters:")
+                            for key, value in connection_kwargs.items():
+                                if "password" in key.lower():
+                                    value = "***hidden***"
+                                self.stdout.write(f"    {key}: {value}")
+            except Exception:
+                pass  # Redis-specific info not available

pulumi_django_azure/middleware.py

@@ -1,14 +1,12 @@
 import logging
 import os
+import signal
 
 from django.conf import settings
-from django.core.cache import cache
 from django.db import connection
-from django.db.utils import OperationalError
 from django.http import HttpResponse
-from django_redis import get_redis_connection
 
-from .azure_helper import db_token_will_expire, get_db_password, get_redis_credentials, redis_token_will_expire
+from .azure_helper import get_db_password
 
 logger = logging.getLogger("pulumi_django_azure.health_check")
 
@@ -18,47 +16,40 @@ class HealthCheckMiddleware:
         self.get_response = get_response
 
     def _self_heal(self):
-        # Send HUP signal to gunicorn main thread,
-        # which will trigger new workers to start.
-        os.kill(os.getppid(), 1)
+        logger.warning("Self-healing by gracefully restarting Gunicorn.")
+
+        master_pid = os.getppid()
+
+        logger.debug("Master PID: %d", master_pid)
+
+        # https://docs.gunicorn.org/en/latest/signals.html
+
+        # Reload a new master with new workers,
+        # since the application is preloaded this is the only safe way for now.
+        os.kill(master_pid, signal.SIGUSR2)
+
+        # Gracefully shutdown the current workers
+        os.kill(master_pid, signal.SIGTERM)
 
     def __call__(self, request):
         if request.path == settings.HEALTH_CHECK_PATH:
             # Update the database credentials if needed
             if settings.AZURE_DB_PASSWORD:
                 try:
-                    if db_token_will_expire():
-                        logger.debug("Database token will expire, fetching new credentials")
-                        settings.DATABASES["default"]["PASSWORD"] = get_db_password()
-                    else:
-                        logger.debug("Database token is still valid, skipping credentials update")
-                except Exception as e:
-                    logger.error("Failed to update database credentials: %s", str(e))
-
-                    self._self_heal()
-
-                    return HttpResponse(status=503)
-
-            # Update the Redis credentials if needed
-            if settings.AZURE_REDIS_CREDENTIALS:
-                try:
-                    if redis_token_will_expire():
-                        logger.debug("Redis token will expire, fetching new credentials")
-
-                        redis_credentials = get_redis_credentials()
+                    current_db_password = settings.DATABASES["default"]["PASSWORD"]
+                    new_db_password = get_db_password()
 
-                        # Re-authenticate the Redis connection
-                        redis_connection = get_redis_connection("default")
-                        redis_connection.execute_command("AUTH", redis_credentials.username, redis_credentials.password)
+                    if new_db_password != current_db_password:
+                        logger.debug("Database password has changed, updating credentials")
+                        settings.DATABASES["default"]["PASSWORD"] = new_db_password
 
-                        settings.CACHES["default"]["OPTIONS"]["PASSWORD"] = redis_credentials.password
+                        # Close existing connections to force reconnect with new password
+                        connection.close()
                     else:
-                        logger.debug("Redis token is still valid, skipping credentials update")
+                        logger.debug("Database password unchanged, keeping existing credentials")
                 except Exception as e:
-                    logger.error("Failed to update Redis credentials: %s", str(e))
-
+                    logger.error("Failed to update database credentials: %s", str(e))
                     self._self_heal()
-
                     return HttpResponse(status=503)
 
             try:
@@ -66,17 +57,11 @@ class HealthCheckMiddleware:
                 connection.ensure_connection()
                 logger.debug("Database connection check passed")
 
-                # Test the Redis connection
-                cache.set("health_check", "test")
-                logger.debug("Redis connection check passed")
-
                 return HttpResponse("OK")
 
-            except OperationalError as e:
-                logger.error("Database connection failed: %s", str(e))
-                return HttpResponse(status=503)
             except Exception as e:
                 logger.error("Health check failed with unexpected error: %s", str(e))
+                self._self_heal()
                 return HttpResponse(status=503)
 
         return self.get_response(request)