CacheEntry::isStale() - Code Metrics - Inspection of "cache now respects vary headers" - Kevinrob/guzzle-cache-middleware - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#75)

unknown

created 2017-02-02 14:11 UTC

CacheEntry::isStale() A

↳ Parent: CacheEntry

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php

namespace Kevinrob\GuzzleCache;

use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

class CacheEntry
{
    /**
     * @var RequestInterface
     */
    protected $request;

    /**
     * @var ResponseInterface
     */
    protected $response;

    /**
     * This field is only used for serialize.
     * Response::body is a stream and can't be serialized.
     *
     * @var string
     */
    protected $responseBody;

    /**
     * @var \DateTime
     */
    protected $staleAt;

    /**
     * @var \DateTime
     */
    protected $staleIfErrorTo;

    /**
     * @var \DateTime
     */
    protected $staleWhileRevalidateTo;

    /**
     * @var \DateTime
     */
    protected $dateCreated;

    /**
     * Cached timestamp of staleAt variable.
     *
     * @var int
     */
    protected $timestampStale;

    /**
     * @param RequestInterface $request
     * @param ResponseInterface $response
     * @param \DateTime $staleAt
     * @param \DateTime|null $staleIfErrorTo if null, detected with the headers (RFC 5861)
     * @param \DateTime|null $staleWhileRevalidateTo
     */
    public function __construct(
        RequestInterface $request,
        ResponseInterface $response,
        \DateTime $staleAt,
        \DateTime $staleIfErrorTo = null,
        \DateTime $staleWhileRevalidateTo = null
    ) {
        $this->dateCreated = new \DateTime();

        $this->request = $request;
        $this->response = $response;
        $this->staleAt = $staleAt;

        $values = new KeyValueHttpHeader($response->getHeader('Cache-Control'));

        if ($staleIfErrorTo === null && $values->has('stale-if-error')) {
            $this->staleIfErrorTo = (new \DateTime(
                '@'.($this->staleAt->getTimestamp() + (int) $values->get('stale-if-error'))
            ));
        } else {
            $this->staleIfErrorTo = $staleIfErrorTo;
        }

        if ($staleWhileRevalidateTo === null && $values->has('stale-while-revalidate')) {
            $this->staleWhileRevalidateTo = new \DateTime(
                '@'.($this->staleAt->getTimestamp() + (int) $values->get('stale-while-revalidate'))
            );
        } else {
            $this->staleWhileRevalidateTo = $staleWhileRevalidateTo;
        }
    }

    /**
     * @return ResponseInterface
     */
    public function getResponse()
    {
        return $this->response
            ->withHeader('Age', $this->getAge());
    }

    /**
     * @return ResponseInterface
     */
    public function getOriginalResponse()
    {
        return $this->response;
    }

    /**
     * @return RequestInterface
     */
    public function getOriginalRequest()
    {
        return $this->request;
    }

    /**
     * @param RequestInterface $request
     * @return bool
     */
    public function isVaryEquals(RequestInterface $request)
    {
        if ($this->response->hasHeader('Vary')) {
            if ($this->request === null) {
                return false;
            }

            foreach ($this->getVaryHeaders() as $key => $value) {
                if (!$this->request->hasHeader($key)
                    && !$request->hasHeader($key)
                ) {
                    // Absent from both
                    continue;
                } elseif ($this->request->getHeaderLine($key)
                    == $request->getHeaderLine($key)
                ) {
                    // Same content
                    continue;
                }

                return false;
            }
        }

        return true;
    }

    /**
     * Get the vary headers that should be honoured by the cache.
     *
     * @return KeyValueHttpHeader
     */
    public function getVaryHeaders()
    {
        return new KeyValueHttpHeader($this->response->getHeader('Vary'));
    }

    /**
     * @return \DateTime
     */
    public function getStaleAt()
    {
        return $this->staleAt;
    }

    /**
     * @return bool
     */
    public function isFresh()
    {
        return !$this->isStale();
    }

    /**
     * @return bool
     */
    public function isStale()
    {
        return $this->getStaleAge() > 0;
    }

    /**
     * @return int positive value equal staled
     */
    public function getStaleAge()
    {
        // This object is immutable
        if ($this->timestampStale === null) {
            $this->timestampStale = $this->staleAt->getTimestamp();
        }

        return time() - $this->timestampStale;
    }

