vendor/symfony/dependency-injection/EnvVarProcessor.php line 31

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\DependencyInjection;
  14. use Symfony\Component\DependencyInjection\Exception\EnvNotFoundException;
  15. use Symfony\Component\DependencyInjection\Exception\ParameterCircularReferenceException;
  16. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  18. /**
  19.  * @author Nicolas Grekas <p@tchwork.com>
  20.  */
  21. class EnvVarProcessor implements EnvVarProcessorInterface
  22. {
  23.     private ContainerInterface $container;
  24.     /** @var \Traversable<EnvVarLoaderInterface> */
  25.     private \Traversable $loaders;
  26.     private array $loadedVars = [];
  28.     /**
  29.      * @param \Traversable<EnvVarLoaderInterface>|null $loaders
  30.      */
  31.     public function __construct(ContainerInterface $container, \Traversable $loaders = null)
  32.     {
  33.         $this->container = $container;
  34.         $this->loaders = $loaders ?? new \ArrayIterator();
  35.     }
  37.     public static function getProvidedTypes(): array
  38.     {
  39.         return [
  40.             'base64' => 'string',
  41.             'bool' => 'bool',
  42.             'not' => 'bool',
  43.             'const' => 'bool|int|float|string|array',
  44.             'csv' => 'array',
  45.             'file' => 'string',
  46.             'float' => 'float',
  47.             'int' => 'int',
  48.             'json' => 'array',
  49.             'key' => 'bool|int|float|string|array',
  50.             'url' => 'array',
  51.             'query_string' => 'array',
  52.             'resolve' => 'string',
  53.             'default' => 'bool|int|float|string|array',
  54.             'string' => 'string',
  55.             'trim' => 'string',
  56.             'require' => 'bool|int|float|string|array',
  57.             'enum' => \BackedEnum::class,
  58.             'shuffle' => 'array',
  59.         ];
  60.     }
  62.     public function getEnv(string $prefix, string $name, \Closure $getEnv): mixed
  63.     {
  64.         $i = strpos($name, ':');
  66.         if ('key' === $prefix) {
  67.             if (false === $i) {
  68.                 throw new RuntimeException(sprintf('Invalid env "key:%s": a key specifier should be provided.', $name));
  69.             }
  71.             $next = substr($name, $i + 1);
  72.             $key = substr($name, 0, $i);
  73.             $array = $getEnv($next);
  75.             if (!\is_array($array)) {
  76.                 throw new RuntimeException(sprintf('Resolved value of "%s" did not result in an array value.', $next));
  77.             }
  79.             if (!isset($array[$key]) && !\array_key_exists($key, $array)) {
  80.                 throw new EnvNotFoundException(sprintf('Key "%s" not found in %s (resolved from "%s").', $key, json_encode($array), $next));
  81.             }
  83.             return $array[$key];
  84.         }
  86.         if ('enum' === $prefix) {
  87.             if (false === $i) {
  88.                 throw new RuntimeException(sprintf('Invalid env "enum:%s": a "%s" class-string should be provided.', $name, \BackedEnum::class));
  89.             }
  91.             $next = substr($name, $i + 1);
  92.             $backedEnumClassName = substr($name, 0, $i);
  93.             $backedEnumValue = $getEnv($next);
  95.             if (!\is_string($backedEnumValue) && !\is_int($backedEnumValue)) {
  96.                 throw new RuntimeException(sprintf('Resolved value of "%s" did not result in a string or int value.', $next));
  97.             }
  99.             if (!is_subclass_of($backedEnumClassName, \BackedEnum::class)) {
  100.                 throw new RuntimeException(sprintf('"%s" is not a "%s".', $backedEnumClassName, \BackedEnum::class));
  101.             }
  103.             return $backedEnumClassName::tryFrom($backedEnumValue) ?? throw new RuntimeException(sprintf('Enum value "%s" is not backed by "%s".', $backedEnumValue, $backedEnumClassName));
  104.         }
  106.         if ('default' === $prefix) {
  107.             if (false === $i) {
  108.                 throw new RuntimeException(sprintf('Invalid env "default:%s": a fallback parameter should be provided.', $name));
  109.             }
  111.             $next = substr($name, $i + 1);
  112.             $default = substr($name, 0, $i);
  114.             if ('' !== $default && !$this->container->hasParameter($default)) {
  115.                 throw new RuntimeException(sprintf('Invalid env fallback in "default:%s": parameter "%s" not found.', $name, $default));
  116.             }
  118.             try {
  119.                 $env = $getEnv($next);
  121.                 if ('' !== $env && null !== $env) {
  122.                     return $env;
  123.                 }
  124.             } catch (EnvNotFoundException) {
  125.                 // no-op
  126.             }
  128.             return '' === $default ? null : $this->container->getParameter($default);
  129.         }
  131.         if ('file' === $prefix || 'require' === $prefix) {
  132.             if (!\is_scalar($file = $getEnv($name))) {
  133.                 throw new RuntimeException(sprintf('Invalid file name: env var "%s" is non-scalar.', $name));
  134.             }
  135.             if (!is_file($file)) {
  136.                 throw new EnvNotFoundException(sprintf('File "%s" not found (resolved from "%s").', $file, $name));
  137.             }
  139.             if ('file' === $prefix) {
  140.                 return file_get_contents($file);
  141.             } else {
  142.                 return require $file;
  143.             }
  144.         }
  146.         if (false !== $i || 'string' !== $prefix) {
  147.             $env = $getEnv($name);
  148.         } elseif (isset($_ENV[$name])) {
  149.             $env = $_ENV[$name];
  150.         } elseif (isset($_SERVER[$name]) && !str_starts_with($name, 'HTTP_')) {
  151.             $env = $_SERVER[$name];
  152.         } elseif (false === ($env = getenv($name)) || null === $env) { // null is a possible value because of thread safety issues
  153.             foreach ($this->loadedVars as $vars) {
  154.                 if (false !== $env = ($vars[$name] ?? false)) {
  155.                     break;
  156.                 }
  157.             }
  159.             if (false === $env || null === $env) {
  160.                 $loaders = $this->loaders;
  161.                 $this->loaders = new \ArrayIterator();
  163.                 try {
  164.                     $i = 0;
  165.                     $ended = true;
  166.                     $count = $loaders instanceof \Countable ? $loaders->count() : 0;
  167.                     foreach ($loaders as $loader) {
  168.                         if (\count($this->loadedVars) > $i++) {
  169.                             continue;
  170.                         }
  171.                         $this->loadedVars[] = $vars = $loader->loadEnvVars();
  172.                         if (false !== $env = $vars[$name] ?? false) {
  173.                             $ended = false;
  174.                             break;
  175.                         }
  176.                     }
  177.                     if ($ended || $count === $i) {
  178.                         $loaders = $this->loaders;
  179.                     }
  180.                 } catch (ParameterCircularReferenceException) {
  181.                     // skip loaders that need an env var that is not defined
  182.                 } finally {
  183.                     $this->loaders = $loaders;
  184.                 }
  185.             }
  187.             if (false === $env || null === $env) {
  188.                 if (!$this->container->hasParameter("env($name)")) {
  189.                     throw new EnvNotFoundException(sprintf('Environment variable not found: "%s".', $name));
  190.                 }
  192.                 $env = $this->container->getParameter("env($name)");
  193.             }
  194.         }
  196.         if (null === $env) {
  197.             if (!isset($this->getProvidedTypes()[$prefix])) {
  198.                 throw new RuntimeException(sprintf('Unsupported env var prefix "%s".', $prefix));
  199.             }
  201.             return null;
  202.         }
  204.         if ('shuffle' === $prefix) {
  205.             \is_array($env) ? shuffle($env) : throw new RuntimeException(sprintf('Env var "%s" cannot be shuffled, expected array, got "%s".', $name, get_debug_type($env)));
  207.             return $env;
  208.         }
  210.         if (!\is_scalar($env)) {
  211.             throw new RuntimeException(sprintf('Non-scalar env var "%s" cannot be cast to "%s".', $name, $prefix));
  212.         }
  214.         if ('string' === $prefix) {
  215.             return (string) $env;
  216.         }
  218.         if (\in_array($prefix, ['bool', 'not'], true)) {
  219.             $env = (bool) (filter_var($env, \FILTER_VALIDATE_BOOL) ?: filter_var($env, \FILTER_VALIDATE_INT) ?: filter_var($env, \FILTER_VALIDATE_FLOAT));
  221.             return 'not' === $prefix ? !$env : $env;
  222.         }
  224.         if ('int' === $prefix) {
  225.             if (false === $env = filter_var($env, \FILTER_VALIDATE_INT) ?: filter_var($env, \FILTER_VALIDATE_FLOAT)) {
  226.                 throw new RuntimeException(sprintf('Non-numeric env var "%s" cannot be cast to int.', $name));
  227.             }
  229.             return (int) $env;
  230.         }
  232.         if ('float' === $prefix) {
  233.             if (false === $env = filter_var($env, \FILTER_VALIDATE_FLOAT)) {
  234.                 throw new RuntimeException(sprintf('Non-numeric env var "%s" cannot be cast to float.', $name));
  235.             }
  237.             return (float) $env;
  238.         }
  240.         if ('const' === $prefix) {
  241.             if (!\defined($env)) {
  242.                 throw new RuntimeException(sprintf('Env var "%s" maps to undefined constant "%s".', $name, $env));
  243.             }
  245.             return \constant($env);
  246.         }
  248.         if ('base64' === $prefix) {
  249.             return base64_decode(strtr($env, '-_', '+/'));
  250.         }
  252.         if ('json' === $prefix) {
  253.             $env = json_decode($env, true);
  255.             if (\JSON_ERROR_NONE !== json_last_error()) {
  256.                 throw new RuntimeException(sprintf('Invalid JSON in env var "%s": ', $name).json_last_error_msg());
  257.             }
  259.             if (null !== $env && !\is_array($env)) {
  260.                 throw new RuntimeException(sprintf('Invalid JSON env var "%s": array or null expected, "%s" given.', $name, get_debug_type($env)));
  261.             }
  263.             return $env;
  264.         }
  266.         if ('url' === $prefix) {
  267.             $parsedEnv = parse_url($env);
  269.             if (false === $parsedEnv) {
  270.                 throw new RuntimeException(sprintf('Invalid URL in env var "%s".', $name));
  271.             }
  272.             if (!isset($parsedEnv['scheme'], $parsedEnv['host'])) {
  273.                 throw new RuntimeException(sprintf('Invalid URL env var "%s": schema and host expected, "%s" given.', $name, $env));
  274.             }
  275.             $parsedEnv += [
  276.                 'port' => null,
  277.                 'user' => null,
  278.                 'pass' => null,
  279.                 'path' => null,
  280.                 'query' => null,
  281.                 'fragment' => null,
  282.             ];
  284.             // remove the '/' separator
  285.             $parsedEnv['path'] = '/' === ($parsedEnv['path'] ?? '/') ? '' : substr($parsedEnv['path'], 1);
  287.             return $parsedEnv;
  288.         }
  290.         if ('query_string' === $prefix) {
  291.             $queryString = parse_url($env, \PHP_URL_QUERY) ?: $env;
  292.             parse_str($queryString, $result);
  294.             return $result;
  295.         }
  297.         if ('resolve' === $prefix) {
  298.             return preg_replace_callback('/%%|%([^%\s]+)%/', function ($match) use ($name, $getEnv) {
  299.                 if (!isset($match[1])) {
  300.                     return '%';
  301.                 }
  303.                 if (str_starts_with($match[1], 'env(') && str_ends_with($match[1], ')') && 'env()' !== $match[1]) {
  304.                     $value = $getEnv(substr($match[1], 4, -1));
  305.                 } else {
  306.                     $value = $this->container->getParameter($match[1]);
  307.                 }
  309.                 if (!\is_scalar($value)) {
  310.                     throw new RuntimeException(sprintf('Parameter "%s" found when resolving env var "%s" must be scalar, "%s" given.', $match[1], $name, get_debug_type($value)));
  311.                 }
  313.                 return $value;
  314.             }, $env);
  315.         }
  317.         if ('csv' === $prefix) {
  318.             return str_getcsv($env, ',', '"', '');
  319.         }
  321.         if ('trim' === $prefix) {
  322.             return trim($env);
  323.         }
  325.         throw new RuntimeException(sprintf('Unsupported env var prefix "%s" for env name "%s".', $prefix, $name));
  326.     }
  327. }