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

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