Пример #1
0
 def key(self, wire, request, *args, **kwargs):
     middleware = self.middleware
     key_get = get_cache_key(
         request, middleware.key_prefix, 'GET', cache=middleware.cache)
     key_head = get_cache_key(
         request, middleware.key_prefix, 'HEAD', cache=middleware.cache)
     return key_get, key_head
Пример #2
0
    def process_request(self, request):
        """
        Check whether the page is already cached and return the cached
        version if available.
        """
        if request.method not in ("GET", "HEAD"):
            request._cache_update_cache = False
            return None  # Don't bother checking the cache.

        # try and get the cached GET response
        cache_key = get_cache_key(request,
                                  self.key_prefix,
                                  "GET",
                                  cache=self.cache)
        if cache_key is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.
        response = self.cache.get(cache_key)
        # if it wasn't found and we are looking for a HEAD, try looking just for that
        if response is None and request.method == "HEAD":
            cache_key = get_cache_key(request,
                                      self.key_prefix,
                                      "HEAD",
                                      cache=self.cache)
            response = self.cache.get(cache_key)

        if response is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.

        # hit, return cached response
        request._cache_update_cache = False
        return response
Пример #3
0
    def process_request(self, request):
        if request.method not in ('GET', 'HEAD') or request.path == '/status':
            request._cache_update_cache = False
            return None

        if request.GET.get('refresh', False):
            request._cache_update_cache = True
            return None

        cache_key = get_cache_key(request,
                                  self.key_prefix,
                                  'GET',
                                  cache=self.cache)
        if cache_key is None:
            request._cache_update_cache = True
            return None

        response = self.cache.get(cache_key)
        if response is None and request.method == 'HEAD':
            cache_key = get_cache_key(request,
                                      self.key_prefix,
                                      'HEAD',
                                      cache=self.cache)
            response = self.cache.get(cache_key)

        if response is None:
            request._cache_update_cache = True
            return None

        request._cache_update_cache = False
        response['Object-Cache'] = 'HIT'
        return response
    def process_request(self, request):
        """
        Checks whether the page is already cached and returns the cached
        version if available.
        """
        if request.method not in ('GET', 'HEAD'):
            request._cache_update_cache = False
            return None  # Don't bother checking the cache.

        # try and get the cached GET response
        cache_key = get_cache_key(request, self.key_prefix, 'GET', cache=self.cache)
        if cache_key is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.
        response = self.cache.get(cache_key, None)
        # if it wasn't found and we are looking for a HEAD, try looking just for that
        if response is None and request.method == 'HEAD':
            cache_key = get_cache_key(request, self.key_prefix, 'HEAD', cache=self.cache)
            response = self.cache.get(cache_key, None)

        if response is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.

        # hit, return cached response
        request._cache_update_cache = False
        return response
Пример #5
0
    def process_request(self, request):
        """
<<<<<<< HEAD
        Checks whether the page is already cached and returns the cached
=======
        Check whether the page is already cached and return the cached
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
        version if available.
        """
        if request.method not in ('GET', 'HEAD'):
            request._cache_update_cache = False
            return None  # Don't bother checking the cache.

        # try and get the cached GET response
        cache_key = get_cache_key(request, self.key_prefix, 'GET', cache=self.cache)
        if cache_key is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.
        response = self.cache.get(cache_key)
        # if it wasn't found and we are looking for a HEAD, try looking just for that
        if response is None and request.method == 'HEAD':
            cache_key = get_cache_key(request, self.key_prefix, 'HEAD', cache=self.cache)
            response = self.cache.get(cache_key)

        if response is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.

        # hit, return cached response
        request._cache_update_cache = False
        return response
Пример #6
0
    def test_generate_cache_header_key(self):
        """
        A test backported from Django stable/1.7.x to show that our patch to
        take the HOST header into account when generating cache middleware
        keys works.
        """
        host = 'www.example.com'
        path = '/cache/test/'
        factory = RequestFactory(HTTP_HOST=host)
        request = factory.get(path)

        response = HttpResponse()
        key_prefix = 'localprefix'
        # Expect None if no headers have been set yet.
        self.assertEqual(get_cache_key(request), None)
        # Set headers to an empty list.
        learn_cache_key(request, response)

        self.assertEqual(
            get_cache_key(request),
            'views.decorators.cache.cache_page.settingsprefix.GET.'
            '18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e'
        )

        # Verify that a specified key_prefix is taken into account.
        learn_cache_key(request, response, key_prefix=key_prefix)
        self.assertEqual(
            get_cache_key(request, key_prefix=key_prefix),
            'views.decorators.cache.cache_page.localprefix.GET.'
            '18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e'
        )
Пример #7
0
    def test_generate_cache_header_key(self):
        """
        A test backported from Django stable/1.7.x to show that our patch to
        take the HOST header into account when generating cache middleware
        keys works.
        """
        host = 'www.example.com'
        path = '/cache/test/'
        factory = RequestFactory(HTTP_HOST=host)
        request = factory.get(path)

        response = HttpResponse()
        key_prefix = 'localprefix'
        # Expect None if no headers have been set yet.
        self.assertEqual(get_cache_key(request), None)
        # Set headers to an empty list.
        learn_cache_key(request, response)

        self.assertEqual(
            get_cache_key(request),
            'views.decorators.cache.cache_page.settingsprefix.GET.'
            '18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e'
        )

        # Verify that a specified key_prefix is taken into account.
        learn_cache_key(request, response, key_prefix=key_prefix)
        self.assertEqual(
            get_cache_key(request, key_prefix=key_prefix),
            'views.decorators.cache.cache_page.localprefix.GET.'
            '18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e'
        )
