hdabo_sf: comparison vendor/symfony/src/Symfony/Component/HttpKernel/HttpCache/Store.php

equal deleted inserted replaced

--1:000000000000
+:7f95f8617b0b
+<?php
+/*
+* This file is part of the Symfony package.
+*
+* (c) Fabien Potencier <fabien@symfony.com>
+*
+* This code is partially based on the Rack-Cache library by Ryan Tomayko,
+* which is released under the MIT license.
+*
+* For the full copyright and license information, please view the LICENSE
+* file that was distributed with this source code.
+*/
+namespace Symfony\Component\HttpKernel\HttpCache;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\HeaderBag;
+/**
+* Store implements all the logic for storing cache metadata (Request and Response headers).
+*
+* @author Fabien Potencier <fabien@symfony.com>
+*/
+class Store implements StoreInterface
+{
+private $root;
+private $keyCache;
+private $locks;
+/**
+* Constructor.
+*
+* @param string $root The path to the cache directory
+*/
+public function __construct($root)
+{
+$this->root = $root;
+if (!is_dir($this->root)) {
+mkdir($this->root, 0777, true);
+}
+$this->keyCache = new \SplObjectStorage();
+$this->locks = array();
+}
+/**
+* Cleanups storage.
+*/
+public function cleanup()
+{
+// unlock everything
+foreach ($this->locks as $lock) {
+@unlink($lock);
+}
+$error = error_get_last();
+if (1 === $error['type'] && false === headers_sent()) {
+// send a 503
+header('HTTP/1.0 503 Service Unavailable');
+header('Retry-After: 10');
+echo '503 Service Unavailable';
+}
+}
+/**
+* Locks the cache for a given Request.
+*
+* @param Request $request A Request instance
+*
+* @return Boolean|string true if the lock is acquired, the path to the current lock otherwise
+*/
+public function lock(Request $request)
+{
+if (false !== $lock = @fopen($path = $this->getPath($this->getCacheKey($request).'.lck'), 'x')) {
+fclose($lock);
+$this->locks[] = $path;
+return true;
+}
+return $path;
+}
+/**
+* Releases the lock for the given Request.
+*
+* @param Request $request A Request instance
+*/
+public function unlock(Request $request)
+{
+return @unlink($this->getPath($this->getCacheKey($request).'.lck'));
+}
+/**
+* Locates a cached Response for the Request provided.
+*
+* @param Request $request A Request instance
+*
+* @return Response|null A Response instance, or null if no cache entry was found
+*/
+public function lookup(Request $request)
+{
+$key = $this->getCacheKey($request);
+if (!$entries = $this->getMetadata($key)) {
+return null;
+}
+// find a cached entry that matches the request.
+$match = null;
+foreach ($entries as $entry) {
+if ($this->requestsMatch(isset($entry[1]['vary']) ? $entry[1]['vary'][0] : '', $request->headers->all(), $entry[0])) {
+$match = $entry;
+break;
+}
+}
+if (null === $match) {
+return null;
+}
+list($req, $headers) = $match;
+if (file_exists($body = $this->getPath($headers['x-content-digest'][0]))) {
+return $this->restoreResponse($headers, $body);
+}
+// TODO the metaStore referenced an entity that doesn't exist in
+// the entityStore. We definitely want to return nil but we should
+// also purge the entry from the meta-store when this is detected.
+return null;
+}
+/**
+* Writes a cache entry to the store for the given Request and Response.
+*
+* Existing entries are read and any that match the response are removed. This
+* method calls write with the new list of cache entries.
+*
+* @param Request  $request  A Request instance
+* @param Response $response A Response instance
+*
+* @return string The key under which the response is stored
+*/
+public function write(Request $request, Response $response)
+{
+$key = $this->getCacheKey($request);
+$storedEnv = $this->persistRequest($request);
+// write the response body to the entity store if this is the original response
+if (!$response->headers->has('X-Content-Digest')) {
+$digest = 'en'.sha1($response->getContent());
+if (false === $this->save($digest, $response->getContent())) {
+throw new \RuntimeException('Unable to store the entity.');
+}
+$response->headers->set('X-Content-Digest', $digest);
+if (!$response->headers->has('Transfer-Encoding')) {
+$response->headers->set('Content-Length', strlen($response->getContent()));
+}
+}
+// read existing cache entries, remove non-varying, and add this one to the list
+$entries = array();
+$vary = $response->headers->get('vary');
+foreach ($this->getMetadata($key) as $entry) {
+if (!isset($entry[1]['vary'])) {
+$entry[1]['vary'] = array('');
+}
+if ($vary != $entry[1]['vary'][0] || !$this->requestsMatch($vary, $entry[0], $storedEnv)) {
+$entries[] = $entry;
+}
+}
+$headers = $this->persistResponse($response);
+unset($headers['age']);
+array_unshift($entries, array($storedEnv, $headers));
+if (false === $this->save($key, serialize($entries))) {
+throw new \RuntimeException('Unable to store the metadata.');
+}
+return $key;
+}
+/**
+* Invalidates all cache entries that match the request.
+*
+* @param Request $request A Request instance
+*/
+public function invalidate(Request $request)
+{
+$modified = false;
+$key = $this->getCacheKey($request);
+$entries = array();
+foreach ($this->getMetadata($key) as $entry) {
+$response = $this->restoreResponse($entry[1]);
+if ($response->isFresh()) {
+$response->expire();
+$modified = true;
+$entries[] = array($entry[0], $this->persistResponse($response));
+} else {
+$entries[] = $entry;
+}
+}
+if ($modified) {
+if (false === $this->save($key, serialize($entries))) {
+throw new \RuntimeException('Unable to store the metadata.');
+}
+}
+// As per the RFC, invalidate Location and Content-Location URLs if present
+foreach (array('Location', 'Content-Location') as $header) {
+if ($uri = $request->headers->get($header)) {
+$subRequest = Request::create($uri, 'get', array(), array(), array(), $request->server->all());
+$this->invalidate($subRequest);
+}
+}
+}
+/**
+* Determines whether two Request HTTP header sets are non-varying based on
+* the vary response header value provided.
+*
+* @param string $vary A Response vary header
+* @param array  $env1 A Request HTTP header array
+* @param array  $env2 A Request HTTP header array
+*
+* @return Boolean true if the the two environments match, false otherwise
+*/
+private function requestsMatch($vary, $env1, $env2)
+{
+if (empty($vary)) {
+return true;
+}
+foreach (preg_split('/[\s,]+/', $vary) as $header) {
+$key = strtr(strtolower($header), '_', '-');
+$v1 = isset($env1[$key]) ? $env1[$key] : null;
+$v2 = isset($env2[$key]) ? $env2[$key] : null;
+if ($v1 !== $v2) {
+return false;
+}
+}
+return true;
+}
+/**
+* Gets all data associated with the given key.
+*
+* Use this method only if you know what you are doing.
+*
+* @param string $key The store key
+*
+* @return array An array of data associated with the key
+*/
+private function getMetadata($key)
+{
+if (false === $entries = $this->load($key)) {
+return array();
+}
+return unserialize($entries);
+}
+/**
+* Purges data for the given URL.
+*
+* @param string $url A URL
+*
+* @return Boolean true if the URL exists and has been purged, false otherwise
+*/
+public function purge($url)
+{
+if (file_exists($path = $this->getPath($this->getCacheKey(Request::create($url))))) {
+unlink($path);
+return true;
+}
+return false;
+}
+/**
+* Loads data for the given key.
+*
+* @param string $key  The store key
+*
+* @return string The data associated with the key
+*/
+private function load($key)
+{
+$path = $this->getPath($key);
+return file_exists($path) ? file_get_contents($path) : false;
+}
+/**
+* Save data for the given key.
+*
+* @param string $key  The store key
+* @param string $data The data to store
+*/
+private function save($key, $data)
+{
+$path = $this->getPath($key);
+if (!is_dir(dirname($path)) && false === @mkdir(dirname($path), 0777, true)) {
+return false;
+}
+$tmpFile = tempnam(dirname($path), basename($path));
+if (false === $fp = @fopen($tmpFile, 'wb')) {
+return false;
+}
+@fwrite($fp, $data);
+@fclose($fp);
+if ($data != file_get_contents($tmpFile)) {
+return false;
+}
+if (false === @rename($tmpFile, $path)) {
+return false;
+}
+chmod($path, 0644);
+}
+public function getPath($key)
+{
+return $this->root.DIRECTORY_SEPARATOR.substr($key, 0, 2).DIRECTORY_SEPARATOR.substr($key, 2, 2).DIRECTORY_SEPARATOR.substr($key, 4, 2).DIRECTORY_SEPARATOR.substr($key, 6);
+}
+/**
+* Returns a cache key for the given Request.
+*
+* @param Request $request A Request instance
+*
+* @return string A key for the given Request
+*/
+private function getCacheKey(Request $request)
+{
+if (isset($this->keyCache[$request])) {
+return $this->keyCache[$request];
+}
+return $this->keyCache[$request] = 'md'.sha1($request->getUri());
+}
+/**
+* Persists the Request HTTP headers.
+*
+* @param Request $request A Request instance
+*
+* @return array An array of HTTP headers
+*/
+private function persistRequest(Request $request)
+{
+return $request->headers->all();
+}
+/**
+* Persists the Response HTTP headers.
+*
+* @param Response $response A Response instance
+*
+* @return array An array of HTTP headers
+*/
+private function persistResponse(Response $response)
+{
+$headers = $response->headers->all();
+$headers['X-Status'] = array($response->getStatusCode());
+return $headers;
+}
+/**
+* Restores a Response from the HTTP headers and body.
+*
+* @param array  $headers An array of HTTP headers for the Response
+* @param string $body    The Response body
+*/
+private function restoreResponse($headers, $body = null)
+{
+$status = $headers['X-Status'][0];
+unset($headers['X-Status']);
+if (null !== $body) {
+$headers['X-Body-File'] = array($body);
+}
+return new Response($body, $status, $headers);
+}
+}