vendor/bref/symfony-bridge/src/BrefKernel.php line 49

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Bref\SymfonyBridge;
  5. use Symfony\Component\Filesystem\Filesystem;
  6. use Symfony\Component\HttpKernel\HttpKernelInterface;
  7. use Symfony\Component\HttpKernel\Kernel;
  9. abstract class BrefKernel extends Kernel
  10. {
  11.     public function isLambda(): bool
  12.     {
  13.         return getenv('LAMBDA_TASK_ROOT') !== false;
  14.     }
  16.     /**
  17.      * {@inheritDoc}
  18.      */
  19.     public function getCacheDir()
  20.     {
  21.         if ($this->isLambda()) {
  22.             return '/tmp/cache/' . $this->environment;
  23.         }
  25.         return parent::getCacheDir();
  26.     }
  28.     /**
  29.      * {@inheritDoc}
  30.      */
  31.     public function getLogDir()
  32.     {
  33.         if ($this->isLambda()) {
  34.             return '/tmp/log/';
  35.         }
  37.         return parent::getLogDir();
  38.     }
  40.     /**
  41.      * {@inheritDoc}
  42.      *
  43.      * When on the lambda, copy the cache dir over to /tmp where it is writable
  44.      * We have to do this before Symfony does anything else with the Kernel
  45.      * otherwise it might prematurely warm the cache before we can copy it
  46.      *
  47.      * @see https://github.com/brefphp/symfony-bridge/pull/37
  48.      */
  49.     public function handle($request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
  50.     {
  51.         $this->prepareCacheDir(parent::getCacheDir(), $this->getCacheDir());
  53.         return parent::handle($request, $type, $catch);
  54.     }
  56.     /**
  57.      * {@inheritdoc}
  58.      *
  59.      * We also need to prepare the Cache dir in Kernel::boot in case we are in a Console or worker context
  60.      * in which Kernel::handle is not called.
  61.      */
  62.     public function boot()
  63.     {
  64.         $this->prepareCacheDir(parent::getCacheDir(), $this->getCacheDir());
  65.         $this->ensureLogDir($this->getLogDir());
  67.         parent::boot();
  68.     }
  70.     /**
  71.      * Return the pre-warmed directories in var/cache/[env] that should be copied to
  72.      * a writable directory in the Lambda environment.
  73.      *
  74.      * For optimal performance one should prewarm the cache folder and override this
  75.      * function to return an empty array.
  76.      */
  77.     protected function getWritableCacheDirectories(): array
  78.     {
  79.         return ['pools'];
  80.     }
  82.     protected function prepareCacheDir(string $readOnlyDir, string $writeDir): void
  83.     {
  84.         if (! $this->isLambda() || is_dir($writeDir) || ! is_dir($readOnlyDir)) {
  85.             return;
  86.         }
  88.         $startTime = microtime(true);
  89.         $cacheDirectoriesToCopy = $this->getWritableCacheDirectories();
  90.         $filesystem = new Filesystem;
  91.         $filesystem->mkdir($writeDir);
  93.         $scandir = scandir($readOnlyDir, SCANDIR_SORT_NONE);
  94.         if ($scandir === false) {
  95.             return;
  96.         }
  98.         foreach ($scandir as $item) {
  99.             if (in_array($item, ['.', '..'])) {
  100.                 continue;
  101.             }
  103.             // Copy directories to a writable space on Lambda.
  104.             if (in_array($item, $cacheDirectoriesToCopy)) {
  105.                 $filesystem->mirror("$readOnlyDir/$item", "$writeDir/$item");
  106.                 continue;
  107.             }
  109.             // Symlink all other directories
  110.             // This is especially important with the Container* directories since it uses require_once statements
  111.             if (is_dir("$readOnlyDir/$item")) {
  112.                 $filesystem->symlink("$readOnlyDir/$item", "$writeDir/$item");
  113.                 continue;
  114.             }
  116.             // Copy all other files.
  117.             $filesystem->copy("$readOnlyDir/$item", "$writeDir/$item");
  118.         }
  120.         $this->logToStderr(sprintf(
  121.             'Symfony cache directory prepared in %s ms.',
  122.             number_format((microtime(true) - $startTime) * 1000, 2)
  123.         ));
  124.     }
  126.     /**
  127.      * Even though applications should never write into it on Lambda, there are parts of Symfony
  128.      * (like "about" CLI command) that expect the log dir exists, so we have to make sure of it.
  129.      *
  130.      * @see https://github.com/brefphp/symfony-bridge/issues/42
  131.      */
  132.     private function ensureLogDir(string $writeLogDir): void
  133.     {
  134.         if (! $this->isLambda() || is_dir($writeLogDir)) {
  135.             return;
  136.         }
  138.         $filesystem = new Filesystem;
  139.         $filesystem->mkdir($writeLogDir);
  140.     }
  142.     /**
  143.      * This method logs to stderr.
  144.      *
  145.      * It must only be used in a lambda environment since all error output will be logged.
  146.      *
  147.      * @param string $message The message to log
  148.      */
  149.     protected function logToStderr(string $message): void
  150.     {
  151.         file_put_contents('php://stderr', date('[c] ') . $message . PHP_EOL, FILE_APPEND);
  152.     }
  153. }