Merge branch 'filter/local-response-cache/no-cache-directive' into 4.0.x

Author: spencergibb

spring-cloud-gateway-server/src/main/java/org/springframework/cloud/gateway/config/LocalResponseCacheAutoConfiguration.java

@@ -65,7 +65,7 @@ public GlobalLocalResponseCacheGatewayFilter globalLocalResponseCacheGatewayFilt
 			@Qualifier(RESPONSE_CACHE_MANAGER_NAME) CacheManager cacheManager,
 			LocalResponseCacheProperties properties) {
 		return new GlobalLocalResponseCacheGatewayFilter(responseCacheManagerFactory, responseCache(cacheManager),
-				properties.getTimeToLive());
+				properties.getTimeToLive(), properties.getRequest());
 	}
 
 	@Bean(name = RESPONSE_CACHE_MANAGER_NAME)
@@ -78,7 +78,7 @@ public CacheManager gatewayCacheManager(LocalResponseCacheProperties cacheProper
 	public LocalResponseCacheGatewayFilterFactory localResponseCacheGatewayFilterFactory(
 			ResponseCacheManagerFactory responseCacheManagerFactory, LocalResponseCacheProperties properties) {
 		return new LocalResponseCacheGatewayFilterFactory(responseCacheManagerFactory, properties.getTimeToLive(),
-				properties.getSize());
+				properties.getSize(), properties.getRequest());
 	}
 
 	@Bean

spring-cloud-gateway-server/src/main/java/org/springframework/cloud/gateway/filter/factory/cache/GlobalLocalResponseCacheGatewayFilter.java

@@ -40,12 +40,19 @@ public class GlobalLocalResponseCacheGatewayFilter implements GlobalFilter, Orde
 
 	private final ResponseCacheGatewayFilter responseCacheGatewayFilter;
 
+	@Deprecated
 	public GlobalLocalResponseCacheGatewayFilter(ResponseCacheManagerFactory cacheManagerFactory, Cache globalCache,
 			Duration configuredTimeToLive) {
 		responseCacheGatewayFilter = new ResponseCacheGatewayFilter(
 				cacheManagerFactory.create(globalCache, configuredTimeToLive));
 	}
 