Пример #8
0
    def process_request(self, request):
        """
        Checks whether the page is already cached and returns the cached
        version if available.
        """
        if not request.method in ('GET', 'HEAD'):
            request._cache_update_cache = False
            return None # Don't bother checking the cache.

        # try and get the cached GET response  GEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEET
        cache_key = get_cache_key(request, self.key_prefix, 'GET', cache=self.cache)
        if cache_key is None:
            request._cache_update_cache = True
            return None # No cache information available, need to rebuild.

        response = self.cache.get(cache_key, None)
        # if it wasn't found and we are looking for a HEAD, try looking just for that HEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD
        if response is None and request.method == 'HEAD':
            cache_key = get_cache_key(request, self.key_prefix, 'HEAD', cache=self.cache)
            response = self.cache.get(cache_key, None)

        if response is None:
            request._cache_update_cache = True
            return None # No cache information available, need to rebuild.

        # hit, return cached response
        request._cache_update_cache = False
        return response
Пример #9
0
    def process_request(self, request):
        """
        Checks whether the page is already cached and returns the cached
        version if available.
        """
        if self.cache_anonymous_only:
            assert hasattr(request, 'user'), "The Django cache middleware with CACHE_MIDDLEWARE_ANONYMOUS_ONLY=True requires authentication middleware to be installed. Edit your MIDDLEWARE_CLASSES setting to insert 'django.contrib.auth.middleware.AuthenticationMiddleware' before the CacheMiddleware."

        if not request.method in ('GET', 'HEAD') or request.GET:
            request._cache_update_cache = False
            return None # Don't bother checking the cache.

        if self.cache_anonymous_only and request.user.is_authenticated():
            request._cache_update_cache = False
            return None # Don't cache requests from authenticated users.

        # try and get the cached GET response
        cache_key = get_cache_key(request, self.key_prefix, 'GET', cache=self.cache)
        if cache_key is None:
            request._cache_update_cache = True
            return None # No cache information available, need to rebuild.
        response = self.cache.get(cache_key, None)
        # if it wasn't found and we are looking for a HEAD, try looking just for that
        if response is None and request.method == 'HEAD':
            cache_key = get_cache_key(request, self.key_prefix, 'HEAD', cache=self.cache)
            response = self.cache.get(cache_key, None)

        if response is None:
            request._cache_update_cache = True
            return None # No cache information available, need to rebuild.

        # hit, return cached response
        request._cache_update_cache = False
        return response
Пример #10
0
    def process_request(self, request):
        """
        Checks whether the page is already cached and returns the cached
        version if available.
        """
        if not request.method in ('GET', 'HEAD'):
            request._cache_update_cache = False
            return None  # Don't bother checking the cache.

        user = request.user
        try:
            profile = user.get_profile()

            if datetime.datetime.now(
            ) - profile.last_modified < datetime.timedelta(
                    seconds=self.cache_timeout):
                request._cache_update_cache = True
                return None
        except:
            pass
        try:
            github_prefix = user.social_auth.get(
                provider='github').extra_data['username']
        except:
            github_prefix = ''
        try:
            bitbucket_prefix = user.social_auth.get(
                provider='bitbucket').extra_data['username']
        except:
            bitbucket_prefix = ''
        custom_prefix = '.'.join((hashlib.md5(github_prefix).hexdigest(),
                                  hashlib.md5(bitbucket_prefix).hexdigest()))

        # try and get the cached GET response
        cache_key = get_cache_key(request,
                                  custom_prefix,
                                  'GET',
                                  cache=self.cache)
        if cache_key is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.
        response = self.cache.get(cache_key, None)
        # if it wasn't found and we are looking for a HEAD, try looking just for that
        if response is None and request.method == 'HEAD':
            cache_key = get_cache_key(request,
                                      custom_prefix,
                                      'HEAD',
                                      cache=self.cache)
            response = self.cache.get(cache_key, None)

        if response is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.

        # hit, return cached response
        request._cache_update_cache = False
        return response
Пример #11
0
 def test_get_cache_key(self):
     request = self._get_request(self.path)
     response = HttpResponse()
     key_prefix = 'localprefix'
     # Expect None if no headers have been set yet.
     self.assertEqual(get_cache_key(request), None)
     # Set headers to an empty list.
     learn_cache_key(request, response)
     self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e')
     # Verify that a specified key_prefix is taken in to account.
     learn_cache_key(request, response, key_prefix=key_prefix)
     self.assertEqual(get_cache_key(request, key_prefix=key_prefix), 'views.decorators.cache.cache_page.localprefix.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e')
Пример #12
0
 def test_get_cache_key(self):
     request = self._get_request(self.path)
     response = HttpResponse()
     key_prefix = 'localprefix'
     # Expect None if no headers have been set yet.
     self.assertEqual(get_cache_key(request), None)
     # Set headers to an empty list.
     learn_cache_key(request, response)
     self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.GET.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e')
     # Verify that a specified key_prefix is taken in to account.
     learn_cache_key(request, response, key_prefix=key_prefix)
     self.assertEqual(get_cache_key(request, key_prefix=key_prefix), 'views.decorators.cache.cache_page.localprefix.GET.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e')