    /**
     * @return bool
     */
    public function serveStaleIfError()
    {
        return $this->staleIfErrorTo !== null
            && $this->staleIfErrorTo->getTimestamp() >= (new \DateTime())->getTimestamp();
    }

    /**
     * @return bool
     */
    public function staleWhileValidate()
    {
        return $this->staleWhileRevalidateTo !== null
            && $this->staleWhileRevalidateTo->getTimestamp() >= (new \DateTime())->getTimestamp();
    }

    /**
     * @return bool
     */
    public function hasValidationInformation()
    {
        return $this->response->hasHeader('Etag') || $this->response->hasHeader('Last-Modified');
    }

    /**
     * @return int TTL in seconds (0 = infinite)
     */
    public function getTTL()
    {
        if ($this->hasValidationInformation()) {
            // No TTL if we have a way to re-validate the cache
            return 0;
        }

        if ($this->staleIfErrorTo !== null) {
            // Keep it when stale if error
            $ttl = $this->staleIfErrorTo->getTimestamp() - time();
        } else {
            // Keep it until it become stale
            $ttl = $this->staleAt->getTimestamp() - time();
        }

        // Don't return 0, it's reserved for infinite TTL
        return $ttl !== 0 ? (int) $ttl : -1;
    }

    /**
     * @return int Age in seconds
     */
    public function getAge()
    {
        return time() - $this->dateCreated->getTimestamp();
    }

    public function __sleep()
    {
        // Stream/Resource can't be serialized... So we copy the content
        if ($this->response !== null) {
            $this->responseBody = (string) $this->response->getBody();
            $this->response->getBody()->rewind();
        }

        return array_keys(get_object_vars($this));
    }

    public function __wakeup()
    {
        // We re-create the stream of the response
        if ($this->response !== null) {
            $this->response = $this->response
                ->withBody(
                    \GuzzleHttp\Psr7\stream_for($this->responseBody)
                );
        }
    }
}