+	public GlobalLocalResponseCacheGatewayFilter(ResponseCacheManagerFactory cacheManagerFactory, Cache globalCache,
+			Duration configuredTimeToLive, LocalResponseCacheProperties.RequestOptions requestOptions) {
+		responseCacheGatewayFilter = new ResponseCacheGatewayFilter(
+				cacheManagerFactory.create(globalCache, configuredTimeToLive, requestOptions));
+	}
+
 	@Override
 	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
 		if (exchange.getAttributes().get(LOCAL_RESPONSE_CACHE_FILTER_APPLIED) == null) {

spring-cloud-gateway-server/src/main/java/org/springframework/cloud/gateway/filter/factory/cache/LocalResponseCacheGatewayFilterFactory.java

@@ -24,17 +24,16 @@
 import org.springframework.cloud.gateway.config.LocalResponseCacheAutoConfiguration;
 import org.springframework.cloud.gateway.filter.GatewayFilter;
 import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
+import org.springframework.cloud.gateway.filter.factory.cache.LocalResponseCacheProperties.RequestOptions;
 import org.springframework.cloud.gateway.support.HasRouteId;
 import org.springframework.util.unit.DataSize;
 import org.springframework.validation.annotation.Validated;
 
 /**
  * {@link org.springframework.cloud.gateway.filter.factory.GatewayFilterFactory} of
- * {@link ResponseCacheGatewayFilter}.
- *
- * By default, a global cache (defined as properties in the application) is used. For
- * specific route configuration, parameters can be added following
- * {@link RouteCacheConfiguration} class.
+ * {@link ResponseCacheGatewayFilter}. By default, a global cache (defined as properties
+ * in the application) is used. For specific route configuration, parameters can be added
+ * following {@link RouteCacheConfiguration} class.
  *
  * @author Marta Medio
  * @author Ignacio Lozano
@@ -49,23 +48,27 @@ public class LocalResponseCacheGatewayFilterFactory
 	 */
 	public static final String LOCAL_RESPONSE_CACHE_FILTER_APPLIED = "LocalResponseCacheGatewayFilter-Applied";
 
-	private ResponseCacheManagerFactory cacheManagerFactory;
+	private final ResponseCacheManagerFactory cacheManagerFactory;
+
+	private final Duration defaultTimeToLive;
 
-	private Duration defaultTimeToLive;
+	private final DataSize defaultSize;
 
-	private DataSize defaultSize;
+	private final RequestOptions requestOptions;
 
+	@Deprecated
 	public LocalResponseCacheGatewayFilterFactory(ResponseCacheManagerFactory cacheManagerFactory,
-			Duration defaultTimeToLive) {
-		this(cacheManagerFactory, defaultTimeToLive, null);
+			Duration defaultTimeToLive, DataSize defaultSize) {
+		this(cacheManagerFactory, defaultTimeToLive, defaultSize, new RequestOptions());
 	}
 
 	public LocalResponseCacheGatewayFilterFactory(ResponseCacheManagerFactory cacheManagerFactory,
-			Duration defaultTimeToLive, DataSize defaultSize) {
+			Duration defaultTimeToLive, DataSize defaultSize, RequestOptions requestOptions) {
 		super(RouteCacheConfiguration.class);
 		this.cacheManagerFactory = cacheManagerFactory;
 		this.defaultTimeToLive = defaultTimeToLive;
 		this.defaultSize = defaultSize;
+		this.requestOptions = requestOptions;
 	}
 
 	@Override
@@ -74,7 +77,8 @@ public GatewayFilter apply(RouteCacheConfiguration config) {
 
 		Cache routeCache = LocalResponseCacheAutoConfiguration.createGatewayCacheManager(cacheProperties)
 				.getCache(config.getRouteId() + "-cache");
-		return new ResponseCacheGatewayFilter(cacheManagerFactory.create(routeCache, cacheProperties.getTimeToLive()));
+		return new ResponseCacheGatewayFilter(
+				cacheManagerFactory.create(routeCache, cacheProperties.getTimeToLive(), requestOptions));
 
 	}
 

spring-cloud-gateway-server/src/main/java/org/springframework/cloud/gateway/filter/factory/cache/LocalResponseCacheProperties.java

@@ -40,6 +40,8 @@ public class LocalResponseCacheProperties {
 
 	private Duration timeToLive;
 
+	private RequestOptions request = new RequestOptions();
+
 	public DataSize getSize() {
 		return size;
 	}
@@ -64,9 +66,57 @@ public void setTimeToLive(Duration timeToLive) {
 		this.timeToLive = timeToLive;
 	}
 
+	public RequestOptions getRequest() {
+		return request;
+	}
+
+	public void setRequest(RequestOptions request) {
+		this.request = request;
+	}
+
 	@Override
 	public String toString() {
-		return "LocalResponseCacheProperties{" + "timeToLive=" + getTimeToLive() + '\'' + ", size='" + getSize() + '}';
+		return "LocalResponseCacheProperties{" + "size=" + size + ", timeToLive=" + timeToLive + ", request=" + request
+				+ '}';
+	}
+
+	public static class RequestOptions {
+
+		private NoCacheStrategy noCacheStrategy = NoCacheStrategy.SKIP_UPDATE_CACHE_ENTRY;
+
+		public NoCacheStrategy getNoCacheStrategy() {
+			return noCacheStrategy;
+		}
+
+		public void setNoCacheStrategy(NoCacheStrategy noCacheStrategy) {
+			this.noCacheStrategy = noCacheStrategy;
+		}
+
+		@Override
+		public String toString() {
+			return "RequestOptions{" + "noCacheStrategy=" + noCacheStrategy + '}';
+		}
+
+	}
+
+	/**
+	 * When client sends "no-cache" directive in "Cache-Control" header, the response
+	 * should be re-validated from upstream. There are several strategies that indicates
+	 * what to do with the new fresh response.
+	 */
+	public enum NoCacheStrategy {
+
+		/**
+		 * Update the cache entry by the fresh response coming from upstream with a new
+		 * time to live.
+		 */
+		UPDATE_CACHE_ENTRY,
+		/**
+		 * Skip the update. The client will receive the fresh response, other clients will
+		 * receive the old entry in cache.
+		 */
+		SKIP_UPDATE_CACHE_ENTRY
+
 	}
 
 }

spring-cloud-gateway-server/src/main/java/org/springframework/cloud/gateway/filter/factory/cache/LocalResponseCacheUtils.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2013-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.gateway.filter.factory.cache;
+
+import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.util.StringUtils;
+
+public final class LocalResponseCacheUtils {
+
+	private LocalResponseCacheUtils() {
+	}
+
+	public static boolean isNoCacheRequest(ServerHttpRequest request) {
+		String cacheControl = request.getHeaders().getCacheControl();
+		return StringUtils.hasText(cacheControl) && cacheControl.matches(".*(\s|,|^)no-cache(\\s|,|$).*");
+	}
+
+}

spring-cloud-gateway-server/src/main/java/org/springframework/cloud/gateway/filter/factory/cache/ResponseCacheGatewayFilter.java

@@ -66,7 +66,7 @@ public int getOrder() {
 
 	private Mono<Void> filterWithCache(ServerWebExchange exchange, GatewayFilterChain chain) {
 		final String metadataKey = responseCacheManager.resolveMetadataKey(exchange);
-		Optional<CachedResponse> cached = responseCacheManager.getFromCache(exchange.getRequest(), metadataKey);
+		Optional<CachedResponse> cached = getCachedResponse(exchange, metadataKey);
 
 		if (cached.isPresent()) {
 			return responseCacheManager.processFromCache(exchange, metadataKey, cached.get());
@@ -77,6 +77,22 @@ private Mono<Void> filterWithCache(ServerWebExchange exchange, GatewayFilterChai
 		}
 	}
 
+	private Optional<CachedResponse> getCachedResponse(ServerWebExchange exchange, String metadataKey) {
+		Optional<CachedResponse> cached;
+		if (shouldRevalidate(exchange)) {
+			cached = Optional.empty();
+		}
+		else {
+			cached = responseCacheManager.getFromCache(exchange.getRequest(), metadataKey);
+		}
+
+		return cached;
+	}
+
+	private boolean shouldRevalidate(ServerWebExchange exchange) {
+		return LocalResponseCacheUtils.isNoCacheRequest(exchange.getRequest());
+	}
+
 	private class CachingResponseDecorator extends ServerHttpResponseDecorator {
 
 		private final String metadataKey;
@@ -94,7 +110,8 @@ public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
 			final ServerHttpResponse response = exchange.getResponse();
 
 			Flux<DataBuffer> decoratedBody;
-			if (responseCacheManager.isResponseCacheable(response)) {
+			if (responseCacheManager.isResponseCacheable(response)
+					&& !responseCacheManager.isNoCacheRequestWithoutUpdate(exchange.getRequest())) {
 				decoratedBody = responseCacheManager.processFromUpstream(metadataKey, exchange, Flux.from(body));
 			}
 			else {

spring-cloud-gateway-server/src/main/java/org/springframework/cloud/gateway/filter/factory/cache/ResponseCacheManager.java

@@ -30,8 +30,11 @@
 import reactor.core.publisher.Mono;
 
 import org.springframework.cache.Cache;
+import org.springframework.cloud.gateway.filter.factory.cache.LocalResponseCacheProperties.NoCacheStrategy;
+import org.springframework.cloud.gateway.filter.factory.cache.LocalResponseCacheProperties.RequestOptions;
 import org.springframework.cloud.gateway.filter.factory.cache.keygenerator.CacheKeyGenerator;
 import org.springframework.cloud.gateway.filter.factory.cache.postprocessor.AfterCacheExchangeMutator;
+import org.springframework.cloud.gateway.filter.factory.cache.postprocessor.SetCacheDirectivesByMaxAgeAfterCacheExchangeMutator;
 import org.springframework.cloud.gateway.filter.factory.cache.postprocessor.SetMaxAgeHeaderAfterCacheExchangeMutator;
 import org.springframework.cloud.gateway.filter.factory.cache.postprocessor.SetResponseHeadersAfterCacheExchangeMutator;
 import org.springframework.cloud.gateway.filter.factory.cache.postprocessor.SetStatusCodeAfterCacheExchangeMutator;
@@ -63,12 +66,28 @@ public class ResponseCacheManager {
 
 	private final Cache cache;
 
+	private final boolean ignoreNoCacheUpdate;
+
+	@Deprecated
 	public ResponseCacheManager(CacheKeyGenerator cacheKeyGenerator, Cache cache, Duration configuredTimeToLive) {
+		this(cacheKeyGenerator, cache, configuredTimeToLive, new RequestOptions());
+	}
+
+	public ResponseCacheManager(CacheKeyGenerator cacheKeyGenerator, Cache cache, Duration configuredTimeToLive,
+			RequestOptions requestOptions) {
 		this.cacheKeyGenerator = cacheKeyGenerator;
 		this.cache = cache;
+		this.ignoreNoCacheUpdate = isSkipNoCacheUpdateActive(requestOptions);
 		this.afterCacheExchangeMutators = List.of(new SetResponseHeadersAfterCacheExchangeMutator(),
 				new SetStatusCodeAfterCacheExchangeMutator(),
-				new SetMaxAgeHeaderAfterCacheExchangeMutator(configuredTimeToLive, Clock.systemDefaultZone()));
+				new SetMaxAgeHeaderAfterCacheExchangeMutator(configuredTimeToLive, Clock.systemDefaultZone(),
+						ignoreNoCacheUpdate),
+				new SetCacheDirectivesByMaxAgeAfterCacheExchangeMutator());
+	}
+
+	private static boolean isSkipNoCacheUpdateActive(RequestOptions requestOptions) {
+		return requestOptions != null
+				&& requestOptions.getNoCacheStrategy().equals(NoCacheStrategy.SKIP_UPDATE_CACHE_ENTRY);
 	}
 
 	private static final List<HttpStatusCode> statusesToCache = Arrays.asList(HttpStatus.OK, HttpStatus.PARTIAL_CONTENT,
@@ -132,13 +151,8 @@ Mono<Void> processFromCache(ServerWebExchange exchange, String metadataKey, Cach
 		afterCacheExchangeMutators.forEach(processor -> processor.accept(exchange, cachedResponse));
 		saveMetadataInCache(metadataKey, new CachedResponseMetadata(cachedResponse.headers().getVary()));
 
-		if (HttpStatus.NOT_MODIFIED.equals(response.getStatusCode())) {
-			return response.writeWith(Mono.empty());
-		}
-		else {
-			return response.writeWith(
-					Flux.fromIterable(cachedResponse.body()).map(data -> response.bufferFactory().wrap(data)));
-		}
+		return response
+				.writeWith(Flux.fromIterable(cachedResponse.body()).map(data -> response.bufferFactory().wrap(data)));
 	}
 
 	private CachedResponseMetadata retrieveMetadata(String metadataKey) {
@@ -157,6 +171,10 @@ boolean isResponseCacheable(ServerHttpResponse response) {
 		return isStatusCodeToCache(response) && isCacheControlAllowed(response) && !isVaryWildcard(response);
 	}
 
+	boolean isNoCacheRequestWithoutUpdate(ServerHttpRequest request) {
+		return LocalResponseCacheUtils.isNoCacheRequest(request) && ignoreNoCacheUpdate;
+	}
+
 	private boolean isStatusCodeToCache(ServerHttpResponse response) {
 		return statusesToCache.contains(response.getStatusCode());
 	}

spring-cloud-gateway-server/src/main/java/org/springframework/cloud/gateway/filter/factory/cache/ResponseCacheManagerFactory.java

@@ -33,8 +33,14 @@ public ResponseCacheManagerFactory(CacheKeyGenerator cacheKeyGenerator) {
 		this.cacheKeyGenerator = cacheKeyGenerator;
 	}
 
+	@Deprecated
 	public ResponseCacheManager create(Cache cache, Duration timeToLive) {
 		return new ResponseCacheManager(cacheKeyGenerator, cache, timeToLive);
 	}
 
+	public ResponseCacheManager create(Cache cache, Duration timeToLive,
+			LocalResponseCacheProperties.RequestOptions requestOptions) {
+		return new ResponseCacheManager(cacheKeyGenerator, cache, timeToLive, requestOptions);
+	}
+
 }