Пример #13
0
    def process_request(self, request: WSGIRequest) -> Optional[HttpResponse]:
        if not wagtailcache_settings.WAGTAIL_CACHE:
            return None

        # Check if request is cacheable
        # Only cache GET and HEAD requests.
        # Don't cache requests that are previews.
        # Don't cache requests that have a logged in user.
        # NOTE: Wagtail manually adds `is_preview` to the request object.
        #       This is not normally part of a request object.
        is_cacheable = (request.method in ("GET", "HEAD")
                        and not getattr(request, "is_preview", False)
                        and not (hasattr(request, "user")
                                 and request.user.is_authenticated))

        # Allow the user to override our caching decision.
        for fn in hooks.get_hooks("is_request_cacheable"):
            result = fn(request, is_cacheable)
            if isinstance(result, bool):
                is_cacheable = result

        if not is_cacheable:
            setattr(request, "_wagtailcache_update", False)
            setattr(request, "_wagtailcache_skip", True)
            return None  # Don't bother checking the cache.

        # Try and get the cached GET response.
        cache_key = get_cache_key(request, None, "GET", cache=self._wagcache)
        if cache_key is None:
            setattr(request, "_wagtailcache_update", True)
            return None  # No cache information available, need to rebuild.

        response = self._wagcache.get(cache_key)

        # If it wasn't found and a HEAD was requested, try looking for that.
        if response is None and request.method == "HEAD":
            cache_key = get_cache_key(request,
                                      None,
                                      "HEAD",
                                      cache=self._wagcache)
            response = self._wagcache.get(cache_key)

        if response is None:
            setattr(request, "_wagtailcache_update", True)
            return None  # No cache information available, need to rebuild.

        # Hit. Return cached response.
        setattr(request, "_wagtailcache_update", False)
        # Add a response header to indicate this was a cache hit.
        _patch_header(response, Status.HIT)
        return response
Пример #14
0
def expire_view_cache(request, view_name, args=[], namespace=None, key_prefix=None, method="GET"):
    """
    This function allows you to invalidate any view-level cache. 
        view_name: view function you wish to invalidate or it's named url pattern
        args: any arguments passed to the view function
        namepace: optioal, if an application namespace is needed
        key prefix: for the @cache_page decorator for the function (if any)
        
        from: http://stackoverflow.com/questions/2268417/expire-a-view-cache-in-django
        added: method to request to get the key generating properly
    """
    # modify a request object
    request.method = method
    if settings.USE_I18N:
        request.LANGUAGE_CODE = settings.LANGUAGE_CODE
    # Loookup the request path:
    if namespace:
        view_name = namespace + ":" + view_name
    request.path = reverse(view_name, args=args)
    # get cache key, expire if the cached item exists:
    key = get_cache_key(request, key_prefix=key_prefix)
    if key:
        if cache.get(key):
            cache.set(key, None, 0)
        return True
    return False
Пример #15
0
def expire_view_cache(view_name, args=[], kwargs={}, namespace=None,\
    key_prefix=None):
    """
    This function allows you to invalidate any view-level cache. 
    
    :param view_name: view function to invalidate or its named url pattern
    
    :keyword args: any arguments passed to the view function
    
    :keyword namepace: if an application namespace is used, pass that
    
    :keyword key_prefix: the @cache_page decorator for the function (if any)
    
    """

    # create a fake request object
    request = HttpRequest()
    # Loookup the request path:
    if namespace:
        view_name = namespace + ":" + view_name
    request.path = reverse(view_name, args=args)
    # get cache key, expire if the cached item exists:
    key = get_cache_key(request, key_prefix=key_prefix)
    if key:
        if cache.get(key):
            cache.set(key, None, 0)
        return True
    return False
Пример #16
0
def index(request):

    if request.method == "POST":
        form = MessageForm(request.POST)

        if form.is_valid():
            logger.debug('Form is valid, message is {}'.format(form.instance))
            save_message(form.instance)

            # basic behavior: invalidate page cache
            key = get_cache_key(request)
            cache.delete(key)

            return HttpResponseRedirect(reverse('message:index', args=tuple()))
        else:
            logger.debug('Form is not valid: {}'.format(form.errors))

            context = create_default_context()
            context.update({'form': form, 'form_error': True})

            return render(request, 'messages/index.html', context)

    else:
        # creation test is faster by already binding form with default values
        default_message = Message(
            user=User.objects.all()[0],
            source="the source",
            destination="the dest",
            content="the content {}".format(random.randint(1, 10)))

        context = create_default_context()
        context.update({'form': MessageForm(instance=default_message), 'form_error': False})

        return render(request, 'messages/index.html', context)
Пример #17
0
def expire_view_cache(view_name,
                      args=[],
                      namespace=None,
                      key_prefix=None,
                      method="GET"):
    """
    This function allows you to invalidate any view-level cache. 
        view_name: view function you wish to invalidate or it's named url pattern
        args: any arguments passed to the view function
        namepace: optioal, if an application namespace is needed
        key prefix: for the @cache_page decorator for the function (if any)

        from: http://stackoverflow.com/questions/2268417/expire-a-view-cache-in-django
        added: method to request to get the key generating properly
    """
    from django.core.urlresolvers import reverse
    from django.http import HttpRequest
    from django.utils.cache import get_cache_key
    from django.core.cache import cache
    # create a fake request object
    request = HttpRequest()
    request.method = method
    # Loookup the request path:
    if namespace:
        view_name = namespace + ":" + view_name
    request.path = reverse(view_name, args=args)
    # get cache key, expire if the cached item exists:
    key = get_cache_key(request, key_prefix=key_prefix)
    if key:
        if cache.get(key):
            cache.set(key, None, 0)
        return True
    return False
