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

  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.     public function process(ContainerBuilder $container)
  33.     {
  34.         $parameters = $container->getParameterBag()->all();
  35.         $definitions = $container->getDefinitions();
  36.         $aliases = $container->getAliases();
  37.         $exprLangProviders = $container->getExpressionLanguageProviders();
  38.         $configAvailable = class_exists(BaseNode::class);
  40.         foreach ($container->getExtensions() as $extension) {
  41.             if ($extension instanceof PrependExtensionInterface) {
  42.                 $extension->prepend($container);
  43.             }
  44.         }
  46.         foreach ($container->getExtensions() as $name => $extension) {
  47.             if (!$config = $container->getExtensionConfig($name)) {
  48.                 // this extension was not called
  49.                 continue;
  50.             }
  51.             $resolvingBag = $container->getParameterBag();
  52.             if ($resolvingBag instanceof EnvPlaceholderParameterBag && $extension instanceof Extension) {
  53.                 // create a dedicated bag so that we can track env vars per-extension
  54.                 $resolvingBag = new MergeExtensionConfigurationParameterBag($resolvingBag);
  55.                 if ($configAvailable) {
  56.                     BaseNode::setPlaceholderUniquePrefix($resolvingBag->getEnvPlaceholderUniquePrefix());
  57.                 }
  58.             }
  59.             $config = $resolvingBag->resolveValue($config);
  61.             try {
  62.                 $tmpContainer = new MergeExtensionConfigurationContainerBuilder($extension, $resolvingBag);
  63.                 $tmpContainer->setResourceTracking($container->isTrackingResources());
  64.                 $tmpContainer->addObjectResource($extension);
  65.                 if ($extension instanceof ConfigurationExtensionInterface && null !== $configuration = $extension->getConfiguration($config, $tmpContainer)) {
  66.                     $tmpContainer->addObjectResource($configuration);
  67.                 }
  69.                 foreach ($exprLangProviders as $provider) {
  70.                     $tmpContainer->addExpressionLanguageProvider($provider);
  71.                 }
  73.                 $extension->load($config, $tmpContainer);
  74.             } catch (\Exception $e) {
  75.                 if ($resolvingBag instanceof MergeExtensionConfigurationParameterBag) {
  76.                     $container->getParameterBag()->mergeEnvPlaceholders($resolvingBag);
  77.                 }
  79.                 throw $e;
  80.             }
  82.             if ($resolvingBag instanceof MergeExtensionConfigurationParameterBag) {
  83.                 // don't keep track of env vars that are *overridden* when configs are merged
  84.                 $resolvingBag->freezeAfterProcessing($extension, $tmpContainer);
  85.             }
  87.             $container->merge($tmpContainer);
  88.             $container->getParameterBag()->add($parameters);
  89.         }
  91.         $container->addDefinitions($definitions);
  92.         $container->addAliases($aliases);
  93.     }
  94. }
  96. /**
  97.  * @internal
  98.  */
  99. class MergeExtensionConfigurationParameterBag extends EnvPlaceholderParameterBag
  100. {
  101.     private array $processedEnvPlaceholders;
  103.     public function __construct(parent $parameterBag)
  104.     {
  105.         parent::__construct($parameterBag->all());
  106.         $this->mergeEnvPlaceholders($parameterBag);
  107.     }
  109.     public function freezeAfterProcessing(Extension $extension, ContainerBuilder $container)
  110.     {
  111.         if (!$config = $extension->getProcessedConfigs()) {
  112.             // Extension::processConfiguration() wasn't called, we cannot know how configs were merged
  113.             return;
  114.         }
  115.         $this->processedEnvPlaceholders = [];
  117.         // serialize config and container to catch env vars nested in object graphs
  118.         $config = serialize($config).serialize($container->getDefinitions()).serialize($container->getAliases()).serialize($container->getParameterBag()->all());
  120.         if (false === stripos($config, 'env_')) {
  121.             return;
  122.         }
  124.         preg_match_all('/env_[a-f0-9]{16}_\w+_[a-f0-9]{32}/Ui', $config, $matches);
  125.         $usedPlaceholders = array_flip($matches[0]);
  126.         foreach (parent::getEnvPlaceholders() as $env => $placeholders) {
  127.             foreach ($placeholders as $placeholder) {
  128.                 if (isset($usedPlaceholders[$placeholder])) {
  129.                     $this->processedEnvPlaceholders[$env] = $placeholders;
  130.                     break;
  131.                 }
  132.             }
  133.         }
  134.     }
  136.     public function getEnvPlaceholders(): array
  137.     {
  138.         return $this->processedEnvPlaceholders ?? parent::getEnvPlaceholders();
  139.     }
  141.     public function getUnusedEnvPlaceholders(): array
  142.     {
  143.         return !isset($this->processedEnvPlaceholders) ? [] : array_diff_key(parent::getEnvPlaceholders(), $this->processedEnvPlaceholders);
  144.     }
  145. }
  147. /**
  148.  * A container builder preventing using methods that wouldn't have any effect from extensions.
  149.  *
  150.  * @internal
  151.  */
  152. class MergeExtensionConfigurationContainerBuilder extends ContainerBuilder
  153. {
  154.     private string $extensionClass;
  156.     public function __construct(ExtensionInterface $extension, ParameterBagInterface $parameterBag = null)
  157.     {
  158.         parent::__construct($parameterBag);
  160.         $this->extensionClass = $extension::class;
  161.     }
  163.     public function addCompilerPass(CompilerPassInterface $pass, string $type = PassConfig::TYPE_BEFORE_OPTIMIZATION, int $priority = 0): static
  164.     {
  165.         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));
  166.     }
  168.     public function registerExtension(ExtensionInterface $extension)
  169.     {
  170.         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));
  171.     }
  173.     public function compile(bool $resolveEnvPlaceholders = false)
  174.     {
  175.         throw new LogicException(sprintf('Cannot compile the container in extension "%s".', $this->extensionClass));
  176.     }
  178.     public function resolveEnvPlaceholders(mixed $value, string|bool $format = null, array &$usedEnvs = null): mixed
  179.     {
  180.         if (true !== $format || !\is_string($value)) {
  181.             return parent::resolveEnvPlaceholders($value, $format, $usedEnvs);
  182.         }
  184.         $bag = $this->getParameterBag();
  185.         $value = $bag->resolveValue($value);
  187.         if (!$bag instanceof EnvPlaceholderParameterBag) {
  188.             return parent::resolveEnvPlaceholders($value, $format, $usedEnvs);
  189.         }
  191.         foreach ($bag->getEnvPlaceholders() as $env => $placeholders) {
  192.             if (!str_contains($env, ':')) {
  193.                 continue;
  194.             }
  195.             foreach ($placeholders as $placeholder) {
  196.                 if (false !== stripos($value, $placeholder)) {
  197.                     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));
  198.                 }
  199.             }
  200.         }
  202.         return parent::resolveEnvPlaceholders($value, $format, $usedEnvs);
  203.     }
  204. }