commit cac10c5271153ae00901990e50ff8526dbd88071
Author: Richard Bradley <Richard.Bradley@softwire.com>
Date:   Wed Apr 5 10:16:47 2017 +0100

    Remove expired filesystem cache entries, disable cache writes when disk is full

diff --git a/app/config/services.yml b/app/config/services.yml
index afb92fb5..ac604ee2 100644
--- a/app/config/services.yml
+++ b/app/config/services.yml
@@ -160,7 +160,7 @@ services:
         class: "(some app service)"
         arguments:
             - "@http_client"
-            - "@doctrine_cache.providers.file_system_configuration_cache"
+            - "@file_system_cache"
             - []
             - "@logger"
             - "@debug.stopwatch"
@@ -347,6 +347,14 @@ services:
             - "@featured_collection_from_collection_pid_factory"
             - "@featured_collection_from_video_promo_factory"
 
+    file_system_cache:
+        class: AppBundle\Cache\FilesystemCacheWithSizeLimiting
+        arguments:
+            - "%kernel.cache_dir%/doctrine/cache/file_system"
+            - ""
+            - 0002
+            - "@logger"
+
     get_set_method_normalizer:
         class: Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer
         tags:
diff --git a/bake-scripts/90-cron-filesystem-cache-gc.sh b/bake-scripts/90-cron-filesystem-cache-gc.sh
new file mode 100755
index 00000000..35d498e6
--- /dev/null
+++ b/bake-scripts/90-cron-filesystem-cache-gc.sh
@@ -0,0 +1,11 @@
+#! /bin/bash
+
+FILE=/etc/cron.hourly/myapp-filesystem-cache-gc.sh
+
+cat > $FILE <<'END'
+# Remove any expired cache entries.
+cd /var/www/my-app
+php app/console cache:gc
+END
+
+chmod +x $FILE
diff --git a/src/AppBundle/Cache/FilesystemCacheWithSizeLimiting.php b/src/AppBundle/Cache/FilesystemCacheWithSizeLimiting.php
new file mode 100644
index 00000000..81c983c4
--- /dev/null
+++ b/src/AppBundle/Cache/FilesystemCacheWithSizeLimiting.php
@@ -0,0 +1,136 @@
+<?php
+
+
+namespace AppBundle\Cache;
+
+use Doctrine\Common\Cache\FilesystemCache;
+use Monolog\Logger;
+
+/**
+ * Adds GC and size limiting (i.e. stop caching when the disk
+ * is nearly full) to the Doctrine FilesystemCache.
+ *
+ * See https://github.com/symfony/symfony/issues/21764
+ */
+class FilesystemCacheWithSizeLimiting extends FilesystemCache {
+
+    /**
+     * If the server has less than this amount of free disk space
+     * remaining, then new cache entries will not be written
+     * (to prevent a server crash).
+     *
+     * Update the alarm in service_monitoring.py if you change this.
+     */
+    const MIN_FREE_DISK_SPACE_BYTES = 500 * 1024 * 1024;
+    static $diskFreeSpace;
+    /** @var Logger */
+    private $logger;
+
+    /**
+     * The length, in bytes of a unix timestamp.
+     * This will be true until at least 2038.
+     */
+    const TIMESTAMP_LENGTH_BYTES = 10;
+
+    public function __construct($directory, $extension, $umask, $logger)
+    {
+        parent::__construct($directory, $extension, $umask);
+        $this->logger = $logger;
+    }
+
+    /**
+     * Scans all cache files and deletes any which have expired.
+     *
+     * This may be an expensive operation.
+     *
+     * @return string a human-readable summary of the cache state
+     */
+    public function gc() {
+        // See doFlush()
+
+        if ('' !== $this->getExtension()) {
+            // (So we don't have to copy 'isFilenameEndingWithExtension')
+            throw new \Exception("This class does not support the 'extension' mode");
+        }
+
+        $time = time();
+        $freeSpaceBefore = disk_free_space($this->directory);
+        $entryCount = 0;
+        $expiredRemovedCount = 0;
+        $neverExpireCount = 0;
+
+        foreach ($this->getIterator() as $name => $file) {
+            if ($file->isFile()) {
+                $entryCount++;
+
+                // See doFetch()
+                $resource = fopen($name, "r");
+
+                if (false !== ($line = fgets($resource, self::TIMESTAMP_LENGTH_BYTES + 1))) {
+                    $lifetime = (int) $line;
+                } else {
+                    $lifetime = PHP_INT_MAX;
+                }
+
+                fclose($resource);
+
+                if ($lifetime == 0) {
+                    $neverExpireCount++;
+                } else if ($lifetime < $time) {
+                    // There is a race condition here, in that a separate request
+                    // may have written a newer cache entry to this $name in the
+                    // time since we read the expiry time above.
+                    // However, nothing too bad will happen in that case; we will
+                    // just delete a valid cache entry, which is not fatal.
+                    @unlink($name);
+
+                    $expiredRemovedCount++;
+                }
+            }
+        }
+
+        $freeSpaceAfter = disk_free_space($this->directory);
+
+        return "Filesystem cache GC OK.
+Elapsed time: " . (time() - $time) . "s
+Examined $entryCount file(s)
+Removed $expiredRemovedCount expired file(s)
+There are $neverExpireCount cache item(s) set to never expire
+The filesystem had free space $freeSpaceBefore before and $freeSpaceAfter after";
+    }
+
+    /**
+     * This is copied from FileCache, where it has private access.
+     *
+     * @return \Iterator
+     */
+    private function getIterator()
+    {
+        return new \RecursiveIteratorIterator(
+            new \RecursiveDirectoryIterator($this->directory, \FilesystemIterator::SKIP_DOTS),
+            \RecursiveIteratorIterator::CHILD_FIRST
+        );
+    }
+
+    protected function doSave($id, $data, $lifeTime = 0) {
+        $freeSpace = $this->estimateFreeSpaceRemaining();
+        if ($freeSpace < self::MIN_FREE_DISK_SPACE_BYTES) {
+            $this->logger->warn("Free disk space of $freeSpace is less than " .
+                "the min threshold of " . self::MIN_FREE_DISK_SPACE_BYTES . ". " .
+                "No new filesystem cache entries will be written.");
+            return false;
+        } else {
+            return parent::doSave($id, $data, $lifeTime);
+        }
+    }
+
+    private function estimateFreeSpaceRemaining() {
+        // See doGetStats()
+        // We cache this in a static var to avoid calling this function
+        // more than once per request.
+        if (!isset(self::$diskFreeSpace)) {
+            self::$diskFreeSpace = disk_free_space($this->directory);
+        }
+        return self::$diskFreeSpace;
+    }
+}
diff --git a/src/AppBundle/Command/FilesystemCacheGcCommand.php b/src/AppBundle/Command/FilesystemCacheGcCommand.php
new file mode 100644
index 00000000..6f8ffd9b
--- /dev/null
+++ b/src/AppBundle/Command/FilesystemCacheGcCommand.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace AppBundle\Command;
+
+use AppBundle\Cache\FilesystemCacheWithSizeLimiting;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Invokes the GC op on the filesystem cache
+ */
+class FilesystemCacheGcCommand extends Command  implements ContainerAwareInterface {
+
+    /**
+     * @var ContainerInterface
+     */
+    private $container;
+
+    protected function configure()
+    {
+        $this
+            ->setName('cache:gc')
+            ->setDescription('Deletes expired filesystem cache entries.')
+            ->setHelp('Deletes expired filesystem cache entries.');
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $container = $this->getContainer();
+        /** @var FilesystemCacheWithSizeLimiting $cacheProvider */
+        $cacheProvider = $container->get("filesystem_cache");
+
+        $summary = $cacheProvider->gc();
+
+        $output->writeln($summary);
+    }
+
+    /**
+     * @return \Symfony\Component\DependencyInjection\ContainerInterface
+     */
+    protected function getContainer()
+    {
+        return $this->container;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setContainer(ContainerInterface $container = null)
+    {
+        $this->container = $container;
+    }
+}