Пример #18
0
def expire_view_cache(view_name, args=[], namespace=None, key_prefix=None):
	"""
	This function allows you to invalidate any view-level cache. 
		view_name: view function you wish to invalidate or it's named url pattern
		args: any arguments passed to the view function
		namepace: optioal, if an application namespace is needed
		key prefix: for the @cache_page decorator for the function (if any)
	"""
	# create a fake request object
	request = HttpRequest()
	# Loookup the request path:
	if namespace:
		view_name = namespace + ":" + view_name
	request.path = reverse(view_name, args=args)
	# get cache key, expire if the cached item exists:
	key = get_cache_key(request, key_prefix=key_prefix)
	
	log_to_file('deleting view cache: %s, view: %s' % (key, view_name))
	if key:
		#if cache.get(key):
		#	cache.set(key, None, 0)
		#return True
		if cache.has_key(key):
			cache.delete(key)
			log_to_file('cache deleted %s, view: %s' % (key, view_name))
		return True
	return False
Пример #19
0
 def test_learn_cache_key(self):
     request = self._get_request(self.path, 'HEAD')
     response = HttpResponse()
     response['Vary'] = 'Pony'
     # Make sure that the Vary header is added to the key hash
     learn_cache_key(request, response)
     self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.HEAD.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e')
Пример #20
0
    def process_request(self, request):
        """
        Checks whether the page is already cached and returns the cached
        version if available.
        """
        if self.cache_anonymous_only:
            assert hasattr(
                request, "user"
            ), "The Django cache middleware with CACHE_MIDDLEWARE_ANONYMOUS_ONLY=True requires authentication middleware to be installed. Edit your MIDDLEWARE_CLASSES setting to insert 'django.contrib.auth.middleware.AuthenticationMiddleware' before the CacheMiddleware."

        if not request.method in ("GET", "HEAD") or request.GET:
            request._cache_update_cache = False
            return None  # Don't bother checking the cache.

        if self.cache_anonymous_only and request.user.is_authenticated():
            request._cache_update_cache = False
            return None  # Don't cache requests from authenticated users.

        cache_key = get_cache_key(request, self.key_prefix)
        if cache_key is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.

        response = cache.get(cache_key, None)
        if response is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.

        request._cache_update_cache = False
        return response
Пример #21
0
def expire_view_cache(view_name, args=[], namespace=None, key_prefix=None):
    """
    This function allows you to invalidate any view-level cache. 
        view_name: view function you wish to invalidate or it's named url pattern
        args: any arguments passed to the view function
        namepace: optioal, if an application namespace is needed
        key prefix: for the @cache_page decorator for the function (if any)

    from: http://stackoverflow.com/questions/2268417/expire-a-view-cache-in-django
    """
    from django.core.urlresolvers import reverse
    from django.http import HttpRequest
    from django.utils.cache import get_cache_key
    from django.core.cache import cache
    # create a fake request object
    request = HttpRequest()
    # Loookup the request path:
    if namespace:
        view_name = namespace + ":" + view_name
    request.path = reverse(view_name, args=args)
    # get cache key, expire if the cached item exists:
    key = get_cache_key(request, key_prefix=key_prefix)
    if key:
        if cache.get(key):
            # Delete the cache entry.  
            #
            # Note that there is a possible race condition here, as another 
            # process / thread may have refreshed the cache between
            # the call to cache.get() above, and the cache.set(key, None) 
            # below.  This may lead to unexpected performance problems under 
            # severe load.
            cache.set(key, None, 0)
        return True
    return False
Пример #22
0
def get_view_cache_key(view_name,
                       args=None,
                       namespace=None,
                       key_prefix=None,
                       request=None):
    """
    This function allows you to invalidate any view-level cache.
    view_name: view function you wish to invalidate or it's named url pattern
    args: any arguments passed to the view function
    namespace: optional, if an application namespace is needed
    key prefix: for the @cache_page decorator for the function (if any)
    """
    # create a proxy request object to access cache
    if request:
        req = request
    else:
        req = HttpRequest()
        req.META = {"HTTP_HOST": "127.0.0.1:8000", "SERVER_PORT": 8000}

    if args is None:
        args = []

    # Loookup the req path:
    if namespace:
        view_name = namespace + ":" + view_name
    req.path = reverse(view_name, args=args)

    # get cache key, expire if the cached item exists:
    return get_cache_key(req, key_prefix=key_prefix)
Пример #23
0
def expire_view_cache(view_name,
                      args=[],
                      namespace=None,
                      key_prefix=None,
                      method="GET"):
    """
    This function allows you to invalidate any view-level cache.

    view_name: view function you wish to invalidate or it's named url pattern
    args: any arguments passed to the view function
    namepace: optioal, if an application namespace is needed
    key prefix: for the @cache_page decorator for the function (if any)
    """

    request = HttpRequest()
    request.method = method
    request.META = {'HTTP_HOST': settings.DOMAIN_NAME}

    if namespace:
        view_name = namespace + ":" + view_name
    request.path = reverse(view_name, args=args)

    key = get_cache_key(request,
                        key_prefix=settings.CACHES['default']['KEY_PREFIX'])

    if key:
        if cache.get(key):
            cache.delete(key)
        return True
    return False
Пример #24
0
    def process_request(self, request):
        resp = super(CacheMiddleware, self).process_request(request)

        if resp is None:
            request._cache_middleware_key = get_cache_key(request, self.key_prefix)

        return resp
