vendor/symfony/dependency-injection/Compiler/MergeExtensionConfigurationPass.php line 76

  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\Compiler;
  14. use Symfony\Component\Config\Definition\BaseNode;
  15. use Symfony\Component\DependencyInjection\ContainerBuilder;
  16. use Symfony\Component\DependencyInjection\Exception\LogicException;
  17. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  18. use Symfony\Component\DependencyInjection\Extension\ConfigurationExtensionInterface;
  19. use Symfony\Component\DependencyInjection\Extension\Extension;
  20. use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
  21. use Symfony\Component\DependencyInjection\Extension\PrependExtensionInterface;
  22. use Symfony\Component\DependencyInjection\ParameterBag\EnvPlaceholderParameterBag;
  23. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  25. /**
  26.  * Merges extension configs into the container builder.
  27.  *
  28.  * @author Fabien Potencier <fabien@symfony.com>
  29.  */
  30. class MergeExtensionConfigurationPass implements CompilerPassInterface
  31. {
  32.     /**
  33.      * @return void
  34.      */
  35.     public function process(ContainerBuilder $container)
  36.     {
  37.         $parameters = $container->getParameterBag()->all();
  38.         $definitions = $container->getDefinitions();
  39.         $aliases = $container->getAliases();
  40.         $exprLangProviders = $container->getExpressionLanguageProviders();
  41.         $configAvailable = class_exists(BaseNode::class);
  43.         foreach ($container->getExtensions() as $extension) {
  44.             if ($extension instanceof PrependExtensionInterface) {
  45.                 $extension->prepend($container);
  46.             }
  47.         }
  49.         foreach ($container->getExtensions() as $name => $extension) {
  50.             if (!$config = $container->getExtensionConfig($name)) {
  51.                 // this extension was not called
  52.                 continue;
  53.             }
  54.             $resolvingBag = $container->getParameterBag();
  55.             if ($resolvingBag instanceof EnvPlaceholderParameterBag && $extension instanceof Extension) {
  56.                 // create a dedicated bag so that we can track env vars per-extension
  57.                 $resolvingBag = new MergeExtensionConfigurationParameterBag($resolvingBag);
  58.                 if ($configAvailable) {
  59.                     BaseNode::setPlaceholderUniquePrefix($resolvingBag->getEnvPlaceholderUniquePrefix());
  60.                 }
  61.             }
  62.             $config = $resolvingBag->resolveValue($config);
  64.             try {
  65.                 $tmpContainer = new MergeExtensionConfigurationContainerBuilder($extension, $resolvingBag);
  66.                 $tmpContainer->setResourceTracking($container->isTrackingResources());
  67.                 $tmpContainer->addObjectResource($extension);
  68.                 if ($extension instanceof ConfigurationExtensionInterface && null !== $configuration = $extension->getConfiguration($config, $tmpContainer)) {
  69.                     $tmpContainer->addObjectResource($configuration);
  70.                 }
  72.                 foreach ($exprLangProviders as $provider) {
  73.                     $tmpContainer->addExpressionLanguageProvider($provider);
  74.                 }
  76.                 $extension->load($config, $tmpContainer);
  77.             } catch (\Exception $e) {
  78.                 if ($resolvingBag instanceof MergeExtensionConfigurationParameterBag) {
  79.                     $container->getParameterBag()->mergeEnvPlaceholders($resolvingBag);
  80.                 }
  82.                 throw $e;
  83.             }
  85.             if ($resolvingBag instanceof MergeExtensionConfigurationParameterBag) {
  86.                 // don't keep track of env vars that are *overridden* when configs are merged
  87.                 $resolvingBag->freezeAfterProcessing($extension, $tmpContainer);
  88.             }
  90.             $container->merge($tmpContainer);
  91.             $container->getParameterBag()->add($parameters);
  92.         }
  94.         $container->addDefinitions($definitions);
  95.         $container->addAliases($aliases);
  96.     }
  97. }
  99. /**
  100.  * @internal
  101.  */
  102. class MergeExtensionConfigurationParameterBag extends EnvPlaceholderParameterBag
  103. {
  104.     private array $processedEnvPlaceholders;
  106.     public function __construct(parent $parameterBag)
  107.     {
  108.         parent::__construct($parameterBag->all());
  109.         $this->mergeEnvPlaceholders($parameterBag);
  110.     }
  112.     public function freezeAfterProcessing(Extension $extension, ContainerBuilder $container): void
  113.     {
  114.         if (!$config = $extension->getProcessedConfigs()) {
  115.             // Extension::processConfiguration() wasn't called, we cannot know how configs were merged
  116.             return;
  117.         }
  118.         $this->processedEnvPlaceholders = [];
  120.         // serialize config and container to catch env vars nested in object graphs
  121.         $config = serialize($config).serialize($container->getDefinitions()).serialize($container->getAliases()).serialize($container->getParameterBag()->all());
  123.         if (false === stripos($config, 'env_')) {
  124.             return;
  125.         }
  127.         preg_match_all('/env_[a-f0-9]{16}_\w+_[a-f0-9]{32}/Ui', $config, $matches);
  128.         $usedPlaceholders = array_flip($matches[0]);
  129.         foreach (parent::getEnvPlaceholders() as $env => $placeholders) {
  130.             foreach ($placeholders as $placeholder) {
  131.                 if (isset($usedPlaceholders[$placeholder])) {
  132.                     $this->processedEnvPlaceholders[$env] = $placeholders;
  133.                     break;
  134.                 }
  135.             }
  136.         }
  137.     }
  139.     public function getEnvPlaceholders(): array
  140.     {
  141.         return $this->processedEnvPlaceholders ?? parent::getEnvPlaceholders();
  142.     }
  144.     public function getUnusedEnvPlaceholders(): array
  145.     {
  146.         return !isset($this->processedEnvPlaceholders) ? [] : array_diff_key(parent::getEnvPlaceholders(), $this->processedEnvPlaceholders);
  147.     }
  148. }
  150. /**
  151.  * A container builder preventing using methods that wouldn't have any effect from extensions.
  152.  *
  153.  * @internal
  154.  */
  155. class MergeExtensionConfigurationContainerBuilder extends ContainerBuilder
  156. {
  157.     private string $extensionClass;
  159.     public function __construct(ExtensionInterface $extension, ParameterBagInterface $parameterBag = null)
  160.     {
  161.         parent::__construct($parameterBag);
  163.         $this->extensionClass = $extension::class;
  164.     }
  166.     public function addCompilerPass(CompilerPassInterface $pass, string $type = PassConfig::TYPE_BEFORE_OPTIMIZATION, int $priority = 0): static
  167.     {
  168.         throw new LogicException(sprintf('You cannot add compiler pass "%s" from extension "%s". Compiler passes must be registered before the container is compiled.', get_debug_type($pass), $this->extensionClass));
  169.     }
  171.     public function registerExtension(ExtensionInterface $extension)
  172.     {
  173.         throw new LogicException(sprintf('You cannot register extension "%s" from "%s". Extensions must be registered before the container is compiled.', get_debug_type($extension), $this->extensionClass));
  174.     }
  176.     public function compile(bool $resolveEnvPlaceholders = false)
  177.     {
  178.         throw new LogicException(sprintf('Cannot compile the container in extension "%s".', $this->extensionClass));
  179.     }
  181.     public function resolveEnvPlaceholders(mixed $value, string|bool $format = null, array &$usedEnvs = null): mixed
  182.     {
  183.         if (true !== $format || !\is_string($value)) {
  184.             return parent::resolveEnvPlaceholders($value, $format, $usedEnvs);
  185.         }
  187.         $bag = $this->getParameterBag();
  188.         $value = $bag->resolveValue($value);
  190.         if (!$bag instanceof EnvPlaceholderParameterBag) {
  191.             return parent::resolveEnvPlaceholders($value, $format, $usedEnvs);
  192.         }
  194.         foreach ($bag->getEnvPlaceholders() as $env => $placeholders) {
  195.             if (!str_contains($env, ':')) {
  196.                 continue;
  197.             }
  198.             foreach ($placeholders as $placeholder) {
  199.                 if (false !== stripos($value, $placeholder)) {
  200.                     throw new RuntimeException(sprintf('Using a cast in "env(%s)" is incompatible with resolution at compile time in "%s". The logic in the extension should be moved to a compiler pass, or an env parameter with no cast should be used instead.', $env, $this->extensionClass));
  201.                 }
  202.             }
  203.         }
  205.         return parent::resolveEnvPlaceholders($value, $format, $usedEnvs);
  206.     }
  207. }