Merge remote-tracking branch 'driebit/master'

Author: dbu

.gitignore

@@ -0,0 +1,3 @@
+vendor/
+composer.lock
+phpunit.xml

.travis.yml

@@ -0,0 +1,10 @@
+language: php
+
+php:
+  - 5.3
+  - 5.4
+
+before_script:
+  - composer install --dev
+
+script: phpunit --coverage-text

CacheManager.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Driebit\HttpCacheBundle;
+
+use Driebit\HttpCacheBundle\HttpCache\HttpCacheInterface;
+use Symfony\Component\Routing\RouterInterface;
+
+/**
+ * Manages HTTP cache invalidations
+ *
+ */
+class CacheManager
+{
+    /**
+     * @var HttpCacheInterface
+     */
+    protected $cache;
+
+    /**
+     * @var RouterInterface
+     */
+    protected $router;
+
+    /**
+     * Invalidation queue
+     *
+     * @var array
+     */
+    protected $invalidationQueue = array();
+
+    /**
+     * Constructor
+     *
+     * @param HttpCacheInterface $cache  HTTP cache
+     * @param RouterInterface    $router Symfony router
+     */
+    public function __construct(HttpCacheInterface $cache, RouterInterface $router)
+    {
+        $this->cache = $cache;
+        $this->router = $router;
+    }
+
+    /**
+     * Invalidate a path (URL)
+     *
+     * @param string $path Path
+     *
+     * @return $this
+     */
+    public function invalidatePath($path)
+    {
+        $this->invalidationQueue[$path] = $path;
+
+        return $this;
+    }
+
+    /**
+     * Invalidate a route
+     *
+     * @param string $name       Route name
+     * @param array  $parameters Route parameters (optional)
+     *
+     * @return $this
+     */
+    public function invalidateRoute($name, $parameters = array())
+    {
+        $this->invalidatePath($this->router->generate($name, $parameters));
+
+        return $this;
+    }
+
+    /**
+     * Flush all paths queued for invalidation
+     *
+     * @return array Paths that were flushed from the queue
+     */
+    public function flush()
+    {
+        $queue = $this->getInvalidationQueue();
+
+        if (0 === count($queue)) {
+            return $queue;
+        }
+
+        $this->cache->invalidateUrls($queue);
+        $this->invalidationQueue = array();
+
+        return $queue;
+    }
+
+    /**
+     * Get paths (URLs) that are queued for invalidation
+     *
+     * @return array
+     */
+    public function getInvalidationQueue()
+    {
+        return \array_values($this->invalidationQueue);
+    }
+}

DependencyInjection/Configuration.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace Driebit\HttpCacheBundle\DependencyInjection;
+
+use Symfony\Component\Config\Definition\Builder\TreeBuilder;
+use Symfony\Component\Config\Definition\ConfigurationInterface;
+
+/**
+ * This is the class that validates and merges configuration from your app/config files
+ *
+ * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html#cookbook-bundles-extension-config-class}
+ */
+class Configuration implements ConfigurationInterface
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function getConfigTreeBuilder()
+    {
+        $treeBuilder = new TreeBuilder();
+        $rootNode = $treeBuilder->root('driebit_http_cache');
+
+        $rootNode
+            ->children()
+                ->arrayNode('http_cache')->isRequired()
+                    ->children()
+                        ->arrayNode('varnish')
+                            ->children()
+                                ->scalarNode('host')->isRequired()->end()
+                                ->arrayNode('ips')
+                                    ->isRequired()
+                                    ->requiresAtLeastOneElement()
+                                    ->prototype('scalar')->end()
+                                ->end()
+                            ->end()
+                        ->end()
+                    ->end()
+                ->end()
+                ->arrayNode('invalidators')
+                    ->useAttributeAsKey('name')
+                    ->prototype('array')
+                        ->children()
+                            ->arrayNode('origin_routes')
+                                ->isRequired()
+                                ->requiresAtLeastOneElement()
+                                ->prototype('scalar')->end()
+                            ->end()
+                            ->arrayNode('invalidate_routes')
+                                ->useAttributeAsKey('name')
+                                ->prototype('array')
+                                    ->children()
+                                        ->scalarNode('parameter_mapper')->end()
+                                        ->booleanNode('ignore_extra_params')->defaultTrue()->end()
+                                    ->end()
+                                ->end()
+                            ->end()
+                        ->end()
+                    ->end()
+                ->end()
+            ->end();
+
+        return $treeBuilder;
+    }
+}