Пример #25
0
def expire_view_cache(
    view_name,
    args=[],
    namespace=None,
    key_prefix=None,
    method="GET"):
    """
    This function allows you to invalidate any view-level cache.

    view_name: view function you wish to invalidate or it's named url pattern
    args: any arguments passed to the view function
    namepace: optioal, if an application namespace is needed
    key prefix: for the @cache_page decorator for the function (if any)
    """

    request = HttpRequest()
    request.method = method
    request.META = { 'HTTP_HOST': settings.DOMAIN_NAME }

    if namespace:
        view_name = namespace + ":" + view_name
    request.path = reverse(view_name, args=args)

    key = get_cache_key(request, key_prefix=settings.CACHES['default']['KEY_PREFIX'])

    if key:
        if cache.get(key):
            cache.delete(key)
        return True
    return False
Пример #26
0
def expire_view_cache(view_name, args=[], namespace=None, key_prefix=None):
    """
    http://stackoverflow.com/questions/2268417/expire-a-view-cache-in-django

    This function allows you to invalidate any view-level cache. 
        view_name: view function you wish to invalidate or it's named url pattern
        args: any arguments passed to the view function
        namepace: optioal, if an application namespace is needed
        key prefix: for the @cache_page decorator for the function (if any)
    """
    from django.core.urlresolvers import reverse
    from django.http import HttpRequest
    from django.utils.cache import get_cache_key
    from django.core.cache import cache
    # create a fake request object
    request = HttpRequest()
    # Loookup the request path:
    if namespace:
        view_name = namespace + ":" + view_name
    request.path = reverse(view_name, args=args)
    # get cache key, expire if the cached item exists:
    key = get_cache_key(request, key_prefix=key_prefix)
    if key:
        if cache.get(key):
            # Delete the cache entry.
            #
            # Note that there is a possible race condition here, as another
            # process / thread may have refreshed the cache between
            # the call to cache.get() above, and the cache.set(key, None)
            # below.  This may lead to unexpected performance problems under
            # severe load.
            cache.set(key, None, 0)
        return True
    return False
Пример #27
0
def expire_view_cache(view_name, args=[], namespace=None, key_prefix=None, method="GET"):
    """
    This function allows you to invalidate any view-level cache. 
        view_name: view function you wish to invalidate or it's named url pattern
        args: any arguments passed to the view function
        namepace: optioal, if an application namespace is needed
        key prefix: for the @cache_page decorator for the function (if any)

        from: http://stackoverflow.com/questions/2268417/expire-a-view-cache-in-django
        added: method to request to get the key generating properly
    """
    from django.core.urlresolvers import reverse
    from django.http import HttpRequest
    from django.utils.cache import get_cache_key
    from django.core.cache import cache
    # create a fake request object
    request = HttpRequest()
    request.method = method
    # Loookup the request path:
    if namespace:
        view_name = namespace + ":" + view_name
    request.path = reverse(view_name, args=args)
    print request.path
    print request.method
    # get cache key, expire if the cached item exists:
    key = get_cache_key(request, key_prefix=key_prefix)
    print key
    if key:
        if cache.get(key):
            cache.set(key, None, 0)
        return True
    return False

    cache.clear()
Пример #28
0
def expire_page(path):
    'http://www.djangosnippets.org/snippets/936/'
    request = HttpRequest()
    request.path = path
    key = get_cache_key(request)
    if cache.has_key(key):
        cache.delete(key)
Пример #29
0
def expire_page(path):
    request = HttpRequest()
    request.path = path
    key = get_cache_key(request)
    
    if cache.has_key(key):   
        cache.delete(key)
Пример #30
0
def expire_page_cache(viewname, curreq, args=None, key_prefix=None):
    """
    Removes cache created by cache_page functionality.
    Parameters are used as they are in reverse()
    """
    if args is None:
        path = reverse(viewname)
    else:
        path = reverse(viewname, args=args)

    http_host = curreq.META.get("HTTP_HOST", "")
    if len(http_host.split(":")) == 1:
        server_name, server_port = http_host, "80"
    else:
        server_name, server_port = http_host.split(":")

    request = HttpRequest()
    request.META = {'SERVER_NAME': server_name, 'SERVER_PORT': server_port}
    request.META.update(
        dict((header, value) for (header, value) in curreq.META.items()
             if header.startswith('HTTP_')))
    request.path = path
    key = get_cache_key(request, key_prefix=key_prefix)
    if key and cache.get(key):
        cache.set(key, None, 0)
Пример #31
0
    def process_request(self, request):
        "Checks whether the page is already cached and returns the cached version if available."
        if self.cache_anonymous_only:
            assert hasattr(
                request, 'user'
            ), "The Django cache middleware with CACHE_MIDDLEWARE_ANONYMOUS_ONLY=True requires authentication middleware to be installed. Edit your MIDDLEWARE_CLASSES setting to insert 'django.contrib.auth.middleware.AuthenticationMiddleware' before the CacheMiddleware."

        if not request.method in ('GET', 'HEAD') or request.GET:
            request._cache_update_cache = False
            return None  # Don't bother checking the cache.

        if self.cache_anonymous_only and request.user.is_authenticated():
            request._cache_update_cache = False
            return None  # Don't cache requests from authenticated users.

        cache_key = get_cache_key(request, self.key_prefix)
        if cache_key is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.

        response = cache.get(cache_key, None)
        if response is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.

        request._cache_update_cache = False
        return response