1			<?php
2
3			namespace Kevinrob\GuzzleCache;
4
5			use Psr\Http\Message\RequestInterface;
6			use Psr\Http\Message\ResponseInterface;
7
8			class CacheEntry
9			{
10			/**
11			* @var RequestInterface
12			*/
13			protected $request;
14
15			/**
16			* @var ResponseInterface
17			*/
18			protected $response;
19
20			/**
21			* This field is only used for serialize.
22			* Response::body is a stream and can't be serialized.
23			*
24			* @var string
25			*/
26			protected $responseBody;
27
28			/**
29			* @var \DateTime
30			*/
31			protected $staleAt;
32
33			/**
34			* @var \DateTime
35			*/
36			protected $staleIfErrorTo;
37
38			/**
39			* @var \DateTime
40			*/
41			protected $staleWhileRevalidateTo;
42
43			/**
44			* @var \DateTime
45			*/
46			protected $dateCreated;
47
48			/**
49			* Cached timestamp of staleAt variable.
50			*
51			* @var int
52			*/
53			protected $timestampStale;
54
55			/**
56			* @param RequestInterface $request
57			* @param ResponseInterface $response
58			* @param \DateTime $staleAt
59			* @param \DateTime\|null $staleIfErrorTo if null, detected with the headers (RFC 5861)
60			* @param \DateTime\|null $staleWhileRevalidateTo
61			*/
62			public function __construct(
63			RequestInterface $request,
64			ResponseInterface $response,
65			\DateTime $staleAt,
66			\DateTime $staleIfErrorTo = null,
67			\DateTime $staleWhileRevalidateTo = null
68			) {
69			$this->dateCreated = new \DateTime();
70
71			$this->request = $request;
72			$this->response = $response;
73			$this->staleAt = $staleAt;
74
75			$values = new KeyValueHttpHeader($response->getHeader('Cache-Control'));
76
77			if ($staleIfErrorTo === null && $values->has('stale-if-error')) {
78			$this->staleIfErrorTo = (new \DateTime(
79			'@'.($this->staleAt->getTimestamp() + (int) $values->get('stale-if-error'))
80			));
81			} else {
82			$this->staleIfErrorTo = $staleIfErrorTo;
83			}
84
85			if ($staleWhileRevalidateTo === null && $values->has('stale-while-revalidate')) {
86			$this->staleWhileRevalidateTo = new \DateTime(
87			'@'.($this->staleAt->getTimestamp() + (int) $values->get('stale-while-revalidate'))
88			);
89			} else {
90			$this->staleWhileRevalidateTo = $staleWhileRevalidateTo;
91			}
92			}
93
94			/**
95			* @return ResponseInterface
96			*/
97			public function getResponse()
98			{
99			return $this->response
100			->withHeader('Age', $this->getAge());
101			}
102
103			/**
104			* @return ResponseInterface
105			*/
106			public function getOriginalResponse()
107			{
108			return $this->response;
109			}
110
111			/**
112			* @return RequestInterface
113			*/
114			public function getOriginalRequest()
115			{
116			return $this->request;
117			}
118
119			/**
120			* @param RequestInterface $request
121			* @return bool
122			*/
123			public function isVaryEquals(RequestInterface $request)
124			{
125			if ($this->response->hasHeader('Vary')) {
126			if ($this->request === null) {
127			return false;
128			}
129
130			foreach ($this->getVaryHeaders() as $key => $value) {
131			if (!$this->request->hasHeader($key)
132			&& !$request->hasHeader($key)
133			) {
134			// Absent from both
135			continue;
136			} elseif ($this->request->getHeaderLine($key)
137			== $request->getHeaderLine($key)
138			) {
139			// Same content
140			continue;
141			}
142
143			return false;
144			}
145			}
146
147			return true;
148			}
149
150			/**
151			* Get the vary headers that should be honoured by the cache.
152			*
153			* @return KeyValueHttpHeader
154			*/
155			public function getVaryHeaders()
156			{
157			return new KeyValueHttpHeader($this->response->getHeader('Vary'));
158			}
159
160			/**
161			* @return \DateTime
162			*/
163			public function getStaleAt()
164			{
165			return $this->staleAt;
166			}
167
168			/**
169			* @return bool
170			*/
171			public function isFresh()
172			{
173			return !$this->isStale();
174			}
175
176			/**
177			* @return bool
178			*/
179			public function isStale()
180			{
181			return $this->getStaleAge() > 0;
182			}
183
184			/**
185			* @return int positive value equal staled
186			*/
187			public function getStaleAge()
188			{
189			// This object is immutable
190			if ($this->timestampStale === null) {
191			$this->timestampStale = $this->staleAt->getTimestamp();
192			}
193
194			return time() - $this->timestampStale;
195			}
196
197			/**
198			* @return bool
199			*/
200			public function serveStaleIfError()
201			{
202			return $this->staleIfErrorTo !== null
203			&& $this->staleIfErrorTo->getTimestamp() >= (new \DateTime())->getTimestamp();
204			}
205
206			/**
207			* @return bool
208			*/
209			public function staleWhileValidate()
210			{
211			return $this->staleWhileRevalidateTo !== null
212			&& $this->staleWhileRevalidateTo->getTimestamp() >= (new \DateTime())->getTimestamp();
213			}
214
215			/**
216			* @return bool
217			*/
218			public function hasValidationInformation()
219			{
220			return $this->response->hasHeader('Etag') \|\| $this->response->hasHeader('Last-Modified');
221			}
222
223			/**
224			* @return int TTL in seconds (0 = infinite)
225			*/
226			public function getTTL()
227			{
228			if ($this->hasValidationInformation()) {
229			// No TTL if we have a way to re-validate the cache
230			return 0;
231			}
232
233			if ($this->staleIfErrorTo !== null) {
234			// Keep it when stale if error
235			$ttl = $this->staleIfErrorTo->getTimestamp() - time();
236			} else {
237			// Keep it until it become stale
238			$ttl = $this->staleAt->getTimestamp() - time();
239			}
240
241			// Don't return 0, it's reserved for infinite TTL
242			return $ttl !== 0 ? (int) $ttl : -1;
243			}
244
245			/**
246			* @return int Age in seconds
247			*/
248			public function getAge()
249			{
250			return time() - $this->dateCreated->getTimestamp();
251			}
252
253			public function __sleep()
254			{
255			// Stream/Resource can't be serialized... So we copy the content
256			if ($this->response !== null) {
257			$this->responseBody = (string) $this->response->getBody();
258			$this->response->getBody()->rewind();
259			}
260
261			return array_keys(get_object_vars($this));
262			}
263
264			public function __wakeup()
265			{
266			// We re-create the stream of the response
267			if ($this->response !== null) {
268			$this->response = $this->response
269			->withBody(
270			\GuzzleHttp\Psr7\stream_for($this->responseBody)
271			);
272			}
273			}
274			}
275

Kevinrob / guzzle-cache-middleware

Pull Request — master (#75)

CacheEntry::isStale() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like