Est-il possible de désactiver la mise en cache depuis les pages d'administration de Django?

Pour la requête principale, vous pouvez utiliser cache-table .

Une alternative est d'utiliser un middleware en comparant l'IP qui reçoit la demande avec votre IP spécifique, que vous pouvez stocker dans vos paramètres. Quelque chose comme ceci:

from django.http import HttpRequest
def get_user_ip(request):
    client_address = request.META['HTTPS_X_FORWARDED_FOR']
    if your_ip == client_address:
        save_user_ip()

Utiliser un site séparé pour le développement est toujours une très bonne chose. Néanmoins, avoir la possibilité de désactiver facilement la mise en cache sur le site de production peut apporter des avantages supplémentaires:

• pour enquêter sur les bogues subtils liés à la mise en cache
• pour mesurer le gain de performance efficace avec des données de production réelles

Je pense que cela peut être résolu avec succès avec une petite quantité de code fournissant un backend de mise en cache personnalisé léger.

En gros:

• Django instancie un objet de cache "par défaut" une fois au démarrage, le traitant comme un singleton et l'utilise pour toujours
• Dans notre backend de cache personnalisé, nous conserverons une instance interne de deux objets séparés (un cache "factice" et un cache "basé sur un fichier") et n'exposerons qu'un seul d'entre eux via les méthodes d'interface requises
• De cette façon, nous agissons en fait comme un proxy de classe pour FileBasedCache ou DummyCache
• Nous pouvons facilement contrôler quel objet est actif avec une variable, changeant ainsi le comportement au moment de l'exécution, sans avoir besoin de redémarrer Django

Le POC suivant a été vérifié dans un petit projet de test avec des résultats positifs.

D'abord, écrivez la classe "proxy" qui se comporte comme FileBasedCache ou DummyCache:

fichier 'project / mycache.py':

pip install django-constance[database]
python manage.py migrate

et référencez-le dans les paramètres du projet comme suit:

INSTALLED_APPS = [
    ...
    'constance',
    'constance.backends.database',
]

CONSTANCE_BACKEND = 'constance.backends.database.DatabaseBackend'
CONSTANCE_CONFIG = {
    'CACHING_ENABLED': (True, 'Set to False to disable caching'),
}

Veuillez noter que les actions réelles sont déléguées à l'un des deux objets internes, en fonction de la valeur actuelle de config.CACHING_ENABLED . Aucune logique de mise en cache n'a été réimplémentée dans le modèle proxy.

Enfin, pour contrôler l'indicateur de commutation de l'administrateur (la partie facile) définissez une valeur booléenne 'CACHING_ENABLED' pour django-constance (une application populaire qui fournit une interface d'administration pour modifier les paramètres dynamiques).

Ajoutez ceci aux paramètres du projet:

CACHES = {
    'default': {
        'BACKEND': 'project.mycache.MyCache',
        'LOCATION': '/var/www/mysite.com/cache,
    }
}

puis:

from django.core.cache.backends.filebased import FileBasedCache
from django.core.cache.backends.dummy import DummyCache
from django.core.cache.backends.base import DEFAULT_TIMEOUT
from constance import config


class MyCache(DummyCache):

    def __init__(self, *args, **kwargs):
        self.dummy_cache = DummyCache(*args, **kwargs)
        self.file_cache = FileBasedCache(*args, **kwargs)

    def _active_cache(self):
        """
        Select either DummyCache or FileBasedCache based on configuration
        """
        return self.file_cache if config.CACHING_ENABLED else self.dummy_cache

    def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None):
        return self._active_cache().add(key, value, timeout, version)

    def get(self, key, default=None, version=None):
        return self._active_cache().get(key, default, version)

    def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None):
        self._active_cache().set(key, value, timeout, version)

    def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None):
        return self._active_cache().touch(key, timeout, version)

    def delete(self, key, version=None):
        self._active_cache().delete(key, version)

    def has_key(self, key, version=None):
        return self._active_cache().has_key(key, version)

    def clear(self):
        self._active_cache().clear()

Vous pouvez utiliser le module django-admin-caching . Tout d'abord, pour l'installer, tapez ceci dans votre terminal bash:

settings.INSTALLED_APPS = [
   #...
   'django_admin_caching',
   #...
]

Une fois installé, vous ajoutez ce morceau de code à votre settings.py afin qu'il soit automatique- s'enregistre:

pip install django-admin-caching

Cela devrait activer la mise en cache sur votre page d'administration django.

Si vous voulez simplement invalider tout le cache à volonté, vous pouvez créer une vue triviale qui fait cela:

fichier views.py:

http://HOST/clear_cache

Ce que j'ai fini par faire:

from django.core.cache import cache

def PageView(request):
    ...
    if request.GET.get('clear') == 'cache':
        if request.user.is_superuser:
            title = request.GET.get('flag') + ' ' + title 
            cache.clear()
    ...
    return render(request, template, context)

Je peux maintenant accéder à https://ozake.com/en/home?clear=cache&flag=sdf

Et le cache sera effacé (si je suis connecté aux pages d'administration).

Deux remarques:

1. Cette adresse sera mise en cache, donc il est nécessaire de changer la chaîne d'indicateur à chaque fois, pour vider le cache.

   li >

2. L'indicateur est ajouté au titre de la page afin que vous puissiez être sûr que vous voyez la version la plus récente.