Пример #32
0
 def expire_view_cache(view_name, args=[], namespace=None, key_prefix=None):
     """
     This function allows you to invalidate any view-level cache. 
         view_name: view function you wish to invalidate or it's named url pattern
         args: any arguments passed to the view function
         namepace: optioal, if an application namespace is needed
         key prefix: for the @cache_page decorator for the function (if any)
     """
     from django.core.urlresolvers import reverse
     from django.http import HttpRequest
     from django.utils.cache import get_cache_key
     from django.core.cache import cache
     # create a fake request object
     request = HttpRequest()
     # Loookup the request path:
     if namespace:
         view_name = namespace + ":" + view_name
     request.path = view_name#reverse(view_name, args=args)
     # get cache key, expire if the cached item exists:
     key = get_cache_key(request, key_prefix=key_prefix)
     if key:
         if cache.get(key):
             cache.delete(key)
         return True
     return False
Пример #33
0
 def test_learn_cache_key(self):
     request = self._get_request(self.path)
     response = HttpResponse()
     response['Vary'] = 'Pony'
     # Make sure that the Vary header is added to the key hash
     learn_cache_key(request, response)
     self.assertEqual(get_cache_key(request), 'views.decorators.cache.cache_page.settingsprefix.a8c87a3d8c44853d7f79474f7ffe4ad5.d41d8cd98f00b204e9800998ecf8427e')
Пример #34
0
    def process_request(self, request):
        resp = super(CacheMiddleware, self).process_request(request)

        if resp is None:
            request._cache_middleware_key = get_cache_key(
                request, self.key_prefix)

        return resp
Пример #35
0
    def process_request(self, request):
        """
        Checks whether the page is already cached and returns the cached
        version if available.
        """
        if not request.method in ('GET', 'HEAD'):
            request._cache_update_cache = False
            return None # Don't bother checking the cache.
        
        user = request.user
        try:
            profile = user.get_profile()
        
            if datetime.datetime.now() - profile.last_modified < datetime.timedelta(seconds = self.cache_timeout):
                request._cache_update_cache = True
                return None
        except:
            pass
        try:
            github_prefix = user.social_auth.get(provider='github').extra_data['username']
        except:
            github_prefix = ''
        try:
            bitbucket_prefix=user.social_auth.get(provider='bitbucket').extra_data['username']
        except:
            bitbucket_prefix = ''
        custom_prefix = '.'.join((hashlib.md5(github_prefix).hexdigest(),hashlib.md5(bitbucket_prefix).hexdigest()))

        # try and get the cached GET response
        cache_key = get_cache_key(request, custom_prefix, 'GET', cache=self.cache)
        if cache_key is None:
            request._cache_update_cache = True
            return None # No cache information available, need to rebuild.
        response = self.cache.get(cache_key, None)
        # if it wasn't found and we are looking for a HEAD, try looking just for that
        if response is None and request.method == 'HEAD':
            cache_key = get_cache_key(request, custom_prefix, 'HEAD', cache=self.cache)
            response = self.cache.get(cache_key, None)

        if response is None:
            request._cache_update_cache = True
            return None # No cache information available, need to rebuild.

        # hit, return cached response
        request._cache_update_cache = False
        return response
Пример #36
0
    def process_request(self, request: WSGIRequest) -> Optional[HttpResponse]:
        if not wagtailcache_settings.WAGTAIL_CACHE:
            return None

        # Check if request is cacheable
        # Only cache GET and HEAD requests.
        # Don't cache requests that are previews.
        # Don't cache reqeusts that have a logged in user.
        # NOTE: Wagtail manually adds `is_preview` to the request object. This
        #       not normally part of a request object.
        is_cacheable = \
            request.method in ('GET', 'HEAD') and \
            not getattr(request, 'is_preview', False) and \
            not request.user.is_authenticated

        # Allow the user to override our caching decision.
        for fn in hooks.get_hooks('is_request_cacheable'):
            result = fn(request, is_cacheable)
            if isinstance(result, bool):
                is_cacheable = result

        if not is_cacheable:
            setattr(request, "_wagtailcache_update", False)
            setattr(request, "_wagtailcache_skip", True)
            return None  # Don't bother checking the cache.

        # try and get the cached GET response
        cache_key = get_cache_key(request, None, 'GET', cache=self._wagcache)
        if cache_key is None:
            setattr(request, "_wagtailcache_update", True)
            return None  # No cache information available, need to rebuild.
        response = self._wagcache.get(cache_key)
        # if it wasn't found and we are looking for a HEAD, try looking just for that
        if response is None and request.method == 'HEAD':
            cache_key = get_cache_key(request, None, 'HEAD', cache=self._wagcache)
            response = self._wagcache.get(cache_key)

        if response is None:
            setattr(request, "_wagtailcache_update", True)
            return None  # No cache information available, need to rebuild.

        # hit, return cached response
        setattr(request, "_wagtailcache_update", False)
        # Add a response header to indicate this was a cache hit
        _patch_header(response, Status.HIT)
        return response
Пример #37
0
 def warmup_cache(self):
     cache = get_cache(settings.CACHE_MIDDLEWARE_ALIAS)
     cache_header_key = _generate_cache_header_key(settings.CACHE_MIDDLEWARE_KEY_PREFIX, self.request)
     cache.set(cache_header_key, 'header dummy cache', 30)
     cache_key = get_cache_key(self.request,
                               settings.CACHE_MIDDLEWARE_KEY_PREFIX, 'GET',
                               cache=cache)
     cache.set(cache_key, self.RESPONSE_CACHED_VALUE, 30)
