def _patch_header(response: HttpResponse, status: Status) -> None: # Patch cache-control with no-cache if it is not already set. if status == Status.SKIP and not response.get("Cache-Control", None): response["Cache-Control"] = CacheControl.NOCACHE.value # Add our custom header. if wagtailcache_settings.WAGTAIL_CACHE_HEADER: response[wagtailcache_settings.WAGTAIL_CACHE_HEADER] = status.value
def to_djangoresponse(self): """django用のレスポンス. """ content_type = self.__headers.get('content-type', 'text/plain') self.set_header('content-length', str(len(self.__body))) django_response = DjangoHttpResponse(self.__body, content_type=content_type, status=self.status) for k, v in self.__headers.items(): django_response[k] = v if self.status == 301: django_response = HttpResponsePermanentRedirect(django_response.get('location')) elif self.status == 302: django_response = HttpResponseRedirect(django_response.get('location')) for k, arr in self.__cookies.items(): v, expires, domain = arr django_response.set_cookie(k, v, expires=expires, domain=domain) return django_response
def wrapper(_self, request, **kwargs): redis_client = get_redis() content, content_type = redis_client.hmget(key, 'content', 'content_type') if content: http_response = HttpResponse(content=content, content_type=content_type) return http_response # 调用原函数 response = func(_self, request, **kwargs) # FIXME response.data http_response = HttpResponse(render.render(response.data), content_type=render.media_type) mapping = { 'content': http_response.content, 'content_type': http_response.get('Content-Type'), } redis_client.hmset(key, mapping) # 返回 return http_response
def process_response(self, request: WSGIRequest, response: HttpResponse) -> HttpResponse: if not wagtailcache_settings.WAGTAIL_CACHE: return response if getattr(request, "_wagtailcache_skip", False): # If we should skip this response, add header and return. _patch_header(response, Status.SKIP) return response if not getattr(request, "_wagtailcache_update", False): # We don't need to update the cache, just return. return response # Check if the response is cacheable # Don't cache private or no-cache responses. # Do cache 200, 301, 302, 304, and 404 codes so that wagtail doesn't # have to repeatedly look up these URLs in the database. # Don't cache streaming responses. is_cacheable = (CacheControl.NOCACHE.value not in response.get( "Cache-Control", "") and CacheControl.PRIVATE.value not in response.get( "Cache-Control", "") and response.status_code in (200, 301, 302, 304, 404) and not response.streaming) # Don't cache 200 responses that set a user-specific cookie in response # to a cookie-less request (e.g. CSRF tokens). if is_cacheable and response.status_code == 200: is_cacheable = not (not request.COOKIES and response.cookies and has_vary_header(response, "Cookie")) # Allow the user to override our caching decision. for fn in hooks.get_hooks("is_response_cacheable"): result = fn(response, is_cacheable) if isinstance(result, bool): is_cacheable = result # If we are not allowed to cache the response, just return. if not is_cacheable: # Add response header to indicate this was intentionally not cached. _patch_header(response, Status.SKIP) return response # Try to get the timeout from the ``max-age`` section of the # ``Cache-Control`` header before reverting to using the cache's # default. timeout = get_max_age(response) if timeout is None: timeout = self._wagcache.default_timeout patch_response_headers(response, timeout) if timeout: cache_key = learn_cache_key(request, response, timeout, None, cache=self._wagcache) if isinstance(response, SimpleTemplateResponse): response.add_post_render_callback( lambda r: self._wagcache.set(cache_key, r, timeout)) else: self._wagcache.set(cache_key, response, timeout) # Add a response header to indicate this was a cache miss. _patch_header(response, Status.MISS) return response