src/AppBundle/Controller/EsiController.php line 69

Open in your IDE?
  1. <?php
  3. namespace AppBundle\Controller;
  5. use Psr\Log\LoggerInterface;
  6. use Symfony\Component\HttpFoundation\Response;
  7. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  9. /**
  10.  * Controller for page fragments rendered as Edge Side Includes (ESI)
  11.  *
  12.  * ESI would normally be rendered via `{{ render_esi(controller(...)) }}` function in twig, however that method
  13.  * generates a unique signature for each fragment, hence making URI un-guessable. Even though this makes sense from
  14.  * security viewpoint (in some scenarios), it would prevent us to selectively invalidate varnish cache via PURGE method.
  15.  *
  16.  * Registering this controller as a separate route and rendering ESI tags manually allows us to use ESI fragments at
  17.  * predictable URIs.
  18.  *
  19.  * Adding new ESI fragments for existing twig `render(controller(...))` calls:
  20.  *
  21.  * 1. register a route - see e.g. `esiModerators` in `routing.yml`
  22.  * 2. add method that wraps the original controller method (see e.g.
  23.  *    {@link EsiController::showModeratorsAction()})
  24.  * 3. verify that cache/vary headers added by the original controller method are in line with what you set in your new
  25.  *    EsiController method
  26.  * 4. replace original `render()` calls with `esi_wrapper('nameOfNewEsiRoute')` (see example below)
  27.  *
  28.  * **Note:**
  29.  * It is _immensely_ important to differentiate between ESI fragments that are user-agnostic (`esi/anonymous`) and those
  30.  * that are not. The former can call `::setResponseCacheHeaders($response, false, ...)` while the latter _must_ add
  31.  * `Vary: cookie` header by using `true` for the second argument! Varnish should then merge the `Vary` header internally
  32.  * and differentiate cache entries per-user (while still disregarding cookies for ESI fragments under `esi/anonymous`
  33.  * route).
  34.  *
  35.  * Also see ESI-specific comment in `routing.yml` regarding `anonymous/shared/user` link format for ESI fragments.
  36.  *
  37.  * Example - route without route params:
  38.  *
  39.  *     {{ esi_wrapper('esiModerators') }}
  40.  *
  41.  * Example - route with route params:
  42.  *
  43.  *     {{ esi_wrapper('esiImportedRss', {'context': 'homepage', 'rssSlug': 'fmg'}) }}
  44.  */
  45. class EsiController extends BaseController
  46. {
  47.     /**
  48.      * Render site header menu as ESI fragment
  49.      *
  50.      * @return Response
  51.      */
  52.     public function showHeaderMenuAction()
  53.     {
  54.         // render via original controller
  55.         $response = $this->forward('AppBundle:Snippets:getHeaderMenu');
  57.         // ... but override cache headers
  58.         $isEsiAnonymous = true;
  59.         $response = $this->setResponseCacheHeadersFromConfig($response, !$isEsiAnonymous, 'cache_ttl_seconds_menu');
  61.         return $response;
  62.     }
  64.     /**
  65.      * Render site footer as ESI fragment
  66.      *
  67.      * @return Response
  68.      */
  69.     public function showFooterAction()
  70.     {
  71.         // render via original controller
  72.         $response = $this->forward('AppBundle:Snippets:getFooter');
  74.         // ... but override cache headers
  75.         $isEsiAnonymous = true;
  76.         $response = $this->setResponseCacheHeadersFromConfig($response, !$isEsiAnonymous, 'cache_ttl_seconds_menu');
  78.         return $response;
  79.     }
  81.     /**
  82.      * Generic ESI renderer for any content loaded from locally cached JSON files
  83.      *
  84.      * Cache expiration is determined based on different between cron interval vs last modification time of JSON file.
  85.      *
  86.      * @param string $context Context where ESI fragment is displayed, i.e. `homepage`, (page) `section`or `sidebar`
  87.      * @param string $rssSlug Slug identifying which cached JSON file to use
  88.      *
  89.      * @return Response
  90.      */
  91.     public function showImportedRssAction($context, $rssSlug)
  92.     {
  93.         // identify active configuration
  94.         list('forward' => $forward, 'cacheKey' => $cacheKey) = $this->getImportedRssConfiguration($context, $rssSlug);
  96.         // render via original controller
  97.         $response = $this->forward($forward);
  99.         // determine cache interval
  100.         $cronInterval = $this->getOptionValue($cacheKey);
  101.         $cacheInterval = $this->getCacheIntervalFromFileModificationTime("data/feeds/{$rssSlug}.json", $cronInterval);
  103.         // override cache headers
  104.         $isEsiAnonymous = true;
  105.         $response = $this->setResponseCacheHeaders($response, !$isEsiAnonymous, $cacheInterval);
  107.         return $response;
  108.     }
  110.     /**
  111.      * Configuration helper for {@link EsiController::showImportedRssAction}
  112.      *
  113.      * @param string $context See {@link EsiController::showImportedRssAction}
  114.      * @param string $rssSlug See {@link EsiController::showImportedRssAction}
  115.      *
  116.      * @return array Returns array with configuration keys `forward` and `cacheKey`
  117.      */
  118.     private function getImportedRssConfiguration($context, $rssSlug)
  119.     {
  120.         $defaults = ['cacheKey' => 'cron_interval_rss'];
  121.         $config = [
  122.             // 'context/rssSlug' => [ 'forward' => 'bundle:controller:method', 'cacheKey' => 'cron_interval_foobar' ]
  123.             'homepage/fmg' => ['forward' => 'AppBundle:Homepage:showFmgArticles'],
  125.             // examples:
  126.             // 'homepage/fmg'   => ['forward' => 'AppBundle:Homepage:showFmgArticles', 'cacheKey' => 'croninterval_rss_fmg'],
  127.             //  'section/hokej' => ['forward' => 'AppBundle:Page:showHokejArticles']
  128.             //    'aside/*'     => ['forward' => 'AppBundle:Snippets:showSidebarRssArticles']
  129.             //        '*/hokej' => ['forward' => 'AppBundle:Snippets:showHokejArticles']
  130.         ];
  132.         // check if configuration is available for requested route parameters
  133.         switch (true) {
  134.             // direct match
  135.             case array_key_exists("{$context}/{$rssSlug}", $config):
  136.                 $configKey = "{$context}/{$rssSlug}";
  137.                 break;
  139.             // any context for given rssSlug
  140.             case array_key_exists("*/{$rssSlug}", $config):
  141.                 $configKey = "*/{$rssSlug}";
  142.                 break;
  144.             // any rssSlug for given context
  145.             case array_key_exists("{$context}/*", $config):
  146.                 $configKey = "{$context}/*";
  147.                 break;
  149.             // giving up...
  150.             default:
  151.                 throw new NotFoundHttpException();
  152.         }
  154.         // apply defaults to selected config
  155.         $activeConfig = array_merge($defaults, $config[$configKey]);
  157.         return $activeConfig;
  158.     }
  160.     /**
  161.      * Render moderators section as ESI fragment
  162.      *
  163.      * @return Response
  164.      */
  165.     public function showModeratorsAction()
  166.     {
  167.         // render via original controller
  168.         $response = $this->forward('AppBundle:Snippets:getModerators');
  170.         // ... but override cache headers
  171.         $isEsiAnonymous = true;
  172.         $response = $this->setResponseCacheHeadersFromConfig($response, !$isEsiAnonymous, 'cache_ttl_seconds_other');
  174.         return $response;
  175.     }
  177.     /**
  178.      * Get cache interval based on file modification date
  179.      *
  180.      * Used as alternative to {@link BaseController::getCacheInterval} for ESI fragments that render content from JSON
  181.      * files that are managed by local or remote cron scripts. This allows to synchronize expiration of cached ESI
  182.      * fragments in varnish with cron execution intervals.
  183.      *
  184.      * @param string $filePath        Path to file relative to project root directory
  185.      * @param int    $cronInterval    How often (in seconds) is cron executed?
  186.      * @param int    $cronLag         How many seconds to lag behind file modification date, taking cron accuracy and
  187.      *                                processing time into account?
  188.      * @param int    $recheckInterval How often (in seconds) to re-check if file did not exist yet or was outdated?
  189.      *
  190.      * @return int
  191.      */
  192.     private function getCacheIntervalFromFileModificationTime($filePath, $cronInterval, $cronLag = 15,
  193.                                                               $recheckInterval = 15)
  194.     {
  195.         /** @var LoggerInterface $logger */
  196.         $logger = $this->get('logger');
  198.         $cronInterval = intval($cronInterval, 10);
  199.         if ($cronInterval <= 0) {
  200.             // cron interval not configured or invalid
  201.             $logger->warning('Given invalid cron interval while being asked to determine ESI cache headers for file'
  202.                              . ' modification of data/' . $filePath);
  203.             return $recheckInterval;
  204.         }
  206.         $jsonPath = $this->getCachedJsonPath($filePath);
  208.         if (false === $jsonPath) {
  209.             $logger->warning('Failed to determine ESI cache headers from file modification date of data/' . $filePath);
  211.             return $recheckInterval;
  212.         }
  214.         $jsonAge = time() - filemtime($jsonPath);
  215.         $isOutdated = ($jsonAge >= $cronInterval + $cronLag);
  217.         if ($isOutdated) {
  218.             return $recheckInterval;
  219.         }
  221.         return $cronInterval + $cronLag - $jsonAge;
  222.     }
  223. }