Пример #38
0
    def process_request(self, request):
        if not wagtailcache_settings['WAGTAIL_CACHE']:
            return None

        # Check if request is cacheable
        # Only cache GET and HEAD requests.
        # Don't cache requests that are previews.
        # Don't cache reqeusts that have a logged in user.
        request.is_preview = getattr(request, 'is_preview', False)
        is_cacheable = \
            request.method in ('GET', 'HEAD') and \
            not request.is_preview and \
            not request.user.is_authenticated

        # Allow the user to override our caching decision.
        for fn in hooks.get_hooks('is_request_cacheable'):
            result = fn(request, is_cacheable)
            if isinstance(result, bool):
                is_cacheable = result

        if not is_cacheable:
            request._cache_update_cache = False
            return None  # Don't bother checking the cache.

        # try and get the cached GET response
        cache_key = get_cache_key(request, None, 'GET', cache=_wagcache)
        if cache_key is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.
        response = _wagcache.get(cache_key)
        # if it wasn't found and we are looking for a HEAD, try looking just for that
        if response is None and request.method == 'HEAD':
            cache_key = get_cache_key(request, None, 'HEAD', cache=_wagcache)
            response = _wagcache.get(cache_key)

        if response is None:
            request._cache_update_cache = True
            return None  # No cache information available, need to rebuild.

        # hit, return cached response
        request._cache_update_cache = False
        # Add a response header to indicate this was a cache hit
        if wagtailcache_settings['WAGTAIL_CACHE_HEADER']:
            response[wagtailcache_settings['WAGTAIL_CACHE_HEADER']] = 'hit'
        return response
Пример #39
0
def set_cached_data(request, key_prefix, data):
    """Function to save data to the cache based on the request."""

    cache_header_key = _generate_cache_header_key(key_prefix, request)
    if cache.get(cache_header_key) is None:
        cache.set(cache_header_key, [], None)

    cache_key = get_cache_key(request, key_prefix)
    cache.set(cache_key, data)
Пример #40
0
    def test_cache_invalidation_with_no_cache(self):
        """
        test get_cache_key returns None for request with no cache
        """
        url = reverse('dynamic-image', args=('simplified_cell_states_graph', ))
        request = self.factory.get(url)

        cache_key = get_cache_key(request)
        self.assertEquals(cache_key, None)
Пример #41
0
def expire_page(path):
    for scheme in ('http', 'https'):
        for host in settings.EXPIRE_CACHE_HOSTS:
            request = HttpRequest()
            request._get_scheme = lambda: scheme
            request.META['HTTP_HOST'] = host
            request.path = path
            key = get_cache_key(request)
            _djcache.delete(key)
Пример #42
0
 def process_request(self, request):
     id = request.META['REMOTE_ADDR']
     import time
     self.dic.get(id, 0)
     self.first_time = time.time()
     if time.time() - self.dic['time'] > 10:  #如果禁止时间超出了10s 就解除禁止
         self.dic[id] = 0
     uid = request.COOKIES.get('e_token', 's1')
     if uid == 's1':
         key = get_cache_key(request)
         if cache.has_key(key):
             cache.delete(key)
         return
     else:
         key = get_cache_key(request)
         if cache.has_key(key):
             cache.delete(key)
         return
Пример #43
0
def session_constraint_expire(request,session):
    from ajax import session_constraints
    path = reverse(session_constraints, args=[session.meeting.number, session.pk])
    temp_request = HttpRequest()
    temp_request.path = path
    temp_request.META['HTTP_HOST'] = request.META['HTTP_HOST']
    key = get_cache_key(temp_request)
    if key is not None and cache.has_key(key):
        cache.delete(key)
Пример #44
0
def session_constraint_expire(session):
    from django.core.urlresolvers import reverse
    from ajax import session_constraints
    path = reverse(session_constraints, args=[session.meeting.number, session.pk])
    request = HttpRequest()
    request.path = path
    key = get_cache_key(request)
    if key is not None and cache.has_key(key):
        cache.delete(key)
Пример #45
0
def expire_view_cache(request, view_name, args=[], namespace=None, key_prefix=None, method="GET"):
     request.method = method
     request.path = reverse(view_name, args=args)
     key = get_cache_key(request, key_prefix=key_prefix)
     if key:
         if cache.get(key):
             cache.delete(key)
         return True
     return False
Пример #46
0
def set_cached_data(request, key_prefix, data):
    """Function to save data to the cache based on the request."""

    cache_header_key = _generate_cache_header_key(key_prefix, request)
    if cache.get(cache_header_key) is None:
        cache.set(cache_header_key, [], None)

    cache_key = get_cache_key(request, key_prefix)
    cache.set(cache_key, data)
Пример #47
0
def expire_page(path, key_prefix=None):
    '''
    Delete page from cache based on it's url
    '''
    request = HttpRequest()
    request.path = path
    key = get_cache_key(request, key_prefix)
    if cache.has_key(key):
        cache.delete(key)
Пример #48
0
def expire_page(path, key_prefix=None):
    '''
    Delete page from cache based on it's url
    '''
    request = HttpRequest()
    request.path = path    
    key = get_cache_key(request, key_prefix)
    if cache.has_key(key):
        cache.delete(key)
Пример #49
0
 def test_cache_key_i18n(self):
     settings.USE_I18N = True
     request = self._get_request()
     lang = translation.get_language()
     response = HttpResponse()
     key = learn_cache_key(request, response)
     self.assertTrue(key.endswith(lang), "Cache keys should include the language name when i18n is active")
     key2 = get_cache_key(request)
     self.assertEqual(key, key2)
