[Summary view]

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