DependencyInjection/DriebitHttpCacheExtension.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Driebit\HttpCacheBundle\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\Config\FileLocator;
+use Symfony\Component\HttpKernel\DependencyInjection\Extension;
+use Symfony\Component\DependencyInjection\Loader;
+
+/**
+ * This is the class that loads and manages your bundle configuration
+ *
+ * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html}
+ */
+class DriebitHttpCacheExtension extends Extension
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function load(array $configs, ContainerBuilder $container)
+    {
+        $configuration = new Configuration();
+        $config = $this->processConfiguration($configuration, $configs);
+
+        $loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
+        $loader->load('services.xml');
+        $container->setParameter('driebit_http_cache.invalidators', $config['invalidators']);
+
+        if (isset($config['http_cache']['varnish'])) {
+            $loader->load('varnish.xml');
+            $container->setParameter('driebit_http_cache.http_cache.varnish.ips', $config['http_cache']['varnish']['ips']);
+            $container->setParameter('driebit_http_cache.http_cache.varnish.host', $config['http_cache']['varnish']['host']);
+
+        }
+    }
+}

DriebitHttpCacheBundle.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Driebit\HttpCacheBundle;
+
+use Symfony\Component\HttpKernel\Bundle\Bundle;
+
+class DriebitHttpCacheBundle extends Bundle
+{
+}

EventListener/InvalidationListener.php

@@ -0,0 +1,114 @@
+<?php
+
+namespace Driebit\HttpCacheBundle\EventListener;
+
+use Driebit\HttpCacheBundle\CacheManager;
+use Driebit\HttpCacheBundle\Invalidator\InvalidatorCollection;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\HttpKernel\KernelEvents;
+use Symfony\Component\HttpKernel\Event\PostResponseEvent;
+use Symfony\Component\Routing\RouterInterface;
+
+/**
+ * On kernel.terminate event, this listener invalidates routes for the current request and flushes the cache manager
+ *
+ * @author David de Boer <[email protected]>
+ */
+class InvalidationListener implements EventSubscriberInterface
+{
+    /**
+     * Cache manager
+     *
+     * @var CacheManager
+     */
+    protected $cacheManager;
+
+    /**
+     * Invalidator collection
+     *
+     * @var InvalidatorCollection
+     */
+    protected $invalidators;
+
+    /**
+     * Router
+     *
+     * @var RouterInterface
+     */
+    protected $router;
+
+    /**
+     * Constructor
+     *
+     * @param CacheManager          $cacheManager
+     * @param InvalidatorCollection $invalidators
+     * @param RouterInterface       $router
+     */
+    public function __construct(
+        CacheManager $cacheManager,
+        InvalidatorCollection $invalidators,
+        RouterInterface $router
+    ) {
+        $this->cacheManager = $cacheManager;
+        $this->invalidators = $invalidators;
+        $this->router = $router;
+    }
+
+    /**
+     * Apply invalidators and flush cache manager
+     *
+     * On kernel.terminate:
+     * - see if any invalidators apply to the current request and, if so, add
+     *   their routes to the cache manager
+     * - flush the cache manager in order to send invalidation requests to the
+     *   HTTP cache.
+     *
+     * @param PostResponseEvent $event
+     *
+     * @return array Paths that were flushed from the invalidation queue
+     */
+    public function onKernelTerminate(PostResponseEvent $event)
+    {
+        // Are there any invalidators configured for the current request route?
+        $request = $event->getRequest();
+        $requestRoute = $request->attributes->get('_route');
+        if (!$this->invalidators->hasInvalidatorRoute($requestRoute)) {
+            return $this->cacheManager->flush();
+        }
+
+        // Don't invalidate any caches if the request was unsuccessful
+        $response = $event->getResponse();
+        if (!$response->isSuccessful()) {
+            return $this->cacheManager->flush();
+        }
+
+        $requestParams = $request->attributes->get('_route_params');
+        $invalidators = $this->invalidators->getInvalidators($requestRoute);
+        foreach ($invalidators as $invalidator) {
+            foreach ($invalidator->getInvalidatedRoutes() as $route => $config) {
+                $path = $this->router->generate($route, $requestParams);
+
+                // If extra route parameters should be ignored, strip the query
+                // string generated by the Symfony router from the path
+                if (isset($config['ignore_extra_params'])
+                    && $config['ignore_extra_params']
+                    && $pos = strpos($path, '?')
+                ) {
+                    $path = substr($path, 0, $pos);
+                }
+
+                $this->cacheManager->invalidatePath($path);
+            }
+        }
+
+        return $this->cacheManager->flush();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function getSubscribedEvents()
+    {
+        return array(KernelEvents::TERMINATE => 'onKernelTerminate');
+    }
+}

HttpCache/HttpCacheInterface.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Driebit\HttpCacheBundle\HttpCache;
+
+/**
+ * A shared HTTP cache
+ *
+ * @author David de Boer <[email protected]>
+ */
+interface HttpCacheInterface
+{
+    /**
+     * Invalidate one URL
+     *
+     * @param string $url
+     */
+    public function invalidateUrl($url);
+
+    /**
+     * Invalidate multiple URLs
+     *
+     * @param array $urls
+     */
+    public function invalidateUrls(array $urls);
+}