Пример #50
0
 def test_cache_key_i18n(self):
     settings.USE_I18N = True
     request = self._get_request()
     lang = translation.get_language()
     response = HttpResponse()
     key = learn_cache_key(request, response)
     self.assertTrue(key.endswith(lang), "Cache keys should include the language name when i18n is active")
     key2 = get_cache_key(request)
     self.assertEqual(key, key2)
Пример #51
0
def req_fin_call(**kwargs):
    print(kwargs)
    request = kwargs['toppings']
    url = kwargs['url']
    request.path = url
    key = get_cache_key(request)

    if cache.has_key(key):
        cache.delete(key)
    print("request_finished")
Пример #52
0
def expire_page(path):
	request = HttpRequest()
	request.path = path
	key = get_cache_key(request)
	log_to_file('deleting cache: %s, path: %s' % (key, request.path))
	if cache.has_key(key):   
		cache.delete(key)
		log_to_file('cache deleted %s, path: %s' % (key, request.path))
	else:
		log_to_file('no such key %s' % key)
Пример #53
0
def expire_page(path):
    request = HttpRequest()
    request.path = path
    request.META = {
        'SERVER_NAME' : 'play-admin.antropoloops.com',
        'SERVER_PORT' : '8000'
    }
    key = get_cache_key(request)
    if cache.has_key(key):
        cache.delete(key)
Пример #54
0
def expire_page(request, path):
    req = HttpRequest()
    req.META = request.META
    # request.META = {'SERVER_NAME': request_meta.SERVER_NAME, 'SERVER_PORT': request_meta.SERVER_PORT}
    req.LANGUAGE_CODE = 'en-us'
    req.path = path
    key = get_cache_key(req)
    if key in cache:
        print("invalidating cache entry")
        cache.delete(key)
Пример #55
0
def expire_page(path):
    request = HttpRequest()
    request.path = request.get_full_path()
    try:
        key = get_cache_key(request)
        if key in cache:
            cache.delete(key)

    except KeyError:
        pass
Пример #56
0
 def test_update_cache(self):
     cache = get_cache(settings.CACHE_MIDDLEWARE_ALIAS)
     cache.clear()
     request = RequestFactory().get('/')
     cache_header_key = _generate_cache_header_key(settings.CACHE_MIDDLEWARE_KEY_PREFIX, request)
     cache.set(cache_header_key, 'header dummy cache', 30)
     cache_key = get_cache_key(request,
                               settings.CACHE_MIDDLEWARE_KEY_PREFIX, 'GET',
                               cache=cache)
     self.assertEqual(cache.get(cache_key), None, 'Cache is empty')
     update_cache('/')
     self.assertNotEqual(cache.get(cache_key), None, 'Cache is not empty')
Пример #57
0
    def process_request(self, request):
        """
        Checks whether the page is already cached and returns the cached
        version if available.
        Copy from FetchFromCacheMiddleware.process_request().
        """
        # check if the request url need to update or not
        updated = self.cache.get('updated')
        if updated:
            full_path = request.get_full_path()
            if updated.get(full_path, False):
                del updated[full_path]
                self.cache.set('updated', updated)
                return None

        if not request.method in ('GET', 'HEAD'):
            request._cache_update_cache = False
            return None # Don't bother checking the cache.

        # try and get the cached GET response
        cache_key = get_cache_key(request, self.key_prefix, 'GET', cache=self.cache)
        if cache_key is None:
            request._cache_update_cache = True
            return None # No cache information available, need to rebuild.
        response = self.cache.get(cache_key, None)
        # if it wasn't found and we are looking for a HEAD, try looking just for that
        if response is None and request.method == 'HEAD':
            cache_key = get_cache_key(request, self.key_prefix, 'HEAD', cache=self.cache)
            response = self.cache.get(cache_key, None)

        if response is None:
            request._cache_update_cache = True
            return None # No cache information available, need to rebuild.

        # hit, return cached response
        request._cache_update_cache = False
        return response
Пример #58
0
 def handle(self, *args, **options):
     path = options['path']
     factory = RequestFactory()
     request = factory.get(path)
     request.user = AnonymousUser()
     key = get_cache_key(request, key_prefix=None)
     if not key:
         self.stdout.write("Could not find key for " + str(path) + "\n")
         return
     if not cache.get(key):
         self.stdout.write("Could not find key " + str(key) + "\n")
         return
     if key and cache.get(key):
         cache.delete(key)
         self.stdout.write("Deleted cache for key " + str(key) + "\n")
Пример #59
0
def get_cached_data(request, key_prefix, data, serializer):
    """Function to get serialized data from the cache based on the request."""
    cache_header_key = _generate_cache_header_key(key_prefix, request)
    if cache.get(cache_header_key) is None:
        cache.set(cache_header_key, [], None)

    cache_key = get_cache_key(request, key_prefix)
    cached_data = cache.get(cache_key, None)
    cache_used = True
    if not cached_data and data is not None:
        cache_used = False
        cached_data = serializer(data, many=True).data
        cache.set(cache_key, cached_data)

    return cached_data, cache_used
Пример #60
0
def expire_view_cache(path, servername, serverport, key_prefix=None):
    from django.http import HttpRequest
    from django.utils.cache import get_cache_key

    request = HttpRequest()
    request.META = {'SERVER_NAME': servername, 'SERVER_PORT': serverport}
    request.path = path

    key = get_cache_key(request, key_prefix=key_prefix, cache=cache)
    if key:
        logger.info('expire_view_cache:get key:{path}'.format(path=path))
        if cache.get(key):
            cache.delete(key)
        return True
    return False