📄 Source: CachePolicy.php
<?php
/*
* Copyright 2014 Google Inc.
*
* 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
*
* http://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.
*/
namespace Google\Service\Compute;
class CachePolicy extends \Google\Collection
{
/**
* Automatically cache static content, including common image formats, media
* (video and audio), and web assets (JavaScript and CSS). Requests and
* responses that are marked as uncacheable, as well as dynamic content
* (including HTML), will not be cached.
*/
public const CACHE_MODE_CACHE_ALL_STATIC = 'CACHE_ALL_STATIC';
/**
* Cache all content, ignoring any "private", "no-store" or "no-cache"
* directives in Cache-Control response headers. Warning: this may result in
* Cloud CDN caching private, per-user (user identifiable) content.
*/
public const CACHE_MODE_FORCE_CACHE_ALL = 'FORCE_CACHE_ALL';
/**
* Requires the origin to set valid caching headers to cache content.
* Responses without these headers will not be cached at the edge, and will
* require a full trip to the origin on every request, potentially impacting
* performance and increasing load on the origin server.
*/
public const CACHE_MODE_USE_ORIGIN_HEADERS = 'USE_ORIGIN_HEADERS';
protected $collection_key = 'negativeCachingPolicy';
/**
* Bypass the cache when the specified request headers are matched by name,
* e.g. Pragma or Authorization headers. Values are case-insensitive. Up to 5
* header names can be specified. The cache is bypassed for all `cacheMode`
* values.
*
* @var string[]
*/
public $cacheBypassRequestHeaderNames;
protected $cacheKeyPolicyType = CachePolicyCacheKeyPolicy::class;
protected $cacheKeyPolicyDataType = '';
/**
* Specifies the cache setting for all responses from this route. If not
* specified, Cloud CDN uses `CACHE_ALL_STATIC` mode.
*
* @var string
*/
public $cacheMode;
protected $clientTtlType = Duration::class;
protected $clientTtlDataType = '';
protected $defaultTtlType = Duration::class;
protected $defaultTtlDataType = '';
protected $maxTtlType = Duration::class;
protected $maxTtlDataType = '';
/**
* Negative caching allows per-status code TTLs to be set, in order to apply
* fine-grained caching for common errors or redirects. This can reduce the
* load on your origin and improve end-user experience by reducing response
* latency. When the `cacheMode` is set to `CACHE_ALL_STATIC` or
* `USE_ORIGIN_HEADERS`, negative caching applies to responses with the
* specified response code that lack any Cache-Control, Expires, or Pragma:
* no-cache directives. When the `cacheMode` is set to `FORCE_CACHE_ALL`,
* negative caching applies to all responses with the specified response code,
* and overrides any caching headers. By default, Cloud CDN applies the
* following TTLs to these HTTP status codes:
*
* * 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m * 404 (Not
* Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s * 405 (Method
* Not Found), 501 (Not Implemented): 60s
*
* These defaults can be overridden in `negativeCachingPolicy`. If not
* specified, Cloud CDN applies negative caching by default.
*
* @var bool
*/
public $negativeCaching;
protected $negativeCachingPolicyType = CachePolicyNegativeCachingPolicy::class;
protected $negativeCachingPolicyDataType = 'array';
/**
* If true then Cloud CDN will combine multiple concurrent cache fill requests
* into a small number of requests to the origin. If not specified, Cloud CDN
* applies request coalescing by default.
*
* @var bool
*/
public $requestCoalescing;
protected $serveWhileStaleType = Duration::class;
protected $serveWhileStaleDataType = '';
/**
* Bypass the cache when the specified request headers are matched by name,
* e.g. Pragma or Authorization headers. Values are case-insensitive. Up to 5
* header names can be specified. The cache is bypassed for all `cacheMode`
* values.
*
* @param string[] $cacheBypassRequestHeaderNames
*/
public function setCacheBypassRequestHeaderNames($cacheBypassRequestHeaderNames)
{
$this->cacheBypassRequestHeaderNames = $cacheBypassRequestHeaderNames;
}
/**
* @return string[]
*/
public function getCacheBypassRequestHeaderNames()
{
return $this->cacheBypassRequestHeaderNames;
}
/**
* The cache key configuration. If not specified, the default behavior depends
* on the backend type: for Backend Services, the complete request URI is
* used; for Backend Buckets, the request URI is used without the protocol or
* host, and only query parameters known to Cloud Storage are included.
*
* @param CachePolicyCacheKeyPolicy $cacheKeyPolicy
*/
public function setCacheKeyPolicy(CachePolicyCacheKeyPolicy $cacheKeyPolicy)
{
$this->cacheKeyPolicy = $cacheKeyPolicy;
}
/**
* @return CachePolicyCacheKeyPolicy
*/
public function getCacheKeyPolicy()
{
return $this->cacheKeyPolicy;
}
/**
* Specifies the cache setting for all responses from this route. If not
* specified, Cloud CDN uses `CACHE_ALL_STATIC` mode.
*
* Accepted values: CACHE_ALL_STATIC, FORCE_CACHE_ALL, USE_ORIGIN_HEADERS
*
* @param self::CACHE_MODE_* $cacheMode
*/
public function setCacheMode($cacheMode)
{
$this->cacheMode = $cacheMode;
}
/**
* @return self::CACHE_MODE_*
*/
public function getCacheMode()
{
return $this->cacheMode;
}
/**
* Specifies a separate client (e.g. browser client) maximum TTL for cached
* content. This is used to clamp the max-age (or Expires) value sent to the
* client. With `FORCE_CACHE_ALL`, the lesser of `clientTtl` and `defaultTtl`
* is used for the response max-age directive, along with a "public"
* directive. For cacheable content in `CACHE_ALL_STATIC` mode, `clientTtl`
* clamps the max-age from the origin (if specified), or else sets the
* response max-age directive to the lesser of the `clientTtl` and
* `defaultTtl`, and also ensures a "public" cache-control directive is
* present. The maximum allowed value is 31,622,400s (1 year). If not
* specified, Cloud CDN uses 3600s (1 hour) for `CACHE_ALL_STATIC` mode.
* Cannot exceed `maxTtl`. Cannot be specified when `cacheMode` is
* `USE_ORIGIN_HEADERS`.
*
* @param Duration $clientTtl
*/
public function setClientTtl(Duration $clientTtl)
{
$this->clientTtl = $clientTtl;
}
/**
* @return Duration
*/
public function getClientTtl()
{
return $this->clientTtl;
}
/**
* Specifies the default TTL for cached content for responses that do not have
* an existing valid TTL (max-age or s-maxage). Setting a TTL of "0" means
* "always revalidate". The value of `defaultTtl` cannot be set to a value
* greater than that of `maxTtl`. When the `cacheMode` is set to
* `FORCE_CACHE_ALL`, the `defaultTtl` will overwrite the TTL set in all
* responses. The maximum allowed value is 31,622,400s (1 year). Infrequently
* accessed objects may be evicted from the cache before the defined TTL. If
* not specified, Cloud CDN uses 3600s (1 hour) for `CACHE_ALL_STATIC` and
* `FORCE_CACHE_ALL` modes. Cannot be specified when `cacheMode` is
* `USE_ORIGIN_HEADERS`.
*
* @param Duration $defaultTtl
*/
public function setDefaultTtl(Duration $defaultTtl)
{
$this->defaultTtl = $defaultTtl;
}
/**
* @return Duration
*/
public function getDefaultTtl()
{
return $this->defaultTtl;
}
/**
* Specifies the maximum allowed TTL for cached content. Cache directives that
* attempt to set a max-age or s-maxage higher than this, or an Expires header
* more than `maxTtl` seconds in the future will be capped at the value of
* `maxTtl`, as if it were the value of an s-maxage Cache-Control directive.
* Headers sent to the client will not be modified. Setting a TTL of "0" means
* "always revalidate". The maximum allowed value is 31,622,400s (1 year).
* Infrequently accessed objects may be evicted from the cache before the
* defined TTL. If not specified, Cloud CDN uses 86400s (1 day) for
* `CACHE_ALL_STATIC` mode. Can be specified only for `CACHE_ALL_STATIC` cache
* mode.
*
* @param Duration $maxTtl
*/
public function setMaxTtl(Duration $maxTtl)
{
$this->maxTtl = $maxTtl;
}
/**
* @return Duration
*/
public function getMaxTtl()
{
return $this->maxTtl;
}
/**
* Negative caching allows per-status code TTLs to be set, in order to apply
* fine-grained caching for common errors or redirects. This can reduce the
* load on your origin and improve end-user experience by reducing response
* latency. When the `cacheMode` is set to `CACHE_ALL_STATIC` or
* `USE_ORIGIN_HEADERS`, negative caching applies to responses with the
* specified response code that lack any Cache-Control, Expires, or Pragma:
* no-cache directives. When the `cacheMode` is set to `FORCE_CACHE_ALL`,
* negative caching applies to all responses with the specified response code,
* and overrides any caching headers. By default, Cloud CDN applies the
* following TTLs to these HTTP status codes:
*
* * 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m * 404 (Not
* Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s * 405 (Method
* Not Found), 501 (Not Implemented): 60s
*
* These defaults can be overridden in `negativeCachingPolicy`. If not
* specified, Cloud CDN applies negative caching by default.
*
* @param bool $negativeCaching
*/
public function setNegativeCaching($negativeCaching)
{
$this->negativeCaching = $negativeCaching;
}
/**
* @return bool
*/
public function getNegativeCaching()
{
return $this->negativeCaching;
}
/**
* Sets a cache TTL for the specified HTTP status code. `negativeCaching` must
* be enabled to configure `negativeCachingPolicy`. Omitting the policy and
* leaving `negativeCaching` enabled will use Cloud CDN's default cache TTLs.
* Note that when specifying an explicit `negativeCachingPolicy`, you should
* take care to specify a cache TTL for all response codes that you wish to
* cache. Cloud CDN will not apply any default negative caching when a policy
* exists.
*
* @param CachePolicyNegativeCachingPolicy[] $negativeCachingPolicy
*/
public function setNegativeCachingPolicy($negativeCachingPolicy)
{
$this->negativeCachingPolicy = $negativeCachingPolicy;
}
/**
* @return CachePolicyNegativeCachingPolicy[]
*/
public function getNegativeCachingPolicy()
{
return $this->negativeCachingPolicy;
}
/**
* If true then Cloud CDN will combine multiple concurrent cache fill requests
* into a small number of requests to the origin. If not specified, Cloud CDN
* applies request coalescing by default.
*
* @param bool $requestCoalescing
*/
public function setRequestCoalescing($requestCoalescing)
{
$this->requestCoalescing = $requestCoalescing;
}
/**
* @return bool
*/
public function getRequestCoalescing()
{
return $this->requestCoalescing;
}
/**
* Serve existing content from the cache (if available) when revalidating
* content with the origin, or when an error is encountered when refreshing
* the cache. This setting defines the default "max-stale" duration for any
* cached responses that do not specify a max-stale directive. Stale responses
* that exceed the TTL configured here will not be served. The default limit
* (max-stale) is 86400s (1 day), which will allow stale content to be served
* up to this limit beyond the max-age (or s-maxage) of a cached response. The
* maximum allowed value is 604800 (1 week). Set this to zero (0) to disable
* serve-while-stale.
*
* @param Duration $serveWhileStale
*/
public function setServeWhileStale(Duration $serveWhileStale)
{
$this->serveWhileStale = $serveWhileStale;
}
/**
* @return Duration
*/
public function getServeWhileStale()
{
return $this->serveWhileStale;
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(CachePolicy::class, 'Google_Service_Compute_CachePolicy');
← Back