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\Bundle\FrameworkBundle\DependencyInjection;
14. use Composer\InstalledVersions;
15. use Doctrine\Common\Annotations\Reader;
16. use Http\Client\HttpAsyncClient;
17. use Http\Client\HttpClient;
18. use phpDocumentor\Reflection\DocBlockFactoryInterface;
19. use phpDocumentor\Reflection\Types\ContextFactory;
20. use PhpParser\Parser;
21. use PHPStan\PhpDocParser\Parser\PhpDocParser;
22. use Psr\Cache\CacheItemPoolInterface;
23. use Psr\Clock\ClockInterface as PsrClockInterface;
24. use Psr\Container\ContainerInterface as PsrContainerInterface;
25. use Psr\Http\Client\ClientInterface;
26. use Psr\Log\LoggerAwareInterface;
27. use Symfony\Bridge\Monolog\Processor\DebugProcessor;
28. use Symfony\Bridge\Twig\Extension\CsrfExtension;
29. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
30. use Symfony\Bundle\FrameworkBundle\Routing\RouteLoaderInterface;
31. use Symfony\Bundle\FullStack;
32. use Symfony\Bundle\MercureBundle\MercureBundle;
33. use Symfony\Component\Asset\PackageInterface;
34. use Symfony\Component\AssetMapper\AssetMapper;
35. use Symfony\Component\AssetMapper\Compiler\AssetCompilerInterface;
36. use Symfony\Component\BrowserKit\AbstractBrowser;
37. use Symfony\Component\Cache\Adapter\AdapterInterface;
38. use Symfony\Component\Cache\Adapter\ArrayAdapter;
39. use Symfony\Component\Cache\Adapter\ChainAdapter;
40. use Symfony\Component\Cache\Adapter\TagAwareAdapter;
41. use Symfony\Component\Cache\DependencyInjection\CachePoolPass;
42. use Symfony\Component\Cache\Marshaller\MarshallerInterface;
43. use Symfony\Component\Cache\ResettableInterface;
44. use Symfony\Component\Clock\ClockInterface;
45. use Symfony\Component\Config\Definition\ConfigurationInterface;
46. use Symfony\Component\Config\FileLocator;
47. use Symfony\Component\Config\Loader\LoaderInterface;
48. use Symfony\Component\Config\Resource\DirectoryResource;
49. use Symfony\Component\Config\Resource\FileResource;
50. use Symfony\Component\Config\ResourceCheckerInterface;
51. use Symfony\Component\Console\Application;
52. use Symfony\Component\Console\Command\Command;
53. use Symfony\Component\Console\DataCollector\CommandDataCollector;
54. use Symfony\Component\Console\Debug\CliRequest;
55. use Symfony\Component\Console\Messenger\RunCommandMessageHandler;
56. use Symfony\Component\DependencyInjection\Alias;
57. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
58. use Symfony\Component\DependencyInjection\ChildDefinition;
59. use Symfony\Component\DependencyInjection\Compiler\ServiceLocatorTagPass;
60. use Symfony\Component\DependencyInjection\ContainerBuilder;
61. use Symfony\Component\DependencyInjection\ContainerInterface;
62. use Symfony\Component\DependencyInjection\Definition;
63. use Symfony\Component\DependencyInjection\EnvVarLoaderInterface;
64. use Symfony\Component\DependencyInjection\EnvVarProcessorInterface;
65. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
66. use Symfony\Component\DependencyInjection\Exception\LogicException;
67. use Symfony\Component\DependencyInjection\Loader\PhpFileLoader;
68. use Symfony\Component\DependencyInjection\Parameter;
69. use Symfony\Component\DependencyInjection\Reference;
70. use Symfony\Component\DependencyInjection\ServiceLocator;
71. use Symfony\Component\Dotenv\Command\DebugCommand;
72. use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
73. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
74. use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
75. use Symfony\Component\Finder\Finder;
76. use Symfony\Component\Finder\Glob;
77. use Symfony\Component\Form\Extension\HtmlSanitizer\Type\TextTypeHtmlSanitizerExtension;
78. use Symfony\Component\Form\Form;
79. use Symfony\Component\Form\FormTypeExtensionInterface;
80. use Symfony\Component\Form\FormTypeGuesserInterface;
81. use Symfony\Component\Form\FormTypeInterface;
82. use Symfony\Component\HtmlSanitizer\HtmlSanitizer;
83. use Symfony\Component\HtmlSanitizer\HtmlSanitizerConfig;
84. use Symfony\Component\HtmlSanitizer\HtmlSanitizerInterface;
85. use Symfony\Component\HttpClient\Messenger\PingWebhookMessageHandler;
86. use Symfony\Component\HttpClient\MockHttpClient;
87. use Symfony\Component\HttpClient\Retry\GenericRetryStrategy;
88. use Symfony\Component\HttpClient\RetryableHttpClient;
89. use Symfony\Component\HttpClient\ScopingHttpClient;
90. use Symfony\Component\HttpClient\UriTemplateHttpClient;
91. use Symfony\Component\HttpFoundation\Request;
92. use Symfony\Component\HttpKernel\Attribute\AsController;
93. use Symfony\Component\HttpKernel\Attribute\AsTargetedValueResolver;
94. use Symfony\Component\HttpKernel\CacheClearer\CacheClearerInterface;
95. use Symfony\Component\HttpKernel\CacheWarmer\CacheWarmerInterface;
96. use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
97. use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
98. use Symfony\Component\HttpKernel\DataCollector\DataCollectorInterface;
99. use Symfony\Component\HttpKernel\DependencyInjection\Extension;
100. use Symfony\Component\HttpKernel\Log\DebugLoggerConfigurator;
101. use Symfony\Component\Lock\LockFactory;
102. use Symfony\Component\Lock\LockInterface;
103. use Symfony\Component\Lock\PersistingStoreInterface;
104. use Symfony\Component\Lock\Store\StoreFactory;
105. use Symfony\Component\Mailer\Bridge as MailerBridge;
106. use Symfony\Component\Mailer\Command\MailerTestCommand;
107. use Symfony\Component\Mailer\EventListener\MessengerTransportListener;
108. use Symfony\Component\Mailer\Mailer;
109. use Symfony\Component\Mercure\HubRegistry;
110. use Symfony\Component\Messenger\Attribute\AsMessageHandler;
111. use Symfony\Component\Messenger\Bridge as MessengerBridge;
112. use Symfony\Component\Messenger\EventListener\StopWorkerOnSignalsListener;
113. use Symfony\Component\Messenger\Handler\BatchHandlerInterface;
114. use Symfony\Component\Messenger\Handler\MessageHandlerInterface;
115. use Symfony\Component\Messenger\MessageBus;
116. use Symfony\Component\Messenger\MessageBusInterface;
117. use Symfony\Component\Messenger\Middleware\RouterContextMiddleware;
118. use Symfony\Component\Messenger\Transport\Serialization\SerializerInterface;
119. use Symfony\Component\Messenger\Transport\TransportFactoryInterface as MessengerTransportFactoryInterface;
120. use Symfony\Component\Messenger\Transport\TransportInterface;
121. use Symfony\Component\Mime\Header\Headers;
122. use Symfony\Component\Mime\MimeTypeGuesserInterface;
123. use Symfony\Component\Mime\MimeTypes;
124. use Symfony\Component\Notifier\Bridge as NotifierBridge;
125. use Symfony\Component\Notifier\ChatterInterface;
126. use Symfony\Component\Notifier\Notifier;
127. use Symfony\Component\Notifier\Recipient\Recipient;
128. use Symfony\Component\Notifier\TexterInterface;
129. use Symfony\Component\Notifier\Transport\TransportFactoryInterface as NotifierTransportFactoryInterface;
130. use Symfony\Component\Process\Messenger\RunProcessMessageHandler;
131. use Symfony\Component\PropertyAccess\PropertyAccessor;
132. use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
133. use Symfony\Component\PropertyInfo\Extractor\PhpStanExtractor;
134. use Symfony\Component\PropertyInfo\PropertyAccessExtractorInterface;
135. use Symfony\Component\PropertyInfo\PropertyDescriptionExtractorInterface;
136. use Symfony\Component\PropertyInfo\PropertyInfoExtractorInterface;
137. use Symfony\Component\PropertyInfo\PropertyInitializableExtractorInterface;
138. use Symfony\Component\PropertyInfo\PropertyListExtractorInterface;
139. use Symfony\Component\PropertyInfo\PropertyReadInfoExtractorInterface;
140. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
141. use Symfony\Component\PropertyInfo\PropertyWriteInfoExtractorInterface;
142. use Symfony\Component\RateLimiter\LimiterInterface;
143. use Symfony\Component\RateLimiter\RateLimiterFactory;
144. use Symfony\Component\RateLimiter\Storage\CacheStorage;
145. use Symfony\Component\RemoteEvent\Attribute\AsRemoteEventConsumer;
146. use Symfony\Component\RemoteEvent\RemoteEvent;
147. use Symfony\Component\Routing\Loader\AttributeClassLoader;
148. use Symfony\Component\Scheduler\Attribute\AsCronTask;
149. use Symfony\Component\Scheduler\Attribute\AsPeriodicTask;
150. use Symfony\Component\Scheduler\Attribute\AsSchedule;
151. use Symfony\Component\Scheduler\Messenger\SchedulerTransportFactory;
152. use Symfony\Component\Security\Core\AuthenticationEvents;
153. use Symfony\Component\Security\Core\Exception\AuthenticationException;
154. use Symfony\Component\Security\Csrf\CsrfTokenManagerInterface;
155. use Symfony\Component\Semaphore\PersistingStoreInterface as SemaphoreStoreInterface;
156. use Symfony\Component\Semaphore\Semaphore;
157. use Symfony\Component\Semaphore\SemaphoreFactory;
158. use Symfony\Component\Semaphore\Store\StoreFactory as SemaphoreStoreFactory;
159. use Symfony\Component\Serializer\Encoder\DecoderInterface;
160. use Symfony\Component\Serializer\Encoder\EncoderInterface;
161. use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader;
162. use Symfony\Component\Serializer\Mapping\Loader\XmlFileLoader;
163. use Symfony\Component\Serializer\Mapping\Loader\YamlFileLoader;
164. use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
165. use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
166. use Symfony\Component\Serializer\Serializer;
167. use Symfony\Component\Stopwatch\Stopwatch;
168. use Symfony\Component\String\LazyString;
169. use Symfony\Component\String\Slugger\SluggerInterface;
170. use Symfony\Component\Translation\Bridge as TranslationBridge;
171. use Symfony\Component\Translation\Command\XliffLintCommand as BaseXliffLintCommand;
172. use Symfony\Component\Translation\Extractor\PhpAstExtractor;
173. use Symfony\Component\Translation\LocaleSwitcher;
174. use Symfony\Component\Translation\PseudoLocalizationTranslator;
175. use Symfony\Component\Translation\Translator;
176. use Symfony\Component\Uid\Factory\UuidFactory;
177. use Symfony\Component\Uid\UuidV4;
178. use Symfony\Component\Validator\Constraints\ExpressionLanguageProvider;
179. use Symfony\Component\Validator\ConstraintValidatorInterface;
180. use Symfony\Component\Validator\GroupProviderInterface;
181. use Symfony\Component\Validator\Mapping\Loader\PropertyInfoLoader;
182. use Symfony\Component\Validator\ObjectInitializerInterface;
183. use Symfony\Component\Validator\Validation;
184. use Symfony\Component\Validator\ValidatorBuilder;
185. use Symfony\Component\Webhook\Controller\WebhookController;
186. use Symfony\Component\WebLink\HttpHeaderSerializer;
187. use Symfony\Component\Workflow;
188. use Symfony\Component\Workflow\WorkflowInterface;
189. use Symfony\Component\Yaml\Command\LintCommand as BaseYamlLintCommand;
190. use Symfony\Component\Yaml\Yaml;
191. use Symfony\Contracts\Cache\CacheInterface;
192. use Symfony\Contracts\Cache\CallbackInterface;
193. use Symfony\Contracts\Cache\TagAwareCacheInterface;
194. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
195. use Symfony\Contracts\HttpClient\HttpClientInterface;
196. use Symfony\Contracts\Service\ResetInterface;
197. use Symfony\Contracts\Service\ServiceSubscriberInterface;
198. use Symfony\Contracts\Translation\LocaleAwareInterface;
200. /**
201.  * Process the configuration and prepare the dependency injection container with
202.  * parameters and services.
203.  */
204. class FrameworkExtension extends Extension
205. {
206.     private array $configsEnabled = [];
208.     /**
209.      * Responds to the app.config configuration parameter.
210.      *
211.      * @return void
212.      *
213.      * @throws LogicException
214.      */
215.     public function load(array $configs, ContainerBuilder $container)
216.     {
217.         $loader = new PhpFileLoader($container, new FileLocator(\dirname(__DIR__).'/Resources/config'));
219.         if (class_exists(InstalledVersions::class) && InstalledVersions::isInstalled('symfony/symfony') && 'symfony/symfony' !== (InstalledVersions::getRootPackage()['name'] ?? '')) {
220.             trigger_deprecation('symfony/symfony', '6.1', 'Requiring the "symfony/symfony" package is deprecated; replace it with standalone components instead.');
221.         }
223.         $loader->load('web.php');
224.         $loader->load('services.php');
225.         $loader->load('fragment_renderer.php');
226.         $loader->load('error_renderer.php');
228.         if (!ContainerBuilder::willBeAvailable('symfony/clock', ClockInterface::class, ['symfony/framework-bundle'])) {
229.             $container->removeDefinition('clock');
230.             $container->removeAlias(ClockInterface::class);
231.             $container->removeAlias(PsrClockInterface::class);
232.         }
234.         $container->registerAliasForArgument('parameter_bag', PsrContainerInterface::class);
236.         $loader->load('process.php');
238.         if (!class_exists(RunProcessMessageHandler::class)) {
239.             $container->removeDefinition('process.messenger.process_message_handler');
240.         }
242.         if ($this->hasConsole()) {
243.             $loader->load('console.php');
245.             if (!class_exists(BaseXliffLintCommand::class)) {
246.                 $container->removeDefinition('console.command.xliff_lint');
247.             }
248.             if (!class_exists(BaseYamlLintCommand::class)) {
249.                 $container->removeDefinition('console.command.yaml_lint');
250.             }
252.             if (!class_exists(DebugCommand::class)) {
253.                 $container->removeDefinition('console.command.dotenv_debug');
254.             }
256.             if (!class_exists(RunCommandMessageHandler::class)) {
257.                 $container->removeDefinition('console.messenger.application');
258.                 $container->removeDefinition('console.messenger.execute_command_handler');
259.             }
260.         }
262.         // Load Cache configuration first as it is used by other components
263.         $loader->load('cache.php');
265.         $configuration = $this->getConfiguration($configs, $container);
266.         $config = $this->processConfiguration($configuration, $configs);
268.         // warmup config enabled
269.         $this->readConfigEnabled('annotations', $container, $config['annotations']);
270.         $this->readConfigEnabled('translator', $container, $config['translator']);
271.         $this->readConfigEnabled('property_access', $container, $config['property_access']);
272.         $this->readConfigEnabled('profiler', $container, $config['profiler']);
273.         $this->readConfigEnabled('workflows', $container, $config['workflows']);
275.         // A translator must always be registered (as support is included by
276.         // default in the Form and Validator component). If disabled, an identity
277.         // translator will be used and everything will still work as expected.
278.         if ($this->readConfigEnabled('translator', $container, $config['translator']) || $this->readConfigEnabled('form', $container, $config['form']) || $this->readConfigEnabled('validation', $container, $config['validation'])) {
279.             if (!class_exists(Translator::class) && $this->readConfigEnabled('translator', $container, $config['translator'])) {
280.                 throw new LogicException('Translation support cannot be enabled as the Translation component is not installed. Try running "composer require symfony/translation".');
281.             }
283.             if (class_exists(Translator::class)) {
284.                 $loader->load('identity_translator.php');
285.             }
286.         }
288.         $container->getDefinition('locale_listener')->replaceArgument(3, $config['set_locale_from_accept_language']);
289.         $container->getDefinition('response_listener')->replaceArgument(1, $config['set_content_language_from_locale']);
290.         $container->getDefinition('http_kernel')->replaceArgument(4, $config['handle_all_throwables'] ?? false);
292.         // If the slugger is used but the String component is not available, we should throw an error
293.         if (!ContainerBuilder::willBeAvailable('symfony/string', SluggerInterface::class, ['symfony/framework-bundle'])) {
294.             $container->register('slugger', SluggerInterface::class)
295.                 ->addError('You cannot use the "slugger" service since the String component is not installed. Try running "composer require symfony/string".');
296.         } else {
297.             if (!ContainerBuilder::willBeAvailable('symfony/translation', LocaleAwareInterface::class, ['symfony/framework-bundle'])) {
298.                 $container->register('slugger', SluggerInterface::class)
299.                     ->addError('You cannot use the "slugger" service since the Translation contracts are not installed. Try running "composer require symfony/translation".');
300.             }
302.             if (!\extension_loaded('intl') && !\defined('PHPUNIT_COMPOSER_INSTALL')) {
303.                 trigger_deprecation('', '', 'Please install the "intl" PHP extension for best performance.');
304.             }
305.         }
307.         if (isset($config['secret'])) {
308.             $container->setParameter('kernel.secret', $config['secret']);
309.         }
311.         $container->setParameter('kernel.http_method_override', $config['http_method_override']);
312.         $container->setParameter('kernel.trust_x_sendfile_type_header', $config['trust_x_sendfile_type_header']);
313.         $container->setParameter('kernel.trusted_hosts', $config['trusted_hosts']);
314.         $container->setParameter('kernel.default_locale', $config['default_locale']);
315.         $container->setParameter('kernel.enabled_locales', $config['enabled_locales']);
316.         $container->setParameter('kernel.error_controller', $config['error_controller']);
318.         if (($config['trusted_proxies'] ?? false) && ($config['trusted_headers'] ?? false)) {
319.             $container->setParameter('kernel.trusted_proxies', $config['trusted_proxies']);
320.             $container->setParameter('kernel.trusted_headers', $this->resolveTrustedHeaders($config['trusted_headers']));
321.         }
323.         if (!$container->hasParameter('debug.file_link_format')) {
324.             $container->setParameter('debug.file_link_format', $config['ide']);
325.         }
327.         if (!empty($config['test'])) {
328.             $loader->load('test.php');
330.             if (!class_exists(AbstractBrowser::class)) {
331.                 $container->removeDefinition('test.client');
332.             }
333.         }
335.         if ($this->readConfigEnabled('request', $container, $config['request'])) {
336.             $this->registerRequestConfiguration($config['request'], $container, $loader);
337.         }
339.         if ($this->readConfigEnabled('assets', $container, $config['assets'])) {
340.             if (!class_exists(\Symfony\Component\Asset\Package::class)) {
341.                 throw new LogicException('Asset support cannot be enabled as the Asset component is not installed. Try running "composer require symfony/asset".');
342.             }
344.             $this->registerAssetsConfiguration($config['assets'], $container, $loader);
345.         }
347.         if ($this->readConfigEnabled('asset_mapper', $container, $config['asset_mapper'])) {
348.             if (!class_exists(AssetMapper::class)) {
349.                 throw new LogicException('AssetMapper support cannot be enabled as the AssetMapper component is not installed. Try running "composer require symfony/asset-mapper".');
350.             }
352.             $this->registerAssetMapperConfiguration($config['asset_mapper'], $container, $loader, $this->readConfigEnabled('assets', $container, $config['assets']));
353.         } else {
354.             $container->removeDefinition('cache.asset_mapper');
355.         }
357.         if ($this->readConfigEnabled('http_client', $container, $config['http_client'])) {
358.             $this->registerHttpClientConfiguration($config['http_client'], $container, $loader);
359.         }
361.         if ($this->readConfigEnabled('mailer', $container, $config['mailer'])) {
362.             $this->registerMailerConfiguration($config['mailer'], $container, $loader, $this->readConfigEnabled('webhook', $container, $config['webhook']));
364.             if (!$this->hasConsole() || !class_exists(MailerTestCommand::class)) {
365.                 $container->removeDefinition('console.command.mailer_test');
366.             }
367.         }
369.         $propertyInfoEnabled = $this->readConfigEnabled('property_info', $container, $config['property_info']);
370.         $this->registerHttpCacheConfiguration($config['http_cache'], $container, $config['http_method_override']);
371.         $this->registerEsiConfiguration($config['esi'], $container, $loader);
372.         $this->registerSsiConfiguration($config['ssi'], $container, $loader);
373.         $this->registerFragmentsConfiguration($config['fragments'], $container, $loader);
374.         $this->registerTranslatorConfiguration($config['translator'], $container, $loader, $config['default_locale'], $config['enabled_locales']);
375.         $this->registerWorkflowConfiguration($config['workflows'], $container, $loader);
376.         $this->registerDebugConfiguration($config['php_errors'], $container, $loader);
377.         $this->registerRouterConfiguration($config['router'], $container, $loader, $config['enabled_locales']);
378.         $this->registerAnnotationsConfiguration($config['annotations'], $container, $loader);
379.         $this->registerPropertyAccessConfiguration($config['property_access'], $container, $loader);
380.         $this->registerSecretsConfiguration($config['secrets'], $container, $loader);
382.         $container->getDefinition('exception_listener')->replaceArgument(3, $config['exceptions']);
384.         if ($this->readConfigEnabled('serializer', $container, $config['serializer'])) {
385.             if (!class_exists(Serializer::class)) {
386.                 throw new LogicException('Serializer support cannot be enabled as the Serializer component is not installed. Try running "composer require symfony/serializer-pack".');
387.             }
389.             $this->registerSerializerConfiguration($config['serializer'], $container, $loader);
390.         } else {
391.             $container->getDefinition('argument_resolver.request_payload')
392.                 ->setArguments([])
393.                 ->addError('You can neither use "#[MapRequestPayload]" nor "#[MapQueryString]" since the Serializer component is not '
394.                     .(class_exists(Serializer::class) ? 'enabled. Try setting "framework.serializer.enabled" to true.' : 'installed. Try running "composer require symfony/serializer-pack".')
395.                 )
396.                 ->addTag('container.error')
397.                 ->clearTag('kernel.event_subscriber');
399.             $container->removeDefinition('console.command.serializer_debug');
400.         }
402.         if ($propertyInfoEnabled) {
403.             $this->registerPropertyInfoConfiguration($container, $loader);
404.         }
406.         if ($this->readConfigEnabled('lock', $container, $config['lock'])) {
407.             $this->registerLockConfiguration($config['lock'], $container, $loader);
408.         }
410.         if ($this->readConfigEnabled('semaphore', $container, $config['semaphore'])) {
411.             $this->registerSemaphoreConfiguration($config['semaphore'], $container, $loader);
412.         }
414.         if ($this->readConfigEnabled('rate_limiter', $container, $config['rate_limiter'])) {
415.             if (!interface_exists(LimiterInterface::class)) {
416.                 throw new LogicException('Rate limiter support cannot be enabled as the RateLimiter component is not installed. Try running "composer require symfony/rate-limiter".');
417.             }
419.             $this->registerRateLimiterConfiguration($config['rate_limiter'], $container, $loader);
420.         }
422.         if ($this->readConfigEnabled('web_link', $container, $config['web_link'])) {
423.             if (!class_exists(HttpHeaderSerializer::class)) {
424.                 throw new LogicException('WebLink support cannot be enabled as the WebLink component is not installed. Try running "composer require symfony/weblink".');
425.             }
427.             $loader->load('web_link.php');
428.         }
430.         if ($this->readConfigEnabled('uid', $container, $config['uid'])) {
431.             if (!class_exists(UuidFactory::class)) {
432.                 throw new LogicException('Uid support cannot be enabled as the Uid component is not installed. Try running "composer require symfony/uid".');
433.             }
435.             $this->registerUidConfiguration($config['uid'], $container, $loader);
436.         } else {
437.             $container->removeDefinition('argument_resolver.uid');
438.         }
440.         // register cache before session so both can share the connection services
441.         $this->registerCacheConfiguration($config['cache'], $container);
443.         if ($this->readConfigEnabled('session', $container, $config['session'])) {
444.             if (!\extension_loaded('session')) {
445.                 throw new LogicException('Session support cannot be enabled as the session extension is not installed. See https://php.net/session.installation for instructions.');
446.             }
448.             $this->registerSessionConfiguration($config['session'], $container, $loader);
449.             if (!empty($config['test'])) {
450.                 // test listener will replace the existing session listener
451.                 // as we are aliasing to avoid duplicated registered events
452.                 $container->setAlias('session_listener', 'test.session.listener');
453.             }
454.         } elseif (!empty($config['test'])) {
455.             $container->removeDefinition('test.session.listener');
456.         }
458.         // csrf depends on session being registered
459.         if (null === $config['csrf_protection']['enabled']) {
460.             $this->writeConfigEnabled('csrf_protection', $this->readConfigEnabled('session', $container, $config['session']) && !class_exists(FullStack::class) && ContainerBuilder::willBeAvailable('symfony/security-csrf', CsrfTokenManagerInterface::class, ['symfony/framework-bundle']), $config['csrf_protection']);
461.         }
462.         $this->registerSecurityCsrfConfiguration($config['csrf_protection'], $container, $loader);
464.         // form depends on csrf being registered
465.         if ($this->readConfigEnabled('form', $container, $config['form'])) {
466.             if (!class_exists(Form::class)) {
467.                 throw new LogicException('Form support cannot be enabled as the Form component is not installed. Try running "composer require symfony/form".');
468.             }
470.             $this->registerFormConfiguration($config, $container, $loader);
472.             if (ContainerBuilder::willBeAvailable('symfony/validator', Validation::class, ['symfony/framework-bundle', 'symfony/form'])) {
473.                 $this->writeConfigEnabled('validation', true, $config['validation']);
474.             } else {
475.                 $container->setParameter('validator.translation_domain', 'validators');
477.                 $container->removeDefinition('form.type_extension.form.validator');
478.                 $container->removeDefinition('form.type_guesser.validator');
479.             }
480.             if (!$this->readConfigEnabled('html_sanitizer', $container, $config['html_sanitizer']) || !class_exists(TextTypeHtmlSanitizerExtension::class)) {
481.                 $container->removeDefinition('form.type_extension.form.html_sanitizer');
482.             }
483.         } else {
484.             $container->removeDefinition('console.command.form_debug');
485.         }
487.         // validation depends on form, annotations being registered
488.         $this->registerValidationConfiguration($config['validation'], $container, $loader, $propertyInfoEnabled);
490.         $messengerEnabled = $this->readConfigEnabled('messenger', $container, $config['messenger']);
492.         if ($this->readConfigEnabled('scheduler', $container, $config['scheduler'])) {
493.             if (!$messengerEnabled) {
494.                 throw new LogicException('Scheduler support cannot be enabled as the Messenger component is not '.(interface_exists(MessageBusInterface::class) ? 'enabled.' : 'installed. Try running "composer require symfony/messenger".'));
495.             }
496.             $this->registerSchedulerConfiguration($config['scheduler'], $container, $loader);
497.         } else {
498.             $container->removeDefinition('cache.scheduler');
499.             $container->removeDefinition('console.command.scheduler_debug');
500.         }
502.         // messenger depends on validation being registered
503.         if ($messengerEnabled) {
504.             $this->registerMessengerConfiguration($config['messenger'], $container, $loader, $this->readConfigEnabled('validation', $container, $config['validation']));
505.         } else {
506.             $container->removeDefinition('console.command.messenger_consume_messages');
507.             $container->removeDefinition('console.command.messenger_stats');
508.             $container->removeDefinition('console.command.messenger_debug');
509.             $container->removeDefinition('console.command.messenger_stop_workers');
510.             $container->removeDefinition('console.command.messenger_setup_transports');
511.             $container->removeDefinition('console.command.messenger_failed_messages_retry');
512.             $container->removeDefinition('console.command.messenger_failed_messages_show');
513.             $container->removeDefinition('console.command.messenger_failed_messages_remove');
514.             $container->removeDefinition('cache.messenger.restart_workers_signal');
516.             if ($container->hasDefinition('messenger.transport.amqp.factory') && !class_exists(MessengerBridge\Amqp\Transport\AmqpTransportFactory::class)) {
517.                 if (class_exists(\Symfony\Component\Messenger\Transport\AmqpExt\AmqpTransportFactory::class)) {
518.                     $container->getDefinition('messenger.transport.amqp.factory')
519.                         ->setClass(\Symfony\Component\Messenger\Transport\AmqpExt\AmqpTransportFactory::class)
520.                         ->addTag('messenger.transport_factory');
521.                 } else {
522.                     $container->removeDefinition('messenger.transport.amqp.factory');
523.                 }
524.             }
526.             if ($container->hasDefinition('messenger.transport.redis.factory') && !class_exists(MessengerBridge\Redis\Transport\RedisTransportFactory::class)) {
527.                 if (class_exists(\Symfony\Component\Messenger\Transport\RedisExt\RedisTransportFactory::class)) {
528.                     $container->getDefinition('messenger.transport.redis.factory')
529.                         ->setClass(\Symfony\Component\Messenger\Transport\RedisExt\RedisTransportFactory::class)
530.                         ->addTag('messenger.transport_factory');
531.                 } else {
532.                     $container->removeDefinition('messenger.transport.redis.factory');
533.                 }
534.             }
535.         }
537.         // notifier depends on messenger, mailer being registered
538.         if ($this->readConfigEnabled('notifier', $container, $config['notifier'])) {
539.             $this->registerNotifierConfiguration($config['notifier'], $container, $loader, $this->readConfigEnabled('webhook', $container, $config['webhook']));
540.         }
542.         // profiler depends on form, validation, translation, messenger, mailer, http-client, notifier, serializer being registered
543.         $this->registerProfilerConfiguration($config['profiler'], $container, $loader);
545.         if ($this->readConfigEnabled('webhook', $container, $config['webhook'])) {
546.             $this->registerWebhookConfiguration($config['webhook'], $container, $loader);
548.             // If Webhook is installed but the HttpClient or Serializer components are not available, we should throw an error
549.             if (!$this->readConfigEnabled('http_client', $container, $config['http_client'])) {
550.                 $container->getDefinition('webhook.transport')
551.                     ->setArguments([])
552.                     ->addError('You cannot use the "webhook transport" service since the HttpClient component is not '
553.                         .(class_exists(ScopingHttpClient::class) ? 'enabled. Try setting "framework.http_client.enabled" to true.' : 'installed. Try running "composer require symfony/http-client".')
554.                     )
555.                     ->addTag('container.error');
556.             }
557.             if (!$this->readConfigEnabled('serializer', $container, $config['serializer'])) {
558.                 $container->getDefinition('webhook.body_configurator.json')
559.                     ->setArguments([])
560.                     ->addError('You cannot use the "webhook transport" service since the Serializer component is not '
561.                         .(class_exists(Serializer::class) ? 'enabled. Try setting "framework.serializer.enabled" to true.' : 'installed. Try running "composer require symfony/serializer-pack".')
562.                     )
563.                     ->addTag('container.error');
564.             }
565.         }
567.         if ($this->readConfigEnabled('remote-event', $container, $config['remote-event'])) {
568.             $this->registerRemoteEventConfiguration($config['remote-event'], $container, $loader);
569.         }
571.         if ($this->readConfigEnabled('html_sanitizer', $container, $config['html_sanitizer'])) {
572.             if (!class_exists(HtmlSanitizerConfig::class)) {
573.                 throw new LogicException('HtmlSanitizer support cannot be enabled as the HtmlSanitizer component is not installed. Try running "composer require symfony/html-sanitizer".');
574.             }
576.             $this->registerHtmlSanitizerConfiguration($config['html_sanitizer'], $container, $loader);
577.         }
579.         $this->addAnnotatedClassesToCompile([
580.             '**\\Controller\\',
581.             '**\\Entity\\',
583.             // Added explicitly so that we don't rely on the class map being dumped to make it work
584.             AbstractController::class,
585.         ]);
587.         if (ContainerBuilder::willBeAvailable('symfony/mime', MimeTypes::class, ['symfony/framework-bundle'])) {
588.             $loader->load('mime_type.php');
589.         }
591.         $container->registerForAutoconfiguration(PackageInterface::class)
592.             ->addTag('assets.package');
593.         $container->registerForAutoconfiguration(AssetCompilerInterface::class)
594.             ->addTag('asset_mapper.compiler');
595.         $container->registerForAutoconfiguration(Command::class)
596.             ->addTag('console.command');
597.         $container->registerForAutoconfiguration(ResourceCheckerInterface::class)
598.             ->addTag('config_cache.resource_checker');
599.         $container->registerForAutoconfiguration(EnvVarLoaderInterface::class)
600.             ->addTag('container.env_var_loader');
601.         $container->registerForAutoconfiguration(EnvVarProcessorInterface::class)
602.             ->addTag('container.env_var_processor');
603.         $container->registerForAutoconfiguration(CallbackInterface::class)
604.             ->addTag('container.reversible');
605.         $container->registerForAutoconfiguration(ServiceLocator::class)
606.             ->addTag('container.service_locator');
607.         $container->registerForAutoconfiguration(ServiceSubscriberInterface::class)
608.             ->addTag('container.service_subscriber');
609.         $container->registerForAutoconfiguration(ArgumentValueResolverInterface::class)
610.             ->addTag('controller.argument_value_resolver');
611.         $container->registerForAutoconfiguration(ValueResolverInterface::class)
612.             ->addTag('controller.argument_value_resolver');
613.         $container->registerForAutoconfiguration(AbstractController::class)
614.             ->addTag('controller.service_arguments');
615.         $container->registerForAutoconfiguration(DataCollectorInterface::class)
616.             ->addTag('data_collector');
617.         $container->registerForAutoconfiguration(FormTypeInterface::class)
618.             ->addTag('form.type');
619.         $container->registerForAutoconfiguration(FormTypeGuesserInterface::class)
620.             ->addTag('form.type_guesser');
621.         $container->registerForAutoconfiguration(FormTypeExtensionInterface::class)
622.             ->addTag('form.type_extension');
623.         $container->registerForAutoconfiguration(CacheClearerInterface::class)
624.             ->addTag('kernel.cache_clearer');
625.         $container->registerForAutoconfiguration(CacheWarmerInterface::class)
626.             ->addTag('kernel.cache_warmer');
627.         $container->registerForAutoconfiguration(EventDispatcherInterface::class)
628.             ->addTag('event_dispatcher.dispatcher');
629.         $container->registerForAutoconfiguration(EventSubscriberInterface::class)
630.             ->addTag('kernel.event_subscriber');
631.         $container->registerForAutoconfiguration(LocaleAwareInterface::class)
632.             ->addTag('kernel.locale_aware');
633.         $container->registerForAutoconfiguration(ResetInterface::class)
634.             ->addTag('kernel.reset', ['method' => 'reset']);
636.         if (!interface_exists(MarshallerInterface::class)) {
637.             $container->registerForAutoconfiguration(ResettableInterface::class)
638.                 ->addTag('kernel.reset', ['method' => 'reset']);
639.         }
641.         $container->registerForAutoconfiguration(PropertyListExtractorInterface::class)
642.             ->addTag('property_info.list_extractor');
643.         $container->registerForAutoconfiguration(PropertyTypeExtractorInterface::class)
644.             ->addTag('property_info.type_extractor');
645.         $container->registerForAutoconfiguration(PropertyDescriptionExtractorInterface::class)
646.             ->addTag('property_info.description_extractor');
647.         $container->registerForAutoconfiguration(PropertyAccessExtractorInterface::class)
648.             ->addTag('property_info.access_extractor');
649.         $container->registerForAutoconfiguration(PropertyInitializableExtractorInterface::class)
650.             ->addTag('property_info.initializable_extractor');
651.         $container->registerForAutoconfiguration(EncoderInterface::class)
652.             ->addTag('serializer.encoder');
653.         $container->registerForAutoconfiguration(DecoderInterface::class)
654.             ->addTag('serializer.encoder');
655.         $container->registerForAutoconfiguration(NormalizerInterface::class)
656.             ->addTag('serializer.normalizer');
657.         $container->registerForAutoconfiguration(DenormalizerInterface::class)
658.             ->addTag('serializer.normalizer');
659.         $container->registerForAutoconfiguration(ConstraintValidatorInterface::class)
660.             ->addTag('validator.constraint_validator');
661.         $container->registerForAutoconfiguration(GroupProviderInterface::class)
662.             ->addTag('validator.group_provider');
663.         $container->registerForAutoconfiguration(ObjectInitializerInterface::class)
664.             ->addTag('validator.initializer');
665.         $container->registerForAutoconfiguration(MessageHandlerInterface::class)
666.             ->addTag('messenger.message_handler');
667.         $container->registerForAutoconfiguration(BatchHandlerInterface::class)
668.             ->addTag('messenger.message_handler');
669.         $container->registerForAutoconfiguration(MessengerTransportFactoryInterface::class)
670.             ->addTag('messenger.transport_factory');
671.         $container->registerForAutoconfiguration(MimeTypeGuesserInterface::class)
672.             ->addTag('mime.mime_type_guesser');
673.         $container->registerForAutoconfiguration(LoggerAwareInterface::class)
674.             ->addMethodCall('setLogger', [new Reference('logger')]);
676.         $container->registerAttributeForAutoconfiguration(AsEventListener::class, static function (ChildDefinition $definition, AsEventListener $attribute, \ReflectionClass|\ReflectionMethod $reflector) {
677.             $tagAttributes = get_object_vars($attribute);
678.             if ($reflector instanceof \ReflectionMethod) {
679.                 if (isset($tagAttributes['method'])) {
680.                     throw new LogicException(sprintf('AsEventListener attribute cannot declare a method on "%s::%s()".', $reflector->class, $reflector->name));
681.                 }
682.                 $tagAttributes['method'] = $reflector->getName();
683.             }
684.             $definition->addTag('kernel.event_listener', $tagAttributes);
685.         });
686.         $container->registerAttributeForAutoconfiguration(AsController::class, static function (ChildDefinition $definition, AsController $attribute): void {
687.             $definition->addTag('controller.service_arguments');
688.         });
689.         $container->registerAttributeForAutoconfiguration(AsRemoteEventConsumer::class, static function (ChildDefinition $definition, AsRemoteEventConsumer $attribute): void {
690.             $definition->addTag('remote_event.consumer', ['consumer' => $attribute->name]);
691.         });
692.         $container->registerAttributeForAutoconfiguration(AsMessageHandler::class, static function (ChildDefinition $definition, AsMessageHandler $attribute, \ReflectionClass|\ReflectionMethod $reflector): void {
693.             $tagAttributes = get_object_vars($attribute);
694.             $tagAttributes['from_transport'] = $tagAttributes['fromTransport'];
695.             unset($tagAttributes['fromTransport']);
696.             if ($reflector instanceof \ReflectionMethod) {
697.                 if (isset($tagAttributes['method'])) {
698.                     throw new LogicException(sprintf('AsMessageHandler attribute cannot declare a method on "%s::%s()".', $reflector->class, $reflector->name));
699.                 }
700.                 $tagAttributes['method'] = $reflector->getName();
701.             }
702.             $definition->addTag('messenger.message_handler', $tagAttributes);
703.         });
704.         $container->registerAttributeForAutoconfiguration(AsTargetedValueResolver::class, static function (ChildDefinition $definition, AsTargetedValueResolver $attribute): void {
705.             $definition->addTag('controller.targeted_value_resolver', $attribute->name ? ['name' => $attribute->name] : []);
706.         });
707.         $container->registerAttributeForAutoconfiguration(AsSchedule::class, static function (ChildDefinition $definition, AsSchedule $attribute): void {
708.             $definition->addTag('scheduler.schedule_provider', ['name' => $attribute->name]);
709.         });
710.         foreach ([AsPeriodicTask::class, AsCronTask::class] as $taskAttributeClass) {
711.             $container->registerAttributeForAutoconfiguration(
712.                 $taskAttributeClass,
713.                 static function (ChildDefinition $definition, AsPeriodicTask|AsCronTask $attribute, \ReflectionClass|\ReflectionMethod $reflector): void {
714.                     $tagAttributes = get_object_vars($attribute) + [
715.                         'trigger' => match ($attribute::class) {
716.                             AsPeriodicTask::class => 'every',
717.                             AsCronTask::class => 'cron',
718.                         },
719.                     ];
720.                     if ($reflector instanceof \ReflectionMethod) {
721.                         if (isset($tagAttributes['method'])) {
722.                             throw new LogicException(sprintf('"%s" attribute cannot declare a method on "%s::%s()".', $attribute::class, $reflector->class, $reflector->name));
723.                         }
724.                         $tagAttributes['method'] = $reflector->getName();
725.                     }
726.                     $definition->addTag('scheduler.task', $tagAttributes);
727.                 }
728.             );
729.         }
731.         if (!$container->getParameter('kernel.debug')) {
732.             // remove tagged iterator argument for resource checkers
733.             $container->getDefinition('config_cache_factory')->setArguments([]);
734.         }
736.         if (!$config['disallow_search_engine_index'] ?? false) {
737.             $container->removeDefinition('disallow_search_engine_index_response_listener');
738.         }
740.         $container->registerForAutoconfiguration(RouteLoaderInterface::class)
741.             ->addTag('routing.route_loader');
743.         $container->setParameter('container.behavior_describing_tags', [
744.             'annotations.cached_reader',
745.             'container.do_not_inline',
746.             'container.service_locator',
747.             'container.service_subscriber',
748.             'kernel.event_subscriber',
749.             'kernel.event_listener',
750.             'kernel.locale_aware',
751.             'kernel.reset',
752.         ]);
753.     }
755.     public function getConfiguration(array $config, ContainerBuilder $container): ?ConfigurationInterface
756.     {
757.         return new Configuration($container->getParameter('kernel.debug'));
758.     }
760.     protected function hasConsole(): bool
761.     {
762.         return class_exists(Application::class);
763.     }
765.     private function registerFormConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
766.     {
767.         $loader->load('form.php');
769.         if (null === $config['form']['csrf_protection']['enabled']) {
770.             $this->writeConfigEnabled('form.csrf_protection', $config['csrf_protection']['enabled'], $config['form']['csrf_protection']);
771.         }
773.         if ($this->readConfigEnabled('form.csrf_protection', $container, $config['form']['csrf_protection'])) {
774.             if (!$container->hasDefinition('security.csrf.token_generator')) {
775.                 throw new \LogicException('To use form CSRF protection, "framework.csrf_protection" must be enabled.');
776.             }
778.             $loader->load('form_csrf.php');
780.             $container->setParameter('form.type_extension.csrf.enabled', true);
781.             $container->setParameter('form.type_extension.csrf.field_name', $config['form']['csrf_protection']['field_name']);
782.         } else {
783.             $container->setParameter('form.type_extension.csrf.enabled', false);
784.         }
786.         if (!ContainerBuilder::willBeAvailable('symfony/translation', Translator::class, ['symfony/framework-bundle', 'symfony/form'])) {
787.             $container->removeDefinition('form.type_extension.upload.validator');
788.         }
789.     }
791.     private function registerHttpCacheConfiguration(array $config, ContainerBuilder $container, bool $httpMethodOverride): void
792.     {
793.         $options = $config;
794.         unset($options['enabled']);
796.         if (!$options['private_headers']) {
797.             unset($options['private_headers']);
798.         }
800.         if (!$options['skip_response_headers']) {
801.             unset($options['skip_response_headers']);
802.         }
804.         $container->getDefinition('http_cache')
805.             ->setPublic($config['enabled'])
806.             ->replaceArgument(3, $options);
808.         if ($httpMethodOverride) {
809.             $container->getDefinition('http_cache')
810.                   ->addArgument((new Definition('void'))
811.                       ->setFactory([Request::class, 'enableHttpMethodParameterOverride'])
812.                   );
813.         }
814.     }
816.     private function registerEsiConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
817.     {
818.         if (!$this->readConfigEnabled('esi', $container, $config)) {
819.             $container->removeDefinition('fragment.renderer.esi');
821.             return;
822.         }
824.         $loader->load('esi.php');
825.     }
827.     private function registerSsiConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
828.     {
829.         if (!$this->readConfigEnabled('ssi', $container, $config)) {
830.             $container->removeDefinition('fragment.renderer.ssi');
832.             return;
833.         }
835.         $loader->load('ssi.php');
836.     }
838.     private function registerFragmentsConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
839.     {
840.         if (!$this->readConfigEnabled('fragments', $container, $config)) {
841.             $container->removeDefinition('fragment.renderer.hinclude');
843.             return;
844.         }
846.         $container->setParameter('fragment.renderer.hinclude.global_template', $config['hinclude_default_template']);
848.         $loader->load('fragment_listener.php');
849.         $container->setParameter('fragment.path', $config['path']);
850.     }
852.     private function registerProfilerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
853.     {
854.         if (!$this->readConfigEnabled('profiler', $container, $config)) {
855.             // this is needed for the WebProfiler to work even if the profiler is disabled
856.             $container->setParameter('data_collector.templates', []);
858.             return;
859.         }
861.         $loader->load('profiling.php');
862.         $loader->load('collectors.php');
863.         $loader->load('cache_debug.php');
865.         if ($this->isInitializedConfigEnabled('form')) {
866.             $loader->load('form_debug.php');
867.         }
869.         if ($this->isInitializedConfigEnabled('validation')) {
870.             $loader->load('validator_debug.php');
871.         }
873.         if ($this->isInitializedConfigEnabled('translator')) {
874.             $loader->load('translation_debug.php');
876.             $container->getDefinition('translator.data_collector')->setDecoratedService('translator');
877.         }
879.         if ($this->isInitializedConfigEnabled('messenger')) {
880.             $loader->load('messenger_debug.php');
881.         }
883.         if ($this->isInitializedConfigEnabled('mailer')) {
884.             $loader->load('mailer_debug.php');
885.         }
887.         if ($this->isInitializedConfigEnabled('workflows')) {
888.             $loader->load('workflow_debug.php');
889.         }
891.         if ($this->isInitializedConfigEnabled('http_client')) {
892.             $loader->load('http_client_debug.php');
893.         }
895.         if ($this->isInitializedConfigEnabled('notifier')) {
896.             $loader->load('notifier_debug.php');
897.         }
899.         if ($this->isInitializedConfigEnabled('serializer') && $config['collect_serializer_data']) {
900.             $loader->load('serializer_debug.php');
901.         }
903.         $container->setParameter('profiler_listener.only_exceptions', $config['only_exceptions']);
904.         $container->setParameter('profiler_listener.only_main_requests', $config['only_main_requests']);
906.         // Choose storage class based on the DSN
907.         [$class] = explode(':', $config['dsn'], 2);
908.         if ('file' !== $class) {
909.             throw new \LogicException(sprintf('Driver "%s" is not supported for the profiler.', $class));
910.         }
912.         $container->setParameter('profiler.storage.dsn', $config['dsn']);
914.         $container->getDefinition('profiler')
915.             ->addArgument($config['collect'])
916.             ->addTag('kernel.reset', ['method' => 'reset']);
918.         $container->getDefinition('profiler_listener')
919.             ->addArgument($config['collect_parameter']);
921.         if (!$container->getParameter('kernel.debug') || !class_exists(CliRequest::class) || !$container->has('debug.stopwatch')) {
922.             $container->removeDefinition('console_profiler_listener');
923.         }
925.         if (!class_exists(CommandDataCollector::class)) {
926.             $container->removeDefinition('.data_collector.command');
927.         }
928.     }
930.     private function registerWorkflowConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
931.     {
932.         if (!$config['enabled']) {
933.             $container->removeDefinition('console.command.workflow_dump');
935.             return;
936.         }
938.         if (!class_exists(Workflow\Workflow::class)) {
939.             throw new LogicException('Workflow support cannot be enabled as the Workflow component is not installed. Try running "composer require symfony/workflow".');
940.         }
942.         $loader->load('workflow.php');
944.         $registryDefinition = $container->getDefinition('workflow.registry');
946.         foreach ($config['workflows'] as $name => $workflow) {
947.             $type = $workflow['type'];
948.             $workflowId = sprintf('%s.%s', $type, $name);
950.             // Process Metadata (workflow + places (transition is done in the "create transition" block))
951.             $metadataStoreDefinition = new Definition(Workflow\Metadata\InMemoryMetadataStore::class, [[], [], null]);
952.             if ($workflow['metadata']) {
953.                 $metadataStoreDefinition->replaceArgument(0, $workflow['metadata']);
954.             }
955.             $placesMetadata = [];
956.             foreach ($workflow['places'] as $place) {
957.                 if ($place['metadata']) {
958.                     $placesMetadata[$place['name']] = $place['metadata'];
959.                 }
960.             }
961.             if ($placesMetadata) {
962.                 $metadataStoreDefinition->replaceArgument(1, $placesMetadata);
963.             }
965.             // Create transitions
966.             $transitions = [];
967.             $guardsConfiguration = [];
968.             $transitionsMetadataDefinition = new Definition(\SplObjectStorage::class);
969.             // Global transition counter per workflow
970.             $transitionCounter = 0;
971.             foreach ($workflow['transitions'] as $transition) {
972.                 if ('workflow' === $type) {
973.                     $transitionDefinition = new Definition(Workflow\Transition::class, [$transition['name'], $transition['from'], $transition['to']]);
974.                     $transitionId = sprintf('.%s.transition.%s', $workflowId, $transitionCounter++);
975.                     $container->setDefinition($transitionId, $transitionDefinition);
976.                     $transitions[] = new Reference($transitionId);
977.                     if (isset($transition['guard'])) {
978.                         $configuration = new Definition(Workflow\EventListener\GuardExpression::class);
979.                         $configuration->addArgument(new Reference($transitionId));
980.                         $configuration->addArgument($transition['guard']);
981.                         $eventName = sprintf('workflow.%s.guard.%s', $name, $transition['name']);
982.                         $guardsConfiguration[$eventName][] = $configuration;
983.                     }
984.                     if ($transition['metadata']) {
985.                         $transitionsMetadataDefinition->addMethodCall('attach', [
986.                             new Reference($transitionId),
987.                             $transition['metadata'],
988.                         ]);
989.                     }
990.                 } elseif ('state_machine' === $type) {
991.                     foreach ($transition['from'] as $from) {
992.                         foreach ($transition['to'] as $to) {
993.                             $transitionDefinition = new Definition(Workflow\Transition::class, [$transition['name'], $from, $to]);
994.                             $transitionId = sprintf('.%s.transition.%s', $workflowId, $transitionCounter++);
995.                             $container->setDefinition($transitionId, $transitionDefinition);
996.                             $transitions[] = new Reference($transitionId);
997.                             if (isset($transition['guard'])) {
998.                                 $configuration = new Definition(Workflow\EventListener\GuardExpression::class);
999.                                 $configuration->addArgument(new Reference($transitionId));
1000.                                 $configuration->addArgument($transition['guard']);
1001.                                 $eventName = sprintf('workflow.%s.guard.%s', $name, $transition['name']);
1002.                                 $guardsConfiguration[$eventName][] = $configuration;
1003.                             }
1004.                             if ($transition['metadata']) {
1005.                                 $transitionsMetadataDefinition->addMethodCall('attach', [
1006.                                     new Reference($transitionId),
1007.                                     $transition['metadata'],
1008.                                 ]);
1009.                             }
1010.                         }
1011.                     }
1012.                 }
1013.             }
1014.             $metadataStoreDefinition->replaceArgument(2, $transitionsMetadataDefinition);
1015.             $container->setDefinition(sprintf('%s.metadata_store', $workflowId), $metadataStoreDefinition);
1017.             // Create places
1018.             $places = array_column($workflow['places'], 'name');
1019.             $initialMarking = $workflow['initial_marking'] ?? [];
1021.             // Create a Definition
1022.             $definitionDefinition = new Definition(Workflow\Definition::class);
1023.             $definitionDefinition->addArgument($places);
1024.             $definitionDefinition->addArgument($transitions);
1025.             $definitionDefinition->addArgument($initialMarking);
1026.             $definitionDefinition->addArgument(new Reference(sprintf('%s.metadata_store', $workflowId)));
1028.             // Create MarkingStore
1029.             $markingStoreDefinition = null;
1030.             if (isset($workflow['marking_store']['type']) || isset($workflow['marking_store']['property'])) {
1031.                 $markingStoreDefinition = new ChildDefinition('workflow.marking_store.method');
1032.                 $markingStoreDefinition->setArguments([
1033.                     'state_machine' === $type, // single state
1034.                     $workflow['marking_store']['property'] ?? 'marking',
1035.                 ]);
1036.             } elseif (isset($workflow['marking_store']['service'])) {
1037.                 $markingStoreDefinition = new Reference($workflow['marking_store']['service']);
1038.             }
1040.             // Create Workflow
1041.             $workflowDefinition = new ChildDefinition(sprintf('%s.abstract', $type));
1042.             $workflowDefinition->replaceArgument(0, new Reference(sprintf('%s.definition', $workflowId)));
1043.             $workflowDefinition->replaceArgument(1, $markingStoreDefinition);
1044.             $workflowDefinition->replaceArgument(3, $name);
1045.             $workflowDefinition->replaceArgument(4, $workflow['events_to_dispatch']);
1047.             $workflowDefinition->addTag('workflow', ['name' => $name]);
1048.             if ('workflow' === $type) {
1049.                 $workflowDefinition->addTag('workflow.workflow', ['name' => $name]);
1050.             } elseif ('state_machine' === $type) {
1051.                 $workflowDefinition->addTag('workflow.state_machine', ['name' => $name]);
1052.             }
1054.             // Store to container
1055.             $container->setDefinition($workflowId, $workflowDefinition);
1056.             $container->setDefinition(sprintf('%s.definition', $workflowId), $definitionDefinition);
1057.             $container->registerAliasForArgument($workflowId, WorkflowInterface::class, $name.'.'.$type);
1058.             $container->registerAliasForArgument($workflowId, WorkflowInterface::class, $name);
1060.             // Validate Workflow
1061.             if ('state_machine' === $workflow['type']) {
1062.                 $validator = new Workflow\Validator\StateMachineValidator();
1063.             } else {
1064.                 $validator = new Workflow\Validator\WorkflowValidator();
1065.             }
1067.             $trs = array_map(fn (Reference $ref): Workflow\Transition => $container->get((string) $ref), $transitions);
1068.             $realDefinition = new Workflow\Definition($places, $trs, $initialMarking);
1069.             $validator->validate($realDefinition, $name);
1071.             // Add workflow to Registry
1072.             if ($workflow['supports']) {
1073.                 foreach ($workflow['supports'] as $supportedClassName) {
1074.                     $strategyDefinition = new Definition(Workflow\SupportStrategy\InstanceOfSupportStrategy::class, [$supportedClassName]);
1075.                     $registryDefinition->addMethodCall('addWorkflow', [new Reference($workflowId), $strategyDefinition]);
1076.                 }
1077.             } elseif (isset($workflow['support_strategy'])) {
1078.                 $registryDefinition->addMethodCall('addWorkflow', [new Reference($workflowId), new Reference($workflow['support_strategy'])]);
1079.             }
1081.             // Enable the AuditTrail
1082.             if ($workflow['audit_trail']['enabled']) {
1083.                 $listener = new Definition(Workflow\EventListener\AuditTrailListener::class);
1084.                 $listener->addTag('monolog.logger', ['channel' => 'workflow']);
1085.                 $listener->addTag('kernel.event_listener', ['event' => sprintf('workflow.%s.leave', $name), 'method' => 'onLeave']);
1086.                 $listener->addTag('kernel.event_listener', ['event' => sprintf('workflow.%s.transition', $name), 'method' => 'onTransition']);
1087.                 $listener->addTag('kernel.event_listener', ['event' => sprintf('workflow.%s.enter', $name), 'method' => 'onEnter']);
1088.                 $listener->addArgument(new Reference('logger'));
1089.                 $container->setDefinition(sprintf('.%s.listener.audit_trail', $workflowId), $listener);
1090.             }
1092.             // Add Guard Listener
1093.             if ($guardsConfiguration) {
1094.                 if (!class_exists(ExpressionLanguage::class)) {
1095.                     throw new LogicException('Cannot guard workflows as the ExpressionLanguage component is not installed. Try running "composer require symfony/expression-language".');
1096.                 }
1098.                 if (!class_exists(AuthenticationEvents::class)) {
1099.                     throw new LogicException('Cannot guard workflows as the Security component is not installed. Try running "composer require symfony/security-core".');
1100.                 }
1102.                 $guard = new Definition(Workflow\EventListener\GuardListener::class);
1104.                 $guard->setArguments([
1105.                     $guardsConfiguration,
1106.                     new Reference('workflow.security.expression_language'),
1107.                     new Reference('security.token_storage'),
1108.                     new Reference('security.authorization_checker'),
1109.                     new Reference('security.authentication.trust_resolver'),
1110.                     new Reference('security.role_hierarchy'),
1111.                     new Reference('validator', ContainerInterface::NULL_ON_INVALID_REFERENCE),
1112.                 ]);
1113.                 foreach ($guardsConfiguration as $eventName => $config) {
1114.                     $guard->addTag('kernel.event_listener', ['event' => $eventName, 'method' => 'onTransition']);
1115.                 }
1117.                 $container->setDefinition(sprintf('.%s.listener.guard', $workflowId), $guard);
1118.                 $container->setParameter('workflow.has_guard_listeners', true);
1119.             }
1120.         }
1122.         $listenerAttributes = [
1123.             Workflow\Attribute\AsAnnounceListener::class,
1124.             Workflow\Attribute\AsCompletedListener::class,
1125.             Workflow\Attribute\AsEnterListener::class,
1126.             Workflow\Attribute\AsEnteredListener::class,
1127.             Workflow\Attribute\AsGuardListener::class,
1128.             Workflow\Attribute\AsLeaveListener::class,
1129.             Workflow\Attribute\AsTransitionListener::class,
1130.         ];
1132.         foreach ($listenerAttributes as $attribute) {
1133.             $container->registerAttributeForAutoconfiguration($attribute, static function (ChildDefinition $definition, AsEventListener $attribute, \ReflectionClass|\ReflectionMethod $reflector) {
1134.                 $tagAttributes = get_object_vars($attribute);
1135.                 if ($reflector instanceof \ReflectionMethod) {
1136.                     if (isset($tagAttributes['method'])) {
1137.                         throw new LogicException(sprintf('"%s" attribute cannot declare a method on "%s::%s()".', $attribute::class, $reflector->class, $reflector->name));
1138.                     }
1139.                     $tagAttributes['method'] = $reflector->getName();
1140.                 }
1141.                 $definition->addTag('kernel.event_listener', $tagAttributes);
1142.             });
1143.         }
1144.     }
1146.     private function registerDebugConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
1147.     {
1148.         $loader->load('debug_prod.php');
1150.         $debug = $container->getParameter('kernel.debug');
1152.         if (class_exists(Stopwatch::class)) {
1153.             $container->register('debug.stopwatch', Stopwatch::class)
1154.                 ->addArgument(true)
1155.                 ->setPublic($debug)
1156.                 ->addTag('kernel.reset', ['method' => 'reset']);
1157.             $container->setAlias(Stopwatch::class, new Alias('debug.stopwatch', false));
1158.         }
1160.         if ($debug && !$container->hasParameter('debug.container.dump')) {
1161.             $container->setParameter('debug.container.dump', '%kernel.build_dir%/%kernel.container_class%.xml');
1162.         }
1164.         if ($debug && class_exists(Stopwatch::class)) {
1165.             $loader->load('debug.php');
1166.         }
1168.         $definition = $container->findDefinition('debug.error_handler_configurator');
1170.         if (false === $config['log']) {
1171.             $definition->replaceArgument(0, null);
1172.         } elseif (true !== $config['log']) {
1173.             $definition->replaceArgument(1, $config['log']);
1174.         }
1176.         if (!$config['throw']) {
1177.             $container->setParameter('debug.error_handler.throw_at', 0);
1178.         }
1180.         if ($debug && class_exists(DebugProcessor::class)) {
1181.             $definition = new Definition(DebugProcessor::class);
1182.             $definition->addArgument(new Reference('.virtual_request_stack'));
1183.             $definition->addTag('kernel.reset', ['method' => 'reset']);
1184.             $container->setDefinition('debug.log_processor', $definition);
1186.             $container->register('debug.debug_logger_configurator', DebugLoggerConfigurator::class)
1187.                 ->setArguments([new Reference('debug.log_processor'), '%kernel.runtime_mode.web%']);
1188.         }
1189.     }
1191.     private function registerRouterConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader, array $enabledLocales = []): void
1192.     {
1193.         if (!$this->readConfigEnabled('router', $container, $config)) {
1194.             $container->removeDefinition('console.command.router_debug');
1195.             $container->removeDefinition('console.command.router_match');
1196.             $container->removeDefinition('messenger.middleware.router_context');
1198.             return;
1199.         }
1200.         if (!class_exists(RouterContextMiddleware::class)) {
1201.             $container->removeDefinition('messenger.middleware.router_context');
1202.         }
1204.         $loader->load('routing.php');
1206.         if ($config['utf8']) {
1207.             $container->getDefinition('routing.loader')->replaceArgument(1, ['utf8' => true]);
1208.         }
1210.         if ($enabledLocales) {
1211.             $enabledLocales = implode('|', array_map('preg_quote', $enabledLocales));
1212.             $container->getDefinition('routing.loader')->replaceArgument(2, ['_locale' => $enabledLocales]);
1213.         }
1215.         if (!ContainerBuilder::willBeAvailable('symfony/expression-language', ExpressionLanguage::class, ['symfony/framework-bundle', 'symfony/routing'])) {
1216.             $container->removeDefinition('router.expression_language_provider');
1217.         }
1219.         $container->setParameter('router.resource', $config['resource']);
1220.         $container->setParameter('router.cache_dir', $config['cache_dir']);
1221.         $router = $container->findDefinition('router.default');
1222.         $argument = $router->getArgument(2);
1223.         $argument['strict_requirements'] = $config['strict_requirements'];
1224.         if (isset($config['type'])) {
1225.             $argument['resource_type'] = $config['type'];
1226.         }
1227.         $router->replaceArgument(2, $argument);
1229.         $container->setParameter('request_listener.http_port', $config['http_port']);
1230.         $container->setParameter('request_listener.https_port', $config['https_port']);
1232.         if (null !== $config['default_uri']) {
1233.             $container->getDefinition('router.request_context')
1234.                 ->replaceArgument(0, $config['default_uri']);
1235.         }
1237.         if ($this->isInitializedConfigEnabled('annotations') && (new \ReflectionClass(AttributeClassLoader::class))->hasProperty('reader')) {
1238.             $container->getDefinition('routing.loader.attribute')->setArguments([
1239.                 new Reference('annotation_reader'),
1240.                 '%kernel.environment%',
1241.             ]);
1242.         }
1243.     }
1245.     private function registerSessionConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
1246.     {
1247.         $loader->load('session.php');
1249.         // session storage
1250.         $container->setAlias('session.storage.factory', $config['storage_factory_id']);
1252.         $options = ['cache_limiter' => '0'];
1253.         foreach (['name', 'cookie_lifetime', 'cookie_path', 'cookie_domain', 'cookie_secure', 'cookie_httponly', 'cookie_samesite', 'use_cookies', 'gc_maxlifetime', 'gc_probability', 'gc_divisor', 'sid_length', 'sid_bits_per_character'] as $key) {
1254.             if (isset($config[$key])) {
1255.                 $options[$key] = $config[$key];
1256.             }
1257.         }
1259.         if ('auto' === ($options['cookie_secure'] ?? null)) {
1260.             $container->getDefinition('session.storage.factory.native')->replaceArgument(3, true);
1261.             $container->getDefinition('session.storage.factory.php_bridge')->replaceArgument(2, true);
1262.         }
1264.         $container->setParameter('session.storage.options', $options);
1266.         // session handler (the internal callback registered with PHP session management)
1267.         if (null === $config['handler_id']) {
1268.             $config['save_path'] = null;
1269.             $container->setAlias('session.handler', 'session.handler.native');
1270.         } else {
1271.             $container->resolveEnvPlaceholders($config['handler_id'], null, $usedEnvs);
1273.             if ($usedEnvs || preg_match('#^[a-z]++://#', $config['handler_id'])) {
1274.                 $id = '.cache_connection.'.ContainerBuilder::hash($config['handler_id']);
1276.                 $container->getDefinition('session.abstract_handler')
1277.                     ->replaceArgument(0, $container->hasDefinition($id) ? new Reference($id) : $config['handler_id']);
1279.                 $container->setAlias('session.handler', 'session.abstract_handler');
1280.             } else {
1281.                 $container->setAlias('session.handler', $config['handler_id']);
1282.             }
1283.         }
1285.         $container->setParameter('session.save_path', $config['save_path']);
1287.         $container->setParameter('session.metadata.update_threshold', $config['metadata_update_threshold']);
1288.     }
1290.     private function registerRequestConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
1291.     {
1292.         if ($config['formats']) {
1293.             $loader->load('request.php');
1295.             $listener = $container->getDefinition('request.add_request_formats_listener');
1296.             $listener->replaceArgument(0, $config['formats']);
1297.         }
1298.     }
1300.     private function registerAssetsConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
1301.     {
1302.         $loader->load('assets.php');
1304.         if ($config['version_strategy']) {
1305.             $defaultVersion = new Reference($config['version_strategy']);
1306.         } else {
1307.             $defaultVersion = $this->createVersion($container, $config['version'], $config['version_format'], $config['json_manifest_path'], '_default', $config['strict_mode']);
1308.         }
1310.         $defaultPackage = $this->createPackageDefinition($config['base_path'], $config['base_urls'], $defaultVersion);
1311.         $container->setDefinition('assets._default_package', $defaultPackage);
1313.         foreach ($config['packages'] as $name => $package) {
1314.             if (null !== $package['version_strategy']) {
1315.                 $version = new Reference($package['version_strategy']);
1316.             } elseif (!\array_key_exists('version', $package) && null === $package['json_manifest_path']) {
1317.                 // if neither version nor json_manifest_path are specified, use the default
1318.                 $version = $defaultVersion;
1319.             } else {
1320.                 // let format fallback to main version_format
1321.                 $format = $package['version_format'] ?: $config['version_format'];
1322.                 $version = $package['version'] ?? null;
1323.                 $version = $this->createVersion($container, $version, $format, $package['json_manifest_path'], $name, $package['strict_mode']);
1324.             }
1326.             $packageDefinition = $this->createPackageDefinition($package['base_path'], $package['base_urls'], $version)
1327.                 ->addTag('assets.package', ['package' => $name]);
1328.             $container->setDefinition('assets._package_'.$name, $packageDefinition);
1329.             $container->registerAliasForArgument('assets._package_'.$name, PackageInterface::class, $name.'.package');
1330.         }
1331.     }
1333.     private function registerAssetMapperConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader, bool $assetEnabled): void
1334.     {
1335.         $loader->load('asset_mapper.php');
1337.         if (!$assetEnabled) {
1338.             $container->removeDefinition('asset_mapper.asset_package');
1339.         }
1341.         $paths = $config['paths'];
1342.         foreach ($container->getParameter('kernel.bundles_metadata') as $name => $bundle) {
1343.             if ($container->fileExists($dir = $bundle['path'].'/Resources/public') || $container->fileExists($dir = $bundle['path'].'/public')) {
1344.                 $paths[$dir] = sprintf('bundles/%s', preg_replace('/bundle$/', '', strtolower($name)));
1345.             }
1346.         }
1347.         $excludedPathPatterns = [];
1348.         foreach ($config['excluded_patterns'] as $path) {
1349.             $excludedPathPatterns[] = Glob::toRegex($path, true, false);
1350.         }
1352.         $container->getDefinition('asset_mapper.repository')
1353.             ->setArgument(0, $paths)
1354.             ->setArgument(2, $excludedPathPatterns)
1355.             ->setArgument(3, $config['exclude_dotfiles']);
1357.         $container->getDefinition('asset_mapper.public_assets_path_resolver')
1358.             ->setArgument(0, $config['public_prefix']);
1360.         $publicDirectory = $this->getPublicDirectory($container);
1361.         $publicAssetsDirectory = rtrim($publicDirectory.'/'.ltrim($config['public_prefix'], '/'), '/');
1362.         $container->getDefinition('asset_mapper.local_public_assets_filesystem')
1363.             ->setArgument(0, $publicDirectory)
1364.         ;
1366.         $container->getDefinition('asset_mapper.compiled_asset_mapper_config_reader')
1367.             ->setArgument(0, $publicAssetsDirectory);
1369.         if (!$config['server']) {
1370.             $container->removeDefinition('asset_mapper.dev_server_subscriber');
1371.         } else {
1372.             $container->getDefinition('asset_mapper.dev_server_subscriber')
1373.                 ->setArgument(1, $config['public_prefix'])
1374.                 ->setArgument(2, $config['extensions']);
1375.         }
1377.         $container->getDefinition('asset_mapper.compiler.css_asset_url_compiler')
1378.             ->setArgument(0, $config['missing_import_mode']);
1380.         $container->getDefinition('asset_mapper.compiler.javascript_import_path_compiler')
1381.             ->setArgument(1, $config['missing_import_mode']);
1383.         $container
1384.             ->getDefinition('asset_mapper.importmap.remote_package_storage')
1385.             ->replaceArgument(0, $config['vendor_dir'])
1386.         ;
1387.         $container
1388.             ->getDefinition('asset_mapper.mapped_asset_factory')
1389.             ->replaceArgument(2, $config['vendor_dir'])
1390.         ;
1392.         $container
1393.             ->getDefinition('asset_mapper.importmap.config_reader')
1394.             ->replaceArgument(0, $config['importmap_path'])
1395.         ;
1397.         $container
1398.             ->getDefinition('asset_mapper.importmap.renderer')
1399.             ->replaceArgument(3, $config['importmap_polyfill'])
1400.             ->replaceArgument(4, $config['importmap_script_attributes'])
1401.         ;
1402.     }
1404.     /**
1405.      * Returns a definition for an asset package.
1406.      */
1407.     private function createPackageDefinition(?string $basePath, array $baseUrls, Reference $version): Definition
1408.     {
1409.         if ($basePath && $baseUrls) {
1410.             throw new \LogicException('An asset package cannot have base URLs and base paths.');
1411.         }
1413.         $package = new ChildDefinition($baseUrls ? 'assets.url_package' : 'assets.path_package');
1414.         $package
1415.             ->replaceArgument(0, $baseUrls ?: $basePath)
1416.             ->replaceArgument(1, $version)
1417.         ;
1419.         return $package;
1420.     }
1422.     private function createVersion(ContainerBuilder $container, ?string $version, ?string $format, ?string $jsonManifestPath, string $name, bool $strictMode): Reference
1423.     {
1424.         // Configuration prevents $version and $jsonManifestPath from being set
1425.         if (null !== $version) {
1426.             $def = new ChildDefinition('assets.static_version_strategy');
1427.             $def
1428.                 ->replaceArgument(0, $version)
1429.                 ->replaceArgument(1, $format)
1430.             ;
1431.             $container->setDefinition('assets._version_'.$name, $def);
1433.             return new Reference('assets._version_'.$name);
1434.         }
1436.         if (null !== $jsonManifestPath) {
1437.             $def = new ChildDefinition('assets.json_manifest_version_strategy');
1438.             $def->replaceArgument(0, $jsonManifestPath);
1439.             $def->replaceArgument(2, $strictMode);
1440.             $container->setDefinition('assets._version_'.$name, $def);
1442.             return new Reference('assets._version_'.$name);
1443.         }
1445.         return new Reference('assets.empty_version_strategy');
1446.     }
1448.     private function registerTranslatorConfiguration(array $config, ContainerBuilder $container, LoaderInterface $loader, string $defaultLocale, array $enabledLocales): void
1449.     {
1450.         if (!$this->readConfigEnabled('translator', $container, $config)) {
1451.             $container->removeDefinition('console.command.translation_debug');
1452.             $container->removeDefinition('console.command.translation_extract');
1453.             $container->removeDefinition('console.command.translation_pull');
1454.             $container->removeDefinition('console.command.translation_push');
1456.             return;
1457.         }
1459.         $loader->load('translation.php');
1461.         if (!ContainerBuilder::willBeAvailable('symfony/translation', LocaleSwitcher::class, ['symfony/framework-bundle'])) {
1462.             $container->removeDefinition('translation.locale_switcher');
1463.         }
1465.         // don't use ContainerBuilder::willBeAvailable() as these are not needed in production
1466.         if (interface_exists(Parser::class) && class_exists(PhpAstExtractor::class)) {
1467.             $container->removeDefinition('translation.extractor.php');
1468.         } else {
1469.             $container->removeDefinition('translation.extractor.php_ast');
1470.         }
1472.         $loader->load('translation_providers.php');
1474.         // Use the "real" translator instead of the identity default
1475.         $container->setAlias('translator', 'translator.default')->setPublic(true);
1476.         $container->setAlias('translator.formatter', new Alias($config['formatter'], false));
1477.         $translator = $container->findDefinition('translator.default');
1478.         $translator->addMethodCall('setFallbackLocales', [$config['fallbacks'] ?: [$defaultLocale]]);
1480.         $defaultOptions = $translator->getArgument(4);
1481.         $defaultOptions['cache_dir'] = $config['cache_dir'];
1482.         $translator->setArgument(4, $defaultOptions);
1483.         $translator->setArgument(5, $enabledLocales);
1485.         $container->setParameter('translator.logging', $config['logging']);
1486.         $container->setParameter('translator.default_path', $config['default_path']);
1488.         // Discover translation directories
1489.         $dirs = [];
1490.         $transPaths = [];
1491.         $nonExistingDirs = [];
1492.         if (ContainerBuilder::willBeAvailable('symfony/validator', Validation::class, ['symfony/framework-bundle', 'symfony/translation'])) {
1493.             $r = new \ReflectionClass(Validation::class);
1495.             $dirs[] = $transPaths[] = \dirname($r->getFileName()).'/Resources/translations';
1496.         }
1497.         if (ContainerBuilder::willBeAvailable('symfony/form', Form::class, ['symfony/framework-bundle', 'symfony/translation'])) {
1498.             $r = new \ReflectionClass(Form::class);
1500.             $dirs[] = $transPaths[] = \dirname($r->getFileName()).'/Resources/translations';
1501.         }
1502.         if (ContainerBuilder::willBeAvailable('symfony/security-core', AuthenticationException::class, ['symfony/framework-bundle', 'symfony/translation'])) {
1503.             $r = new \ReflectionClass(AuthenticationException::class);
1505.             $dirs[] = $transPaths[] = \dirname($r->getFileName(), 2).'/Resources/translations';
1506.         }
1507.         $defaultDir = $container->getParameterBag()->resolveValue($config['default_path']);
1508.         foreach ($container->getParameter('kernel.bundles_metadata') as $name => $bundle) {
1509.             if ($container->fileExists($dir = $bundle['path'].'/Resources/translations') || $container->fileExists($dir = $bundle['path'].'/translations')) {
1510.                 $dirs[] = $dir;
1511.             } else {
1512.                 $nonExistingDirs[] = $dir;
1513.             }
1514.         }
1516.         foreach ($config['paths'] as $dir) {
1517.             if ($container->fileExists($dir)) {
1518.                 $dirs[] = $transPaths[] = $dir;
1519.             } else {
1520.                 throw new \UnexpectedValueException(sprintf('"%s" defined in translator.paths does not exist or is not a directory.', $dir));
1521.             }
1522.         }
1524.         if ($container->hasDefinition('console.command.translation_debug')) {
1525.             $container->getDefinition('console.command.translation_debug')->replaceArgument(5, $transPaths);
1526.         }
1528.         if ($container->hasDefinition('console.command.translation_extract')) {
1529.             $container->getDefinition('console.command.translation_extract')->replaceArgument(6, $transPaths);
1530.         }
1532.         if (null === $defaultDir) {
1533.             // allow null
1534.         } elseif ($container->fileExists($defaultDir)) {
1535.             $dirs[] = $defaultDir;
1536.         } else {
1537.             $nonExistingDirs[] = $defaultDir;
1538.         }
1540.         // Register translation resources
1541.         if ($dirs) {
1542.             $files = [];
1544.             foreach ($dirs as $dir) {
1545.                 $finder = Finder::create()
1546.                     ->followLinks()
1547.                     ->files()
1548.                     ->filter(fn (\SplFileInfo $file) => 2 <= substr_count($file->getBasename(), '.') && preg_match('/\.\w+$/', $file->getBasename()))
1549.                     ->in($dir)
1550.                     ->sortByName()
1551.                 ;
1552.                 foreach ($finder as $file) {
1553.                     $fileNameParts = explode('.', basename($file));
1554.                     $locale = $fileNameParts[\count($fileNameParts) - 2];
1555.                     if (!isset($files[$locale])) {
1556.                         $files[$locale] = [];
1557.                     }
1559.                     $files[$locale][] = (string) $file;
1560.                 }
1561.             }
1563.             $projectDir = $container->getParameter('kernel.project_dir');
1565.             $options = array_merge(
1566.                 $translator->getArgument(4),
1567.                 [
1568.                     'resource_files' => $files,
1569.                     'scanned_directories' => $scannedDirectories = array_merge($dirs, $nonExistingDirs),
1570.                     'cache_vary' => [
1571.                         'scanned_directories' => array_map(fn ($dir) => str_starts_with($dir, $projectDir.'/') ? substr($dir, 1 + \strlen($projectDir)) : $dir, $scannedDirectories),
1572.                     ],
1573.                 ]
1574.             );
1576.             $translator->replaceArgument(4, $options);
1577.         }
1579.         if ($config['pseudo_localization']['enabled']) {
1580.             $options = $config['pseudo_localization'];
1581.             unset($options['enabled']);
1583.             $container
1584.                 ->register('translator.pseudo', PseudoLocalizationTranslator::class)
1585.                 ->setDecoratedService('translator', null, -1) // Lower priority than "translator.data_collector"
1586.                 ->setArguments([
1587.                     new Reference('translator.pseudo.inner'),
1588.                     $options,
1589.                 ]);
1590.         }
1592.         $classToServices = [
1593.             TranslationBridge\Crowdin\CrowdinProviderFactory::class => 'translation.provider_factory.crowdin',
1594.             TranslationBridge\Loco\LocoProviderFactory::class => 'translation.provider_factory.loco',
1595.             TranslationBridge\Lokalise\LokaliseProviderFactory::class => 'translation.provider_factory.lokalise',
1596.             TranslationBridge\Phrase\PhraseProviderFactory::class => 'translation.provider_factory.phrase',
1597.         ];
1599.         $parentPackages = ['symfony/framework-bundle', 'symfony/translation', 'symfony/http-client'];
1601.         foreach ($classToServices as $class => $service) {
1602.             $package = substr($service, \strlen('translation.provider_factory.'));
1604.             if (!$container->hasDefinition('http_client') || !ContainerBuilder::willBeAvailable(sprintf('symfony/%s-translation-provider', $package), $class, $parentPackages)) {
1605.                 $container->removeDefinition($service);
1606.             }
1607.         }
1609.         if (!$config['providers']) {
1610.             return;
1611.         }
1613.         $locales = $enabledLocales;
1615.         foreach ($config['providers'] as $provider) {
1616.             if ($provider['locales']) {
1617.                 $locales += $provider['locales'];
1618.             }
1619.         }
1621.         $locales = array_unique($locales);
1623.         $container->getDefinition('console.command.translation_pull')
1624.             ->replaceArgument(4, array_merge($transPaths, [$config['default_path']]))
1625.             ->replaceArgument(5, $locales)
1626.         ;
1628.         $container->getDefinition('console.command.translation_push')
1629.             ->replaceArgument(2, array_merge($transPaths, [$config['default_path']]))
1630.             ->replaceArgument(3, $locales)
1631.         ;
1633.         $container->getDefinition('translation.provider_collection_factory')
1634.             ->replaceArgument(1, $locales)
1635.         ;
1637.         $container->getDefinition('translation.provider_collection')->setArgument(0, $config['providers']);
1638.     }
1640.     private function registerValidationConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader, bool $propertyInfoEnabled): void
1641.     {
1642.         if (!$this->readConfigEnabled('validation', $container, $config)) {
1643.             $container->removeDefinition('console.command.validator_debug');
1645.             return;
1646.         }
1648.         if (!class_exists(Validation::class)) {
1649.             throw new LogicException('Validation support cannot be enabled as the Validator component is not installed. Try running "composer require symfony/validator".');
1650.         }
1652.         if (!isset($config['email_validation_mode'])) {
1653.             $config['email_validation_mode'] = 'loose';
1654.         }
1656.         $loader->load('validator.php');
1658.         $validatorBuilder = $container->getDefinition('validator.builder');
1660.         $container->setParameter('validator.translation_domain', $config['translation_domain']);
1662.         $files = ['xml' => [], 'yml' => []];
1663.         $this->registerValidatorMapping($container, $config, $files);
1665.         if (!empty($files['xml'])) {
1666.             $validatorBuilder->addMethodCall('addXmlMappings', [$files['xml']]);
1667.         }
1669.         if (!empty($files['yml'])) {
1670.             $validatorBuilder->addMethodCall('addYamlMappings', [$files['yml']]);
1671.         }
1673.         $definition = $container->findDefinition('validator.email');
1674.         $definition->replaceArgument(0, $config['email_validation_mode']);
1676.         if (\array_key_exists('enable_attributes', $config) && $config['enable_attributes']) {
1677.             $validatorBuilder->addMethodCall('enableAttributeMapping', [true]);
1678.             if ($this->isInitializedConfigEnabled('annotations') && method_exists(ValidatorBuilder::class, 'setDoctrineAnnotationReader')) {
1679.                 $validatorBuilder->addMethodCall('setDoctrineAnnotationReader', [new Reference('annotation_reader')]);
1680.             }
1681.         }
1683.         if (\array_key_exists('static_method', $config) && $config['static_method']) {
1684.             foreach ($config['static_method'] as $methodName) {
1685.                 $validatorBuilder->addMethodCall('addMethodMapping', [$methodName]);
1686.             }
1687.         }
1689.         if (!$container->getParameter('kernel.debug')) {
1690.             $validatorBuilder->addMethodCall('setMappingCache', [new Reference('validator.mapping.cache.adapter')]);
1691.         }
1693.         $container->setParameter('validator.auto_mapping', $config['auto_mapping']);
1694.         if (!$propertyInfoEnabled || !class_exists(PropertyInfoLoader::class)) {
1695.             $container->removeDefinition('validator.property_info_loader');
1696.         }
1698.         $container
1699.             ->getDefinition('validator.not_compromised_password')
1700.             ->setArgument(2, $config['not_compromised_password']['enabled'])
1701.             ->setArgument(3, $config['not_compromised_password']['endpoint'])
1702.         ;
1704.         if (!class_exists(ExpressionLanguage::class)) {
1705.             $container->removeDefinition('validator.expression_language');
1706.             $container->removeDefinition('validator.expression_language_provider');
1707.         } elseif (!class_exists(ExpressionLanguageProvider::class)) {
1708.             $container->removeDefinition('validator.expression_language_provider');
1709.         }
1710.     }
1712.     private function registerValidatorMapping(ContainerBuilder $container, array $config, array &$files): void
1713.     {
1714.         $fileRecorder = function ($extension, $path) use (&$files) {
1715.             $files['yaml' === $extension ? 'yml' : $extension][] = $path;
1716.         };
1718.         if (ContainerBuilder::willBeAvailable('symfony/form', Form::class, ['symfony/framework-bundle', 'symfony/validator'])) {
1719.             $reflClass = new \ReflectionClass(Form::class);
1720.             $fileRecorder('xml', \dirname($reflClass->getFileName()).'/Resources/config/validation.xml');
1721.         }
1723.         foreach ($container->getParameter('kernel.bundles_metadata') as $bundle) {
1724.             $configDir = is_dir($bundle['path'].'/Resources/config') ? $bundle['path'].'/Resources/config' : $bundle['path'].'/config';
1726.             if (
1727.                 $container->fileExists($file = $configDir.'/validation.yaml', false)
1728.                 || $container->fileExists($file = $configDir.'/validation.yml', false)
1729.             ) {
1730.                 $fileRecorder('yml', $file);
1731.             }
1733.             if ($container->fileExists($file = $configDir.'/validation.xml', false)) {
1734.                 $fileRecorder('xml', $file);
1735.             }
1737.             if ($container->fileExists($dir = $configDir.'/validation', '/^$/')) {
1738.                 $this->registerMappingFilesFromDir($dir, $fileRecorder);
1739.             }
1740.         }
1742.         $projectDir = $container->getParameter('kernel.project_dir');
1743.         if ($container->fileExists($dir = $projectDir.'/config/validator', '/^$/')) {
1744.             $this->registerMappingFilesFromDir($dir, $fileRecorder);
1745.         }
1747.         $this->registerMappingFilesFromConfig($container, $config, $fileRecorder);
1748.     }
1750.     private function registerMappingFilesFromDir(string $dir, callable $fileRecorder): void
1751.     {
1752.         foreach (Finder::create()->followLinks()->files()->in($dir)->name('/\.(xml|ya?ml)$/')->sortByName() as $file) {
1753.             $fileRecorder($file->getExtension(), $file->getRealPath());
1754.         }
1755.     }
1757.     private function registerMappingFilesFromConfig(ContainerBuilder $container, array $config, callable $fileRecorder): void
1758.     {
1759.         foreach ($config['mapping']['paths'] as $path) {
1760.             if (is_dir($path)) {
1761.                 $this->registerMappingFilesFromDir($path, $fileRecorder);
1762.                 $container->addResource(new DirectoryResource($path, '/^$/'));
1763.             } elseif ($container->fileExists($path, false)) {
1764.                 if (!preg_match('/\.(xml|ya?ml)$/', $path, $matches)) {
1765.                     throw new \RuntimeException(sprintf('Unsupported mapping type in "%s", supported types are XML & Yaml.', $path));
1766.                 }
1767.                 $fileRecorder($matches[1], $path);
1768.             } else {
1769.                 throw new \RuntimeException(sprintf('Could not open file or directory "%s".', $path));
1770.             }
1771.         }
1772.     }
1774.     private function registerAnnotationsConfiguration(array $config, ContainerBuilder $container, LoaderInterface $loader): void
1775.     {
1776.         if (!$this->isInitializedConfigEnabled('annotations')) {
1777.             return;
1778.         }
1780.         if (!class_exists(\Doctrine\Common\Annotations\Annotation::class)) {
1781.             throw new LogicException('Annotations cannot be enabled as the Doctrine Annotation library is not installed. Try running "composer require doctrine/annotations".');
1782.         }
1784.         trigger_deprecation('symfony/framework-bundle', '6.4', 'Enabling the integration of Doctrine annotations is deprecated. Set the "framework.annotations.enabled" config option to false.');
1786.         $loader->load('annotations.php');
1788.         if ('none' === $config['cache']) {
1789.             $container->removeDefinition('annotations.cached_reader');
1791.             return;
1792.         }
1794.         if ('php_array' === $config['cache']) {
1795.             $cacheService = 'annotations.cache_adapter';
1797.             // Enable warmer only if PHP array is used for cache
1798.             $definition = $container->findDefinition('annotations.cache_warmer');
1799.             $definition->addTag('kernel.cache_warmer');
1800.         } else {
1801.             $cacheService = 'annotations.filesystem_cache_adapter';
1802.             $cacheDir = $container->getParameterBag()->resolveValue($config['file_cache_dir']);
1804.             if (!is_dir($cacheDir) && false === @mkdir($cacheDir, 0777, true) && !is_dir($cacheDir)) {
1805.                 throw new \RuntimeException(sprintf('Could not create cache directory "%s".', $cacheDir));
1806.             }
1808.             $container
1809.                 ->getDefinition('annotations.filesystem_cache_adapter')
1810.                 ->replaceArgument(2, $cacheDir)
1811.             ;
1812.         }
1814.         $container
1815.             ->getDefinition('annotations.cached_reader')
1816.             ->replaceArgument(2, $config['debug'])
1817.             // reference the cache provider without using it until AddAnnotationsCachedReaderPass runs
1818.             ->addArgument(new ServiceClosureArgument(new Reference($cacheService)))
1819.         ;
1821.         $container->setAlias('annotation_reader', 'annotations.cached_reader');
1822.         $container->setAlias(Reader::class, new Alias('annotations.cached_reader', false));
1823.         $container->removeDefinition('annotations.psr_cached_reader');
1824.     }
1826.     private function registerPropertyAccessConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
1827.     {
1828.         if (!$this->readConfigEnabled('property_access', $container, $config)) {
1829.             return;
1830.         }
1832.         $loader->load('property_access.php');
1834.         $magicMethods = PropertyAccessor::DISALLOW_MAGIC_METHODS;
1835.         $magicMethods |= $config['magic_call'] ? PropertyAccessor::MAGIC_CALL : 0;
1836.         $magicMethods |= $config['magic_get'] ? PropertyAccessor::MAGIC_GET : 0;
1837.         $magicMethods |= $config['magic_set'] ? PropertyAccessor::MAGIC_SET : 0;
1839.         $throw = PropertyAccessor::DO_NOT_THROW;
1840.         $throw |= $config['throw_exception_on_invalid_index'] ? PropertyAccessor::THROW_ON_INVALID_INDEX : 0;
1841.         $throw |= $config['throw_exception_on_invalid_property_path'] ? PropertyAccessor::THROW_ON_INVALID_PROPERTY_PATH : 0;
1843.         $container
1844.             ->getDefinition('property_accessor')
1845.             ->replaceArgument(0, $magicMethods)
1846.             ->replaceArgument(1, $throw)
1847.             ->replaceArgument(3, new Reference(PropertyReadInfoExtractorInterface::class, ContainerInterface::NULL_ON_INVALID_REFERENCE))
1848.             ->replaceArgument(4, new Reference(PropertyWriteInfoExtractorInterface::class, ContainerInterface::NULL_ON_INVALID_REFERENCE))
1849.         ;
1850.     }
1852.     private function registerSecretsConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
1853.     {
1854.         if (!$this->readConfigEnabled('secrets', $container, $config)) {
1855.             $container->removeDefinition('console.command.secrets_set');
1856.             $container->removeDefinition('console.command.secrets_list');
1857.             $container->removeDefinition('console.command.secrets_remove');
1858.             $container->removeDefinition('console.command.secrets_generate_key');
1859.             $container->removeDefinition('console.command.secrets_decrypt_to_local');
1860.             $container->removeDefinition('console.command.secrets_encrypt_from_local');
1862.             return;
1863.         }
1865.         $loader->load('secrets.php');
1867.         $container->getDefinition('secrets.vault')->replaceArgument(0, $config['vault_directory']);
1869.         if ($config['local_dotenv_file']) {
1870.             $container->getDefinition('secrets.local_vault')->replaceArgument(0, $config['local_dotenv_file']);
1871.         } else {
1872.             $container->removeDefinition('secrets.local_vault');
1873.         }
1875.         if ($config['decryption_env_var']) {
1876.             if (!preg_match('/^(?:[-.\w\\\\]*+:)*+\w++$/', $config['decryption_env_var'])) {
1877.                 throw new InvalidArgumentException(sprintf('Invalid value "%s" set as "decryption_env_var": only "word" characters are allowed.', $config['decryption_env_var']));
1878.             }
1880.             if (ContainerBuilder::willBeAvailable('symfony/string', LazyString::class, ['symfony/framework-bundle'])) {
1881.                 $container->getDefinition('secrets.decryption_key')->replaceArgument(1, $config['decryption_env_var']);
1882.             } else {
1883.                 $container->getDefinition('secrets.vault')->replaceArgument(1, "%env({$config['decryption_env_var']})%");
1884.                 $container->removeDefinition('secrets.decryption_key');
1885.             }
1886.         } else {
1887.             $container->getDefinition('secrets.vault')->replaceArgument(1, null);
1888.             $container->removeDefinition('secrets.decryption_key');
1889.         }
1890.     }
1892.     private function registerSecurityCsrfConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
1893.     {
1894.         if (!$this->readConfigEnabled('csrf_protection', $container, $config)) {
1895.             return;
1896.         }
1898.         if (!class_exists(\Symfony\Component\Security\Csrf\CsrfToken::class)) {
1899.             throw new LogicException('CSRF support cannot be enabled as the Security CSRF component is not installed. Try running "composer require symfony/security-csrf".');
1900.         }
1902.         if (!$this->isInitializedConfigEnabled('session')) {
1903.             throw new \LogicException('CSRF protection needs sessions to be enabled.');
1904.         }
1906.         // Enable services for CSRF protection (even without forms)
1907.         $loader->load('security_csrf.php');
1909.         if (!class_exists(CsrfExtension::class)) {
1910.             $container->removeDefinition('twig.extension.security_csrf');
1911.         }
1912.     }
1914.     private function registerSerializerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
1915.     {
1916.         $loader->load('serializer.php');
1918.         $chainLoader = $container->getDefinition('serializer.mapping.chain_loader');
1920.         if (!$this->isInitializedConfigEnabled('property_access')) {
1921.             $container->removeAlias('serializer.property_accessor');
1922.             $container->removeDefinition('serializer.normalizer.object');
1923.         }
1925.         if (!class_exists(Yaml::class)) {
1926.             $container->removeDefinition('serializer.encoder.yaml');
1927.         }
1929.         if (!$this->isInitializedConfigEnabled('property_access')) {
1930.             $container->removeDefinition('serializer.denormalizer.unwrapping');
1931.         }
1933.         if (!class_exists(Headers::class)) {
1934.             $container->removeDefinition('serializer.normalizer.mime_message');
1935.         }
1937.         if ($container->getParameter('kernel.debug')) {
1938.             $container->removeDefinition('serializer.mapping.cache_class_metadata_factory');
1939.         }
1941.         if (!$this->readConfigEnabled('translator', $container, $config)) {
1942.             $container->removeDefinition('serializer.normalizer.translatable');
1943.         }
1945.         $serializerLoaders = [];
1946.         if (isset($config['enable_attributes']) && $config['enable_attributes']) {
1947.             $annotationLoader = new Definition(
1948.                 AttributeLoader::class,
1949.                 [new Reference('annotation_reader', ContainerInterface::NULL_ON_INVALID_REFERENCE)]
1950.             );
1952.             $serializerLoaders[] = $annotationLoader;
1953.         }
1955.         $fileRecorder = function ($extension, $path) use (&$serializerLoaders) {
1956.             $definition = new Definition(\in_array($extension, ['yaml', 'yml']) ? YamlFileLoader::class : XmlFileLoader::class, [$path]);
1957.             $serializerLoaders[] = $definition;
1958.         };
1960.         foreach ($container->getParameter('kernel.bundles_metadata') as $bundle) {
1961.             $configDir = is_dir($bundle['path'].'/Resources/config') ? $bundle['path'].'/Resources/config' : $bundle['path'].'/config';
1963.             if ($container->fileExists($file = $configDir.'/serialization.xml', false)) {
1964.                 $fileRecorder('xml', $file);
1965.             }
1967.             if (
1968.                 $container->fileExists($file = $configDir.'/serialization.yaml', false)
1969.                 || $container->fileExists($file = $configDir.'/serialization.yml', false)
1970.             ) {
1971.                 $fileRecorder('yml', $file);
1972.             }
1974.             if ($container->fileExists($dir = $configDir.'/serialization', '/^$/')) {
1975.                 $this->registerMappingFilesFromDir($dir, $fileRecorder);
1976.             }
1977.         }
1979.         $projectDir = $container->getParameter('kernel.project_dir');
1980.         if ($container->fileExists($dir = $projectDir.'/config/serializer', '/^$/')) {
1981.             $this->registerMappingFilesFromDir($dir, $fileRecorder);
1982.         }
1984.         $this->registerMappingFilesFromConfig($container, $config, $fileRecorder);
1986.         $chainLoader->replaceArgument(0, $serializerLoaders);
1987.         $container->getDefinition('serializer.mapping.cache_warmer')->replaceArgument(0, $serializerLoaders);
1989.         if (isset($config['name_converter']) && $config['name_converter']) {
1990.             $container->getDefinition('serializer.name_converter.metadata_aware')->setArgument(1, new Reference($config['name_converter']));
1991.         }
1993.         $defaultContext = $config['default_context'] ?? [];
1995.         if ($defaultContext) {
1996.             $container->setParameter('serializer.default_context', $defaultContext);
1997.         }
1999.         if (isset($config['circular_reference_handler']) && $config['circular_reference_handler']) {
2000.             $arguments = $container->getDefinition('serializer.normalizer.object')->getArguments();
2001.             $context = ($arguments[6] ?? $defaultContext) + ['circular_reference_handler' => new Reference($config['circular_reference_handler'])];
2002.             $container->getDefinition('serializer.normalizer.object')->setArgument(5, null);
2003.             $container->getDefinition('serializer.normalizer.object')->setArgument(6, $context);
2004.         }
2006.         if ($config['max_depth_handler'] ?? false) {
2007.             $arguments = $container->getDefinition('serializer.normalizer.object')->getArguments();
2008.             $context = ($arguments[6] ?? $defaultContext) + ['max_depth_handler' => new Reference($config['max_depth_handler'])];
2009.             $container->getDefinition('serializer.normalizer.object')->setArgument(6, $context);
2010.         }
2011.     }
2013.     private function registerPropertyInfoConfiguration(ContainerBuilder $container, PhpFileLoader $loader): void
2014.     {
2015.         if (!interface_exists(PropertyInfoExtractorInterface::class)) {
2016.             throw new LogicException('PropertyInfo support cannot be enabled as the PropertyInfo component is not installed. Try running "composer require symfony/property-info".');
2017.         }
2019.         $loader->load('property_info.php');
2021.         if (
2022.             ContainerBuilder::willBeAvailable('phpstan/phpdoc-parser', PhpDocParser::class, ['symfony/framework-bundle', 'symfony/property-info'])
2023.             && ContainerBuilder::willBeAvailable('phpdocumentor/type-resolver', ContextFactory::class, ['symfony/framework-bundle', 'symfony/property-info'])
2024.         ) {
2025.             $definition = $container->register('property_info.phpstan_extractor', PhpStanExtractor::class);
2026.             $definition->addTag('property_info.type_extractor', ['priority' => -1000]);
2027.         }
2029.         if (ContainerBuilder::willBeAvailable('phpdocumentor/reflection-docblock', DocBlockFactoryInterface::class, ['symfony/framework-bundle', 'symfony/property-info'], true)) {
2030.             $definition = $container->register('property_info.php_doc_extractor', PhpDocExtractor::class);
2031.             $definition->addTag('property_info.description_extractor', ['priority' => -1000]);
2032.             $definition->addTag('property_info.type_extractor', ['priority' => -1001]);
2033.         }
2035.         if ($container->getParameter('kernel.debug')) {
2036.             $container->removeDefinition('property_info.cache');
2037.         }
2038.     }
2040.     private function registerLockConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
2041.     {
2042.         $loader->load('lock.php');
2044.         foreach ($config['resources'] as $resourceName => $resourceStores) {
2045.             if (0 === \count($resourceStores)) {
2046.                 continue;
2047.             }
2049.             // Generate stores
2050.             $storeDefinitions = [];
2051.             foreach ($resourceStores as $resourceStore) {
2052.                 $storeDsn = $container->resolveEnvPlaceholders($resourceStore, null, $usedEnvs);
2053.                 $storeDefinition = new Definition(PersistingStoreInterface::class);
2054.                 $storeDefinition
2055.                     ->setFactory([StoreFactory::class, 'createStore'])
2056.                     ->setArguments([$resourceStore])
2057.                     ->addTag('lock.store');
2059.                 $container->setDefinition($storeDefinitionId = '.lock.'.$resourceName.'.store.'.$container->hash($storeDsn), $storeDefinition);
2061.                 $storeDefinition = new Reference($storeDefinitionId);
2063.                 $storeDefinitions[] = $storeDefinition;
2064.             }
2066.             // Wrap array of stores with CombinedStore
2067.             if (\count($storeDefinitions) > 1) {
2068.                 $combinedDefinition = new ChildDefinition('lock.store.combined.abstract');
2069.                 $combinedDefinition->replaceArgument(0, $storeDefinitions);
2070.                 $container->setDefinition($storeDefinitionId = '.lock.'.$resourceName.'.store.'.$container->hash($resourceStores), $combinedDefinition);
2071.             }
2073.             // Generate factories for each resource
2074.             $factoryDefinition = new ChildDefinition('lock.factory.abstract');
2075.             $factoryDefinition->replaceArgument(0, new Reference($storeDefinitionId));
2076.             $container->setDefinition('lock.'.$resourceName.'.factory', $factoryDefinition);
2078.             // provide alias for default resource
2079.             if ('default' === $resourceName) {
2080.                 $container->setAlias('lock.factory', new Alias('lock.'.$resourceName.'.factory', false));
2081.                 $container->setAlias(LockFactory::class, new Alias('lock.factory', false));
2082.             } else {
2083.                 $container->registerAliasForArgument('lock.'.$resourceName.'.factory', LockFactory::class, $resourceName.'.lock.factory');
2084.             }
2085.         }
2086.     }
2088.     private function registerSemaphoreConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
2089.     {
2090.         $loader->load('semaphore.php');
2092.         foreach ($config['resources'] as $resourceName => $resourceStore) {
2093.             $storeDsn = $container->resolveEnvPlaceholders($resourceStore, null, $usedEnvs);
2094.             $storeDefinition = new Definition(SemaphoreStoreInterface::class);
2095.             $storeDefinition->setFactory([SemaphoreStoreFactory::class, 'createStore']);
2096.             $storeDefinition->setArguments([$resourceStore]);
2098.             $container->setDefinition($storeDefinitionId = '.semaphore.'.$resourceName.'.store.'.$container->hash($storeDsn), $storeDefinition);
2100.             // Generate factories for each resource
2101.             $factoryDefinition = new ChildDefinition('semaphore.factory.abstract');
2102.             $factoryDefinition->replaceArgument(0, new Reference($storeDefinitionId));
2103.             $container->setDefinition('semaphore.'.$resourceName.'.factory', $factoryDefinition);
2105.             // Generate services for semaphore instances
2106.             $semaphoreDefinition = new Definition(Semaphore::class);
2107.             $semaphoreDefinition->setFactory([new Reference('semaphore.'.$resourceName.'.factory'), 'createSemaphore']);
2108.             $semaphoreDefinition->setArguments([$resourceName]);
2110.             // provide alias for default resource
2111.             if ('default' === $resourceName) {
2112.                 $container->setAlias('semaphore.factory', new Alias('semaphore.'.$resourceName.'.factory', false));
2113.                 $container->setAlias(SemaphoreFactory::class, new Alias('semaphore.factory', false));
2114.             } else {
2115.                 $container->registerAliasForArgument('semaphore.'.$resourceName.'.factory', SemaphoreFactory::class, $resourceName.'.semaphore.factory');
2116.             }
2117.         }
2118.     }
2120.     private function registerSchedulerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
2121.     {
2122.         if (!class_exists(SchedulerTransportFactory::class)) {
2123.             throw new LogicException('Scheduler support cannot be enabled as the Scheduler component is not installed. Try running "composer require symfony/scheduler".');
2124.         }
2126.         $loader->load('scheduler.php');
2128.         if (!$this->hasConsole()) {
2129.             $container->removeDefinition('console.command.scheduler_debug');
2130.         }
2131.     }
2133.     private function registerMessengerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader, bool $validationEnabled): void
2134.     {
2135.         if (!interface_exists(MessageBusInterface::class)) {
2136.             throw new LogicException('Messenger support cannot be enabled as the Messenger component is not installed. Try running "composer require symfony/messenger".');
2137.         }
2139.         if (!$this->hasConsole()) {
2140.             $container->removeDefinition('console.command.messenger_stats');
2141.         }
2143.         $loader->load('messenger.php');
2145.         if (!interface_exists(DenormalizerInterface::class)) {
2146.             $container->removeDefinition('serializer.normalizer.flatten_exception');
2147.         }
2149.         if (ContainerBuilder::willBeAvailable('symfony/amqp-messenger', MessengerBridge\Amqp\Transport\AmqpTransportFactory::class, ['symfony/framework-bundle', 'symfony/messenger'])) {
2150.             $container->getDefinition('messenger.transport.amqp.factory')->addTag('messenger.transport_factory');
2151.         }
2153.         if (ContainerBuilder::willBeAvailable('symfony/redis-messenger', MessengerBridge\Redis\Transport\RedisTransportFactory::class, ['symfony/framework-bundle', 'symfony/messenger'])) {
2154.             $container->getDefinition('messenger.transport.redis.factory')->addTag('messenger.transport_factory');
2155.         }
2157.         if (ContainerBuilder::willBeAvailable('symfony/amazon-sqs-messenger', MessengerBridge\AmazonSqs\Transport\AmazonSqsTransportFactory::class, ['symfony/framework-bundle', 'symfony/messenger'])) {
2158.             $container->getDefinition('messenger.transport.sqs.factory')->addTag('messenger.transport_factory');
2159.         }
2161.         if (ContainerBuilder::willBeAvailable('symfony/beanstalkd-messenger', MessengerBridge\Beanstalkd\Transport\BeanstalkdTransportFactory::class, ['symfony/framework-bundle', 'symfony/messenger'])) {
2162.             $container->getDefinition('messenger.transport.beanstalkd.factory')->addTag('messenger.transport_factory');
2163.         }
2165.         if ($config['stop_worker_on_signals'] && $this->hasConsole()) {
2166.             $container->getDefinition('console.command.messenger_consume_messages')
2167.                 ->replaceArgument(8, $config['stop_worker_on_signals']);
2168.             $container->getDefinition('console.command.messenger_failed_messages_retry')
2169.                 ->replaceArgument(6, $config['stop_worker_on_signals']);
2170.         }
2172.         if ($this->hasConsole() && $container->hasDefinition('messenger.listener.stop_worker_signals_listener')) {
2173.             $container->getDefinition('messenger.listener.stop_worker_signals_listener')->clearTag('kernel.event_subscriber');
2174.         }
2175.         if (!class_exists(StopWorkerOnSignalsListener::class)) {
2176.             $container->removeDefinition('messenger.listener.stop_worker_signals_listener');
2177.         } elseif ($config['stop_worker_on_signals']) {
2178.             $container->getDefinition('messenger.listener.stop_worker_signals_listener')->replaceArgument(0, $config['stop_worker_on_signals']);
2179.         }
2181.         if (null === $config['default_bus'] && 1 === \count($config['buses'])) {
2182.             $config['default_bus'] = key($config['buses']);
2183.         }
2185.         $defaultMiddleware = [
2186.             'before' => [
2187.                 ['id' => 'add_bus_name_stamp_middleware'],
2188.                 ['id' => 'reject_redelivered_message_middleware'],
2189.                 ['id' => 'dispatch_after_current_bus'],
2190.                 ['id' => 'failed_message_processing_middleware'],
2191.             ],
2192.             'after' => [
2193.                 ['id' => 'send_message'],
2194.                 ['id' => 'handle_message'],
2195.             ],
2196.         ];
2197.         foreach ($config['buses'] as $busId => $bus) {
2198.             $middleware = $bus['middleware'];
2200.             if ($bus['default_middleware']['enabled']) {
2201.                 $defaultMiddleware['after'][0]['arguments'] = [$bus['default_middleware']['allow_no_senders']];
2202.                 $defaultMiddleware['after'][1]['arguments'] = [$bus['default_middleware']['allow_no_handlers']];
2204.                 // argument to add_bus_name_stamp_middleware
2205.                 $defaultMiddleware['before'][0]['arguments'] = [$busId];
2207.                 $middleware = array_merge($defaultMiddleware['before'], $middleware, $defaultMiddleware['after']);
2208.             }
2210.             foreach ($middleware as $middlewareItem) {
2211.                 if (!$validationEnabled && \in_array($middlewareItem['id'], ['validation', 'messenger.middleware.validation'], true)) {
2212.                     throw new LogicException('The Validation middleware is only available when the Validator component is installed and enabled. Try running "composer require symfony/validator".');
2213.                 }
2214.             }
2216.             if ($container->getParameter('kernel.debug') && class_exists(Stopwatch::class)) {
2217.                 array_unshift($middleware, ['id' => 'traceable', 'arguments' => [$busId]]);
2218.             }
2220.             $container->setParameter($busId.'.middleware', $middleware);
2221.             $container->register($busId, MessageBus::class)->addArgument([])->addTag('messenger.bus');
2223.             if ($busId === $config['default_bus']) {
2224.                 $container->setAlias('messenger.default_bus', $busId)->setPublic(true);
2225.                 $container->setAlias(MessageBusInterface::class, $busId);
2226.             } else {
2227.                 $container->registerAliasForArgument($busId, MessageBusInterface::class);
2228.             }
2229.         }
2231.         if (empty($config['transports'])) {
2232.             $container->removeDefinition('messenger.transport.symfony_serializer');
2233.             $container->removeDefinition('messenger.transport.amqp.factory');
2234.             $container->removeDefinition('messenger.transport.redis.factory');
2235.             $container->removeDefinition('messenger.transport.sqs.factory');
2236.             $container->removeDefinition('messenger.transport.beanstalkd.factory');
2237.             $container->removeAlias(SerializerInterface::class);
2238.         } else {
2239.             $container->getDefinition('messenger.transport.symfony_serializer')
2240.                 ->replaceArgument(1, $config['serializer']['symfony_serializer']['format'])
2241.                 ->replaceArgument(2, $config['serializer']['symfony_serializer']['context']);
2242.             $container->setAlias('messenger.default_serializer', $config['serializer']['default_serializer']);
2243.         }
2245.         $failureTransports = [];
2246.         if ($config['failure_transport']) {
2247.             if (!isset($config['transports'][$config['failure_transport']])) {
2248.                 throw new LogicException(sprintf('Invalid Messenger configuration: the failure transport "%s" is not a valid transport or service id.', $config['failure_transport']));
2249.             }
2251.             $container->setAlias('messenger.failure_transports.default', 'messenger.transport.'.$config['failure_transport']);
2252.             $failureTransports[] = $config['failure_transport'];
2253.         }
2255.         $failureTransportsByName = [];
2256.         foreach ($config['transports'] as $name => $transport) {
2257.             if ($transport['failure_transport']) {
2258.                 $failureTransports[] = $transport['failure_transport'];
2259.                 $failureTransportsByName[$name] = $transport['failure_transport'];
2260.             } elseif ($config['failure_transport']) {
2261.                 $failureTransportsByName[$name] = $config['failure_transport'];
2262.             }
2263.         }
2265.         $senderAliases = [];
2266.         $transportRetryReferences = [];
2267.         $transportRateLimiterReferences = [];
2268.         foreach ($config['transports'] as $name => $transport) {
2269.             $serializerId = $transport['serializer'] ?? 'messenger.default_serializer';
2270.             $transportDefinition = (new Definition(TransportInterface::class))
2271.                 ->setFactory([new Reference('messenger.transport_factory'), 'createTransport'])
2272.                 ->setArguments([$transport['dsn'], $transport['options'] + ['transport_name' => $name], new Reference($serializerId)])
2273.                 ->addTag('messenger.receiver', [
2274.                         'alias' => $name,
2275.                         'is_failure_transport' => \in_array($name, $failureTransports),
2276.                     ]
2277.                 )
2278.             ;
2279.             $container->setDefinition($transportId = 'messenger.transport.'.$name, $transportDefinition);
2280.             $senderAliases[$name] = $transportId;
2282.             if (null !== $transport['retry_strategy']['service']) {
2283.                 $transportRetryReferences[$name] = new Reference($transport['retry_strategy']['service']);
2284.             } else {
2285.                 $retryServiceId = sprintf('messenger.retry.multiplier_retry_strategy.%s', $name);
2286.                 $retryDefinition = new ChildDefinition('messenger.retry.abstract_multiplier_retry_strategy');
2287.                 $retryDefinition
2288.                     ->replaceArgument(0, $transport['retry_strategy']['max_retries'])
2289.                     ->replaceArgument(1, $transport['retry_strategy']['delay'])
2290.                     ->replaceArgument(2, $transport['retry_strategy']['multiplier'])
2291.                     ->replaceArgument(3, $transport['retry_strategy']['max_delay']);
2292.                 $container->setDefinition($retryServiceId, $retryDefinition);
2294.                 $transportRetryReferences[$name] = new Reference($retryServiceId);
2295.             }
2297.             if ($transport['rate_limiter']) {
2298.                 if (!interface_exists(LimiterInterface::class)) {
2299.                     throw new LogicException('Rate limiter cannot be used within Messenger as the RateLimiter component is not installed. Try running "composer require symfony/rate-limiter".');
2300.                 }
2302.                 $transportRateLimiterReferences[$name] = new Reference('limiter.'.$transport['rate_limiter']);
2303.             }
2304.         }
2306.         $senderReferences = [];
2307.         // alias => service_id
2308.         foreach ($senderAliases as $alias => $serviceId) {
2309.             $senderReferences[$alias] = new Reference($serviceId);
2310.         }
2311.         // service_id => service_id
2312.         foreach ($senderAliases as $serviceId) {
2313.             $senderReferences[$serviceId] = new Reference($serviceId);
2314.         }
2316.         foreach ($config['transports'] as $name => $transport) {
2317.             if ($transport['failure_transport']) {
2318.                 if (!isset($senderReferences[$transport['failure_transport']])) {
2319.                     throw new LogicException(sprintf('Invalid Messenger configuration: the failure transport "%s" is not a valid transport or service id.', $transport['failure_transport']));
2320.                 }
2321.             }
2322.         }
2324.         $failureTransportReferencesByTransportName = array_map(fn ($failureTransportName) => $senderReferences[$failureTransportName], $failureTransportsByName);
2326.         $messageToSendersMapping = [];
2327.         foreach ($config['routing'] as $message => $messageConfiguration) {
2328.             if ('*' !== $message && !class_exists($message) && !interface_exists($message, false) && !preg_match('/^(?:[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+\\\\)++\*$/', $message)) {
2329.                 if (str_contains($message, '*')) {
2330.                     throw new LogicException(sprintf('Invalid Messenger routing configuration: invalid namespace "%s" wildcard.', $message));
2331.                 }
2333.                 throw new LogicException(sprintf('Invalid Messenger routing configuration: class or interface "%s" not found.', $message));
2334.             }
2336.             // make sure senderAliases contains all senders
2337.             foreach ($messageConfiguration['senders'] as $sender) {
2338.                 if (!isset($senderReferences[$sender])) {
2339.                     throw new LogicException(sprintf('Invalid Messenger routing configuration: the "%s" class is being routed to a sender called "%s". This is not a valid transport or service id.', $message, $sender));
2340.                 }
2341.             }
2343.             $messageToSendersMapping[$message] = $messageConfiguration['senders'];
2344.         }
2346.         $sendersServiceLocator = ServiceLocatorTagPass::register($container, $senderReferences);
2348.         $container->getDefinition('messenger.senders_locator')
2349.             ->replaceArgument(0, $messageToSendersMapping)
2350.             ->replaceArgument(1, $sendersServiceLocator)
2351.         ;
2353.         $container->getDefinition('messenger.retry.send_failed_message_for_retry_listener')
2354.             ->replaceArgument(0, $sendersServiceLocator)
2355.         ;
2357.         $container->getDefinition('messenger.retry_strategy_locator')
2358.             ->replaceArgument(0, $transportRetryReferences);
2360.         if (!$transportRateLimiterReferences) {
2361.             $container->removeDefinition('messenger.rate_limiter_locator');
2362.         } else {
2363.             $container->getDefinition('messenger.rate_limiter_locator')
2364.                 ->replaceArgument(0, $transportRateLimiterReferences);
2365.         }
2367.         if (\count($failureTransports) > 0) {
2368.             if ($this->hasConsole()) {
2369.                 $container->getDefinition('console.command.messenger_failed_messages_retry')
2370.                     ->replaceArgument(0, $config['failure_transport']);
2371.                 $container->getDefinition('console.command.messenger_failed_messages_show')
2372.                     ->replaceArgument(0, $config['failure_transport']);
2373.                 $container->getDefinition('console.command.messenger_failed_messages_remove')
2374.                     ->replaceArgument(0, $config['failure_transport']);
2375.             }
2377.             $failureTransportsByTransportNameServiceLocator = ServiceLocatorTagPass::register($container, $failureTransportReferencesByTransportName);
2378.             $container->getDefinition('messenger.failure.send_failed_message_to_failure_transport_listener')
2379.                 ->replaceArgument(0, $failureTransportsByTransportNameServiceLocator);
2380.         } else {
2381.             $container->removeDefinition('messenger.failure.send_failed_message_to_failure_transport_listener');
2382.             $container->removeDefinition('console.command.messenger_failed_messages_retry');
2383.             $container->removeDefinition('console.command.messenger_failed_messages_show');
2384.             $container->removeDefinition('console.command.messenger_failed_messages_remove');
2385.         }
2387.         if (!$container->hasDefinition('console.command.messenger_consume_messages')) {
2388.             $container->removeDefinition('messenger.listener.reset_services');
2389.         }
2390.     }
2392.     private function registerCacheConfiguration(array $config, ContainerBuilder $container): void
2393.     {
2394.         $version = new Parameter('container.build_id');
2395.         $container->getDefinition('cache.adapter.apcu')->replaceArgument(2, $version);
2396.         $container->getDefinition('cache.adapter.system')->replaceArgument(2, $version);
2397.         $container->getDefinition('cache.adapter.filesystem')->replaceArgument(2, $config['directory']);
2399.         if (isset($config['prefix_seed'])) {
2400.             $container->setParameter('cache.prefix.seed', $config['prefix_seed']);
2401.         }
2402.         if ($container->hasParameter('cache.prefix.seed')) {
2403.             // Inline any env vars referenced in the parameter
2404.             $container->setParameter('cache.prefix.seed', $container->resolveEnvPlaceholders($container->getParameter('cache.prefix.seed'), true));
2405.         }
2406.         foreach (['psr6', 'redis', 'memcached', 'doctrine_dbal', 'pdo'] as $name) {
2407.             if (isset($config[$name = 'default_'.$name.'_provider'])) {
2408.                 $container->setAlias('cache.'.$name, new Alias(CachePoolPass::getServiceProvider($container, $config[$name]), false));
2409.             }
2410.         }
2411.         foreach (['app', 'system'] as $name) {
2412.             $config['pools']['cache.'.$name] = [
2413.                 'adapters' => [$config[$name]],
2414.                 'public' => true,
2415.                 'tags' => false,
2416.             ];
2417.         }
2418.         foreach ($config['pools'] as $name => $pool) {
2419.             $pool['adapters'] = $pool['adapters'] ?: ['cache.app'];
2421.             $isRedisTagAware = ['cache.adapter.redis_tag_aware'] === $pool['adapters'];
2422.             foreach ($pool['adapters'] as $provider => $adapter) {
2423.                 if (($config['pools'][$adapter]['adapters'] ?? null) === ['cache.adapter.redis_tag_aware']) {
2424.                     $isRedisTagAware = true;
2425.                 } elseif ($config['pools'][$adapter]['tags'] ?? false) {
2426.                     $pool['adapters'][$provider] = $adapter = '.'.$adapter.'.inner';
2427.                 }
2428.             }
2430.             if (1 === \count($pool['adapters'])) {
2431.                 if (!isset($pool['provider']) && !\is_int($provider)) {
2432.                     $pool['provider'] = $provider;
2433.                 }
2434.                 $definition = new ChildDefinition($adapter);
2435.             } else {
2436.                 $definition = new Definition(ChainAdapter::class, [$pool['adapters'], 0]);
2437.                 $pool['reset'] = 'reset';
2438.             }
2440.             if ($isRedisTagAware && 'cache.app' === $name) {
2441.                 $container->setAlias('cache.app.taggable', $name);
2442.                 $definition->addTag('cache.taggable', ['pool' => $name]);
2443.             } elseif ($isRedisTagAware) {
2444.                 $tagAwareId = $name;
2445.                 $container->setAlias('.'.$name.'.inner', $name);
2446.                 $definition->addTag('cache.taggable', ['pool' => $name]);
2447.             } elseif ($pool['tags']) {
2448.                 if (true !== $pool['tags'] && ($config['pools'][$pool['tags']]['tags'] ?? false)) {
2449.                     $pool['tags'] = '.'.$pool['tags'].'.inner';
2450.                 }
2451.                 $container->register($name, TagAwareAdapter::class)
2452.                     ->addArgument(new Reference('.'.$name.'.inner'))
2453.                     ->addArgument(true !== $pool['tags'] ? new Reference($pool['tags']) : null)
2454.                     ->addMethodCall('setLogger', [new Reference('logger', ContainerInterface::IGNORE_ON_INVALID_REFERENCE)])
2455.                     ->setPublic($pool['public'])
2456.                     ->addTag('cache.taggable', ['pool' => $name])
2457.                     ->addTag('monolog.logger', ['channel' => 'cache']);
2459.                 $pool['name'] = $tagAwareId = $name;
2460.                 $pool['public'] = false;
2461.                 $name = '.'.$name.'.inner';
2462.             } elseif (!\in_array($name, ['cache.app', 'cache.system'], true)) {
2463.                 $tagAwareId = '.'.$name.'.taggable';
2464.                 $container->register($tagAwareId, TagAwareAdapter::class)
2465.                     ->addArgument(new Reference($name))
2466.                     ->addTag('cache.taggable', ['pool' => $name])
2467.                 ;
2468.             }
2470.             if (!\in_array($name, ['cache.app', 'cache.system'], true)) {
2471.                 $container->registerAliasForArgument($tagAwareId, TagAwareCacheInterface::class, $pool['name'] ?? $name);
2472.                 $container->registerAliasForArgument($name, CacheInterface::class, $pool['name'] ?? $name);
2473.                 $container->registerAliasForArgument($name, CacheItemPoolInterface::class, $pool['name'] ?? $name);
2474.             }
2476.             $definition->setPublic($pool['public']);
2477.             unset($pool['adapters'], $pool['public'], $pool['tags']);
2479.             $definition->addTag('cache.pool', $pool);
2480.             $container->setDefinition($name, $definition);
2481.         }
2483.         if (class_exists(PropertyAccessor::class)) {
2484.             $propertyAccessDefinition = $container->register('cache.property_access', AdapterInterface::class);
2486.             if (!$container->getParameter('kernel.debug')) {
2487.                 $propertyAccessDefinition->setFactory([PropertyAccessor::class, 'createCache']);
2488.                 $propertyAccessDefinition->setArguments(['', 0, $version, new Reference('logger', ContainerInterface::IGNORE_ON_INVALID_REFERENCE)]);
2489.                 $propertyAccessDefinition->addTag('cache.pool', ['clearer' => 'cache.system_clearer']);
2490.                 $propertyAccessDefinition->addTag('monolog.logger', ['channel' => 'cache']);
2491.             } else {
2492.                 $propertyAccessDefinition->setClass(ArrayAdapter::class);
2493.                 $propertyAccessDefinition->setArguments([0, false]);
2494.             }
2495.         }
2496.     }
2498.     private function registerHttpClientConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
2499.     {
2500.         $loader->load('http_client.php');
2502.         $options = $config['default_options'] ?? [];
2503.         $retryOptions = $options['retry_failed'] ?? ['enabled' => false];
2504.         unset($options['retry_failed']);
2505.         $defaultUriTemplateVars = $options['vars'] ?? [];
2506.         unset($options['vars']);
2507.         $container->getDefinition('http_client.transport')->setArguments([$options, $config['max_host_connections'] ?? 6]);
2509.         if (!class_exists(PingWebhookMessageHandler::class)) {
2510.             $container->removeDefinition('http_client.messenger.ping_webhook_handler');
2511.         }
2513.         if (!$hasPsr18 = ContainerBuilder::willBeAvailable('psr/http-client', ClientInterface::class, ['symfony/framework-bundle', 'symfony/http-client'])) {
2514.             $container->removeDefinition('psr18.http_client');
2515.             $container->removeAlias(ClientInterface::class);
2516.         }
2518.         if (!$hasHttplug = ContainerBuilder::willBeAvailable('php-http/httplug', HttpAsyncClient::class, ['symfony/framework-bundle', 'symfony/http-client'])) {
2519.             $container->removeDefinition('httplug.http_client');
2520.             $container->removeAlias(HttpAsyncClient::class);
2521.             $container->removeAlias(HttpClient::class);
2522.         }
2524.         if ($this->readConfigEnabled('http_client.retry_failed', $container, $retryOptions)) {
2525.             $this->registerRetryableHttpClient($retryOptions, 'http_client', $container);
2526.         }
2528.         if (ContainerBuilder::willBeAvailable('guzzlehttp/uri-template', \GuzzleHttp\UriTemplate\UriTemplate::class, [])) {
2529.             $container->setAlias('http_client.uri_template_expander', 'http_client.uri_template_expander.guzzle');
2530.         } elseif (ContainerBuilder::willBeAvailable('rize/uri-template', \Rize\UriTemplate::class, [])) {
2531.             $container->setAlias('http_client.uri_template_expander', 'http_client.uri_template_expander.rize');
2532.         }
2534.         $container
2535.             ->getDefinition('http_client.uri_template')
2536.             ->setArgument(2, $defaultUriTemplateVars);
2538.         foreach ($config['scoped_clients'] as $name => $scopeConfig) {
2539.             if ($container->has($name)) {
2540.                 throw new InvalidArgumentException(sprintf('Invalid scope name: "%s" is reserved.', $name));
2541.             }
2543.             $scope = $scopeConfig['scope'] ?? null;
2544.             unset($scopeConfig['scope']);
2545.             $retryOptions = $scopeConfig['retry_failed'] ?? ['enabled' => false];
2546.             unset($scopeConfig['retry_failed']);
2548.             if (null === $scope) {
2549.                 $baseUri = $scopeConfig['base_uri'];
2550.                 unset($scopeConfig['base_uri']);
2552.                 $container->register($name, ScopingHttpClient::class)
2553.                     ->setFactory([ScopingHttpClient::class, 'forBaseUri'])
2554.                     ->setArguments([new Reference('http_client.transport'), $baseUri, $scopeConfig])
2555.                     ->addTag('http_client.client')
2556.                 ;
2557.             } else {
2558.                 $container->register($name, ScopingHttpClient::class)
2559.                     ->setArguments([new Reference('http_client.transport'), [$scope => $scopeConfig], $scope])
2560.                     ->addTag('http_client.client')
2561.                 ;
2562.             }
2564.             if ($this->readConfigEnabled('http_client.scoped_clients.'.$name.'.retry_failed', $container, $retryOptions)) {
2565.                 $this->registerRetryableHttpClient($retryOptions, $name, $container);
2566.             }
2568.             $container
2569.                 ->register($name.'.uri_template', UriTemplateHttpClient::class)
2570.                 ->setDecoratedService($name, null, 7) // Between TraceableHttpClient (5) and RetryableHttpClient (10)
2571.                 ->setArguments([
2572.                     new Reference($name.'.uri_template.inner'),
2573.                     new Reference('http_client.uri_template_expander', ContainerInterface::NULL_ON_INVALID_REFERENCE),
2574.                     $defaultUriTemplateVars,
2575.                 ]);
2577.             $container->registerAliasForArgument($name, HttpClientInterface::class);
2579.             if ($hasPsr18) {
2580.                 $container->setDefinition('psr18.'.$name, new ChildDefinition('psr18.http_client'))
2581.                     ->replaceArgument(0, new Reference($name));
2583.                 $container->registerAliasForArgument('psr18.'.$name, ClientInterface::class, $name);
2584.             }
2586.             if ($hasHttplug) {
2587.                 $container->setDefinition('httplug.'.$name, new ChildDefinition('httplug.http_client'))
2588.                     ->replaceArgument(0, new Reference($name));
2590.                 $container->registerAliasForArgument('httplug.'.$name, HttpAsyncClient::class, $name);
2591.             }
2592.         }
2594.         if ($responseFactoryId = $config['mock_response_factory'] ?? null) {
2595.             $container->register('http_client.mock_client', MockHttpClient::class)
2596.                 ->setDecoratedService('http_client.transport', null, -10)  // lower priority than TraceableHttpClient (5)
2597.                 ->setArguments([new Reference($responseFactoryId)]);
2598.         }
2599.     }
2601.     private function registerRetryableHttpClient(array $options, string $name, ContainerBuilder $container): void
2602.     {
2603.         if (null !== $options['retry_strategy']) {
2604.             $retryStrategy = new Reference($options['retry_strategy']);
2605.         } else {
2606.             $retryStrategy = new ChildDefinition('http_client.abstract_retry_strategy');
2607.             $codes = [];
2608.             foreach ($options['http_codes'] as $code => $codeOptions) {
2609.                 if ($codeOptions['methods']) {
2610.                     $codes[$code] = $codeOptions['methods'];
2611.                 } else {
2612.                     $codes[] = $code;
2613.                 }
2614.             }
2616.             $retryStrategy
2617.                 ->replaceArgument(0, $codes ?: GenericRetryStrategy::DEFAULT_RETRY_STATUS_CODES)
2618.                 ->replaceArgument(1, $options['delay'])
2619.                 ->replaceArgument(2, $options['multiplier'])
2620.                 ->replaceArgument(3, $options['max_delay'])
2621.                 ->replaceArgument(4, $options['jitter']);
2622.             $container->setDefinition($name.'.retry_strategy', $retryStrategy);
2624.             $retryStrategy = new Reference($name.'.retry_strategy');
2625.         }
2627.         $container
2628.             ->register($name.'.retryable', RetryableHttpClient::class)
2629.             ->setDecoratedService($name, null, 10) // higher priority than TraceableHttpClient (5)
2630.             ->setArguments([new Reference($name.'.retryable.inner'), $retryStrategy, $options['max_retries'], new Reference('logger')])
2631.             ->addTag('monolog.logger', ['channel' => 'http_client']);
2632.     }
2634.     private function registerMailerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader, bool $webhookEnabled): void
2635.     {
2636.         if (!class_exists(Mailer::class)) {
2637.             throw new LogicException('Mailer support cannot be enabled as the component is not installed. Try running "composer require symfony/mailer".');
2638.         }
2640.         $loader->load('mailer.php');
2641.         $loader->load('mailer_transports.php');
2642.         if (!\count($config['transports']) && null === $config['dsn']) {
2643.             $config['dsn'] = 'smtp://null';
2644.         }
2645.         $transports = $config['dsn'] ? ['main' => $config['dsn']] : $config['transports'];
2646.         $container->getDefinition('mailer.transports')->setArgument(0, $transports);
2647.         $container->getDefinition('mailer.default_transport')->setArgument(0, current($transports));
2649.         $mailer = $container->getDefinition('mailer.mailer');
2650.         if (false === $messageBus = $config['message_bus']) {
2651.             $mailer->replaceArgument(1, null);
2652.         } else {
2653.             $mailer->replaceArgument(1, $messageBus ? new Reference($messageBus) : new Reference('messenger.default_bus', ContainerInterface::NULL_ON_INVALID_REFERENCE));
2654.         }
2656.         $classToServices = [
2657.             MailerBridge\Brevo\Transport\BrevoTransportFactory::class => 'mailer.transport_factory.brevo',
2658.             MailerBridge\Google\Transport\GmailTransportFactory::class => 'mailer.transport_factory.gmail',
2659.             MailerBridge\Infobip\Transport\InfobipTransportFactory::class => 'mailer.transport_factory.infobip',
2660.             MailerBridge\MailerSend\Transport\MailerSendTransportFactory::class => 'mailer.transport_factory.mailersend',
2661.             MailerBridge\Mailgun\Transport\MailgunTransportFactory::class => 'mailer.transport_factory.mailgun',
2662.             MailerBridge\Mailjet\Transport\MailjetTransportFactory::class => 'mailer.transport_factory.mailjet',
2663.             MailerBridge\MailPace\Transport\MailPaceTransportFactory::class => 'mailer.transport_factory.mailpace',
2664.             MailerBridge\Mailchimp\Transport\MandrillTransportFactory::class => 'mailer.transport_factory.mailchimp',
2665.             MailerBridge\OhMySmtp\Transport\OhMySmtpTransportFactory::class => 'mailer.transport_factory.ohmysmtp',
2666.             MailerBridge\Postmark\Transport\PostmarkTransportFactory::class => 'mailer.transport_factory.postmark',
2667.             MailerBridge\Scaleway\Transport\ScalewayTransportFactory::class => 'mailer.transport_factory.scaleway',
2668.             MailerBridge\Sendgrid\Transport\SendgridTransportFactory::class => 'mailer.transport_factory.sendgrid',
2669.             MailerBridge\Sendinblue\Transport\SendinblueTransportFactory::class => 'mailer.transport_factory.sendinblue',
2670.             MailerBridge\Amazon\Transport\SesTransportFactory::class => 'mailer.transport_factory.amazon',
2671.         ];
2673.         foreach ($classToServices as $class => $service) {
2674.             $package = substr($service, \strlen('mailer.transport_factory.'));
2676.             if (!ContainerBuilder::willBeAvailable(sprintf('symfony/%s-mailer', 'gmail' === $package ? 'google' : $package), $class, ['symfony/framework-bundle', 'symfony/mailer'])) {
2677.                 $container->removeDefinition($service);
2678.             }
2679.         }
2681.         if ($webhookEnabled) {
2682.             $webhookRequestParsers = [
2683.                 MailerBridge\Brevo\Webhook\BrevoRequestParser::class => 'mailer.webhook.request_parser.brevo',
2684.                 MailerBridge\Mailgun\Webhook\MailgunRequestParser::class => 'mailer.webhook.request_parser.mailgun',
2685.                 MailerBridge\Mailjet\Webhook\MailjetRequestParser::class => 'mailer.webhook.request_parser.mailjet',
2686.                 MailerBridge\Postmark\Webhook\PostmarkRequestParser::class => 'mailer.webhook.request_parser.postmark',
2687.                 MailerBridge\Sendgrid\Webhook\SendgridRequestParser::class => 'mailer.webhook.request_parser.sendgrid',
2688.             ];
2690.             foreach ($webhookRequestParsers as $class => $service) {
2691.                 $package = substr($service, \strlen('mailer.webhook.request_parser.'));
2693.                 if (!ContainerBuilder::willBeAvailable(sprintf('symfony/%s-mailer', 'gmail' === $package ? 'google' : $package), $class, ['symfony/framework-bundle', 'symfony/mailer'])) {
2694.                     $container->removeDefinition($service);
2695.                 }
2696.             }
2697.         }
2699.         $envelopeListener = $container->getDefinition('mailer.envelope_listener');
2700.         $envelopeListener->setArgument(0, $config['envelope']['sender'] ?? null);
2701.         $envelopeListener->setArgument(1, $config['envelope']['recipients'] ?? null);
2703.         if ($config['headers']) {
2704.             $headers = new Definition(Headers::class);
2705.             foreach ($config['headers'] as $name => $data) {
2706.                 $value = $data['value'];
2707.                 if (\in_array(strtolower($name), ['from', 'to', 'cc', 'bcc', 'reply-to'])) {
2708.                     $value = (array) $value;
2709.                 }
2710.                 $headers->addMethodCall('addHeader', [$name, $value]);
2711.             }
2712.             $messageListener = $container->getDefinition('mailer.message_listener');
2713.             $messageListener->setArgument(0, $headers);
2714.         } else {
2715.             $container->removeDefinition('mailer.message_listener');
2716.         }
2718.         if (!class_exists(MessengerTransportListener::class)) {
2719.             $container->removeDefinition('mailer.messenger_transport_listener');
2720.         }
2722.         if ($webhookEnabled) {
2723.             $loader->load('mailer_webhook.php');
2724.         }
2725.     }
2727.     private function registerNotifierConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader, bool $webhookEnabled): void
2728.     {
2729.         if (!class_exists(Notifier::class)) {
2730.             throw new LogicException('Notifier support cannot be enabled as the component is not installed. Try running "composer require symfony/notifier".');
2731.         }
2733.         $loader->load('notifier.php');
2734.         $loader->load('notifier_transports.php');
2736.         if ($config['chatter_transports']) {
2737.             $container->getDefinition('chatter.transports')->setArgument(0, $config['chatter_transports']);
2738.         } else {
2739.             $container->removeDefinition('chatter');
2740.             $container->removeAlias(ChatterInterface::class);
2741.         }
2742.         if ($config['texter_transports']) {
2743.             $container->getDefinition('texter.transports')->setArgument(0, $config['texter_transports']);
2744.         } else {
2745.             $container->removeDefinition('texter');
2746.             $container->removeAlias(TexterInterface::class);
2747.         }
2749.         if ($this->isInitializedConfigEnabled('mailer')) {
2750.             $sender = $container->getDefinition('mailer.envelope_listener')->getArgument(0);
2751.             $container->getDefinition('notifier.channel.email')->setArgument(2, $sender);
2752.         } else {
2753.             $container->removeDefinition('notifier.channel.email');
2754.         }
2756.         foreach (['texter', 'chatter', 'notifier.channel.chat', 'notifier.channel.email', 'notifier.channel.sms'] as $serviceId) {
2757.             if (!$container->hasDefinition($serviceId)) {
2758.                 continue;
2759.             }
2761.             if (false === $messageBus = $config['message_bus']) {
2762.                 $container->getDefinition($serviceId)->replaceArgument(1, null);
2763.             } else {
2764.                 $container->getDefinition($serviceId)->replaceArgument(1, $messageBus ? new Reference($messageBus) : new Reference('messenger.default_bus', ContainerInterface::NULL_ON_INVALID_REFERENCE));
2765.             }
2766.         }
2768.         if ($this->isInitializedConfigEnabled('messenger')) {
2769.             if ($config['notification_on_failed_messages']) {
2770.                 $container->getDefinition('notifier.failed_message_listener')->addTag('kernel.event_subscriber');
2771.             }
2773.             // as we have a bus, the channels don't need the transports
2774.             $container->getDefinition('notifier.channel.chat')->setArgument(0, null);
2775.             if ($container->hasDefinition('notifier.channel.email')) {
2776.                 $container->getDefinition('notifier.channel.email')->setArgument(0, null);
2777.             }
2778.             $container->getDefinition('notifier.channel.sms')->setArgument(0, null);
2779.             $container->getDefinition('notifier.channel.push')->setArgument(0, null);
2780.         }
2782.         $container->getDefinition('notifier.channel_policy')->setArgument(0, $config['channel_policy']);
2784.         $container->registerForAutoconfiguration(NotifierTransportFactoryInterface::class)
2785.             ->addTag('chatter.transport_factory');
2787.         $container->registerForAutoconfiguration(NotifierTransportFactoryInterface::class)
2788.             ->addTag('texter.transport_factory');
2790.         $classToServices = [
2791.             NotifierBridge\AllMySms\AllMySmsTransportFactory::class => 'notifier.transport_factory.all-my-sms',
2792.             NotifierBridge\AmazonSns\AmazonSnsTransportFactory::class => 'notifier.transport_factory.amazon-sns',
2793.             NotifierBridge\Bandwidth\BandwidthTransportFactory::class => 'notifier.transport_factory.bandwidth',
2794.             NotifierBridge\Brevo\BrevoTransportFactory::class => 'notifier.transport_factory.brevo',
2795.             NotifierBridge\Chatwork\ChatworkTransportFactory::class => 'notifier.transport_factory.chatwork',
2796.             NotifierBridge\Clickatell\ClickatellTransportFactory::class => 'notifier.transport_factory.clickatell',
2797.             NotifierBridge\ClickSend\ClickSendTransportFactory::class => 'notifier.transport_factory.click-send',
2798.             NotifierBridge\ContactEveryone\ContactEveryoneTransportFactory::class => 'notifier.transport_factory.contact-everyone',
2799.             NotifierBridge\Discord\DiscordTransportFactory::class => 'notifier.transport_factory.discord',
2800.             NotifierBridge\Engagespot\EngagespotTransportFactory::class => 'notifier.transport_factory.engagespot',
2801.             NotifierBridge\Esendex\EsendexTransportFactory::class => 'notifier.transport_factory.esendex',
2802.             NotifierBridge\Expo\ExpoTransportFactory::class => 'notifier.transport_factory.expo',
2803.             NotifierBridge\FakeChat\FakeChatTransportFactory::class => 'notifier.transport_factory.fake-chat',
2804.             NotifierBridge\FakeSms\FakeSmsTransportFactory::class => 'notifier.transport_factory.fake-sms',
2805.             NotifierBridge\Firebase\FirebaseTransportFactory::class => 'notifier.transport_factory.firebase',
2806.             NotifierBridge\FortySixElks\FortySixElksTransportFactory::class => 'notifier.transport_factory.forty-six-elks',
2807.             NotifierBridge\FreeMobile\FreeMobileTransportFactory::class => 'notifier.transport_factory.free-mobile',
2808.             NotifierBridge\GatewayApi\GatewayApiTransportFactory::class => 'notifier.transport_factory.gateway-api',
2809.             NotifierBridge\Gitter\GitterTransportFactory::class => 'notifier.transport_factory.gitter',
2810.             NotifierBridge\GoIp\GoIpTransportFactory::class => 'notifier.transport_factory.go-ip',
2811.             NotifierBridge\GoogleChat\GoogleChatTransportFactory::class => 'notifier.transport_factory.google-chat',
2812.             NotifierBridge\Infobip\InfobipTransportFactory::class => 'notifier.transport_factory.infobip',
2813.             NotifierBridge\Iqsms\IqsmsTransportFactory::class => 'notifier.transport_factory.iqsms',
2814.             NotifierBridge\Isendpro\IsendproTransportFactory::class => 'notifier.transport_factory.isendpro',
2815.             NotifierBridge\KazInfoTeh\KazInfoTehTransportFactory::class => 'notifier.transport_factory.kaz-info-teh',
2816.             NotifierBridge\LightSms\LightSmsTransportFactory::class => 'notifier.transport_factory.light-sms',
2817.             NotifierBridge\LineNotify\LineNotifyTransportFactory::class => 'notifier.transport_factory.line-notify',
2818.             NotifierBridge\LinkedIn\LinkedInTransportFactory::class => 'notifier.transport_factory.linked-in',
2819.             NotifierBridge\Mailjet\MailjetTransportFactory::class => 'notifier.transport_factory.mailjet',
2820.             NotifierBridge\Mastodon\MastodonTransportFactory::class => 'notifier.transport_factory.mastodon',
2821.             NotifierBridge\Mattermost\MattermostTransportFactory::class => 'notifier.transport_factory.mattermost',
2822.             NotifierBridge\Mercure\MercureTransportFactory::class => 'notifier.transport_factory.mercure',
2823.             NotifierBridge\MessageBird\MessageBirdTransportFactory::class => 'notifier.transport_factory.message-bird',
2824.             NotifierBridge\MessageMedia\MessageMediaTransportFactory::class => 'notifier.transport_factory.message-media',
2825.             NotifierBridge\MicrosoftTeams\MicrosoftTeamsTransportFactory::class => 'notifier.transport_factory.microsoft-teams',
2826.             NotifierBridge\Mobyt\MobytTransportFactory::class => 'notifier.transport_factory.mobyt',
2827.             NotifierBridge\Novu\NovuTransportFactory::class => 'notifier.transport_factory.novu',
2828.             NotifierBridge\Ntfy\NtfyTransportFactory::class => 'notifier.transport_factory.ntfy',
2829.             NotifierBridge\Octopush\OctopushTransportFactory::class => 'notifier.transport_factory.octopush',
2830.             NotifierBridge\OneSignal\OneSignalTransportFactory::class => 'notifier.transport_factory.one-signal',
2831.             NotifierBridge\OrangeSms\OrangeSmsTransportFactory::class => 'notifier.transport_factory.orange-sms',
2832.             NotifierBridge\OvhCloud\OvhCloudTransportFactory::class => 'notifier.transport_factory.ovh-cloud',
2833.             NotifierBridge\PagerDuty\PagerDutyTransportFactory::class => 'notifier.transport_factory.pager-duty',
2834.             NotifierBridge\Plivo\PlivoTransportFactory::class => 'notifier.transport_factory.plivo',
2835.             NotifierBridge\Pushover\PushoverTransportFactory::class => 'notifier.transport_factory.pushover',
2836.             NotifierBridge\Redlink\RedlinkTransportFactory::class => 'notifier.transport_factory.redlink',
2837.             NotifierBridge\RingCentral\RingCentralTransportFactory::class => 'notifier.transport_factory.ring-central',
2838.             NotifierBridge\RocketChat\RocketChatTransportFactory::class => 'notifier.transport_factory.rocket-chat',
2839.             NotifierBridge\Sendberry\SendberryTransportFactory::class => 'notifier.transport_factory.sendberry',
2840.             NotifierBridge\SimpleTextin\SimpleTextinTransportFactory::class => 'notifier.transport_factory.simple-textin',
2841.             NotifierBridge\Sendinblue\SendinblueTransportFactory::class => 'notifier.transport_factory.sendinblue',
2842.             NotifierBridge\Sinch\SinchTransportFactory::class => 'notifier.transport_factory.sinch',
2843.             NotifierBridge\Slack\SlackTransportFactory::class => 'notifier.transport_factory.slack',
2844.             NotifierBridge\Sms77\Sms77TransportFactory::class => 'notifier.transport_factory.sms77',
2845.             NotifierBridge\Smsapi\SmsapiTransportFactory::class => 'notifier.transport_factory.smsapi',
2846.             NotifierBridge\SmsBiuras\SmsBiurasTransportFactory::class => 'notifier.transport_factory.sms-biuras',
2847.             NotifierBridge\Smsc\SmscTransportFactory::class => 'notifier.transport_factory.smsc',
2848.             NotifierBridge\SmsFactor\SmsFactorTransportFactory::class => 'notifier.transport_factory.sms-factor',
2849.             NotifierBridge\Smsmode\SmsmodeTransportFactory::class => 'notifier.transport_factory.smsmode',
2850.             NotifierBridge\SpotHit\SpotHitTransportFactory::class => 'notifier.transport_factory.spot-hit',
2851.             NotifierBridge\Telegram\TelegramTransportFactory::class => 'notifier.transport_factory.telegram',
2852.             NotifierBridge\Telnyx\TelnyxTransportFactory::class => 'notifier.transport_factory.telnyx',
2853.             NotifierBridge\Termii\TermiiTransportFactory::class => 'notifier.transport_factory.termii',
2854.             NotifierBridge\TurboSms\TurboSmsTransportFactory::class => 'notifier.transport_factory.turbo-sms',
2855.             NotifierBridge\Twilio\TwilioTransportFactory::class => 'notifier.transport_factory.twilio',
2856.             NotifierBridge\Twitter\TwitterTransportFactory::class => 'notifier.transport_factory.twitter',
2857.             NotifierBridge\Vonage\VonageTransportFactory::class => 'notifier.transport_factory.vonage',
2858.             NotifierBridge\Yunpian\YunpianTransportFactory::class => 'notifier.transport_factory.yunpian',
2859.             NotifierBridge\Zendesk\ZendeskTransportFactory::class => 'notifier.transport_factory.zendesk',
2860.             NotifierBridge\Zulip\ZulipTransportFactory::class => 'notifier.transport_factory.zulip',
2861.         ];
2863.         $parentPackages = ['symfony/framework-bundle', 'symfony/notifier'];
2865.         foreach ($classToServices as $class => $service) {
2866.             $package = substr($service, \strlen('notifier.transport_factory.'));
2868.             if (!ContainerBuilder::willBeAvailable(sprintf('symfony/%s-notifier', $package), $class, $parentPackages)) {
2869.                 $container->removeDefinition($service);
2870.             }
2871.         }
2873.         if (ContainerBuilder::willBeAvailable('symfony/mercure-notifier', NotifierBridge\Mercure\MercureTransportFactory::class, $parentPackages) && ContainerBuilder::willBeAvailable('symfony/mercure-bundle', MercureBundle::class, $parentPackages) && \in_array(MercureBundle::class, $container->getParameter('kernel.bundles'), true)) {
2874.             $container->getDefinition($classToServices[NotifierBridge\Mercure\MercureTransportFactory::class])
2875.                 ->replaceArgument(0, new Reference(HubRegistry::class))
2876.                 ->replaceArgument(1, new Reference('event_dispatcher', ContainerBuilder::NULL_ON_INVALID_REFERENCE))
2877.                 ->addArgument(new Reference('http_client', ContainerBuilder::NULL_ON_INVALID_REFERENCE));
2878.         } elseif (ContainerBuilder::willBeAvailable('symfony/mercure-notifier', NotifierBridge\Mercure\MercureTransportFactory::class, $parentPackages)) {
2879.             $container->removeDefinition($classToServices[NotifierBridge\Mercure\MercureTransportFactory::class]);
2880.         }
2882.         if (ContainerBuilder::willBeAvailable('symfony/fake-chat-notifier', NotifierBridge\FakeChat\FakeChatTransportFactory::class, ['symfony/framework-bundle', 'symfony/notifier', 'symfony/mailer'])) {
2883.             $container->getDefinition($classToServices[NotifierBridge\FakeChat\FakeChatTransportFactory::class])
2884.                 ->replaceArgument(0, new Reference('mailer'))
2885.                 ->replaceArgument(1, new Reference('logger'))
2886.                 ->addArgument(new Reference('event_dispatcher', ContainerBuilder::NULL_ON_INVALID_REFERENCE))
2887.                 ->addArgument(new Reference('http_client', ContainerBuilder::NULL_ON_INVALID_REFERENCE));
2888.         }
2890.         if (ContainerBuilder::willBeAvailable('symfony/fake-sms-notifier', NotifierBridge\FakeSms\FakeSmsTransportFactory::class, ['symfony/framework-bundle', 'symfony/notifier', 'symfony/mailer'])) {
2891.             $container->getDefinition($classToServices[NotifierBridge\FakeSms\FakeSmsTransportFactory::class])
2892.                 ->replaceArgument(0, new Reference('mailer'))
2893.                 ->replaceArgument(1, new Reference('logger'))
2894.                 ->addArgument(new Reference('event_dispatcher', ContainerBuilder::NULL_ON_INVALID_REFERENCE))
2895.                 ->addArgument(new Reference('http_client', ContainerBuilder::NULL_ON_INVALID_REFERENCE));
2896.         }
2898.         if (isset($config['admin_recipients'])) {
2899.             $notifier = $container->getDefinition('notifier');
2900.             foreach ($config['admin_recipients'] as $i => $recipient) {
2901.                 $id = 'notifier.admin_recipient.'.$i;
2902.                 $container->setDefinition($id, new Definition(Recipient::class, [$recipient['email'], $recipient['phone']]));
2903.                 $notifier->addMethodCall('addAdminRecipient', [new Reference($id)]);
2904.             }
2905.         }
2907.         if ($webhookEnabled) {
2908.             $loader->load('notifier_webhook.php');
2910.             $webhookRequestParsers = [
2911.                 NotifierBridge\Twilio\Webhook\TwilioRequestParser::class => 'notifier.webhook.request_parser.twilio',
2912.                 NotifierBridge\Vonage\Webhook\VonageRequestParser::class => 'notifier.webhook.request_parser.vonage',
2913.             ];
2915.             foreach ($webhookRequestParsers as $class => $service) {
2916.                 $package = substr($service, \strlen('notifier.webhook.request_parser.'));
2918.                 if (!ContainerBuilder::willBeAvailable(sprintf('symfony/%s-notifier', $package), $class, ['symfony/framework-bundle', 'symfony/notifier'])) {
2919.                     $container->removeDefinition($service);
2920.                 }
2921.             }
2922.         }
2923.     }
2925.     private function registerWebhookConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
2926.     {
2927.         if (!class_exists(WebhookController::class)) {
2928.             throw new LogicException('Webhook support cannot be enabled as the component is not installed. Try running "composer require symfony/webhook".');
2929.         }
2931.         $loader->load('webhook.php');
2933.         $parsers = [];
2934.         foreach ($config['routing'] as $type => $cfg) {
2935.             $parsers[$type] = [
2936.                 'parser' => new Reference($cfg['service']),
2937.                 'secret' => $cfg['secret'],
2938.             ];
2939.         }
2941.         $controller = $container->getDefinition('webhook.controller');
2942.         $controller->replaceArgument(0, $parsers);
2943.         $controller->replaceArgument(1, new Reference($config['message_bus']));
2944.     }
2946.     private function registerRemoteEventConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
2947.     {
2948.         if (!class_exists(RemoteEvent::class)) {
2949.             throw new LogicException('RemoteEvent support cannot be enabled as the component is not installed. Try running "composer require symfony/remote-event".');
2950.         }
2952.         $loader->load('remote_event.php');
2953.     }
2955.     private function registerRateLimiterConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
2956.     {
2957.         $loader->load('rate_limiter.php');
2959.         foreach ($config['limiters'] as $name => $limiterConfig) {
2960.             // default configuration (when used by other DI extensions)
2961.             $limiterConfig += ['lock_factory' => 'lock.factory', 'cache_pool' => 'cache.rate_limiter'];
2963.             $limiter = $container->setDefinition($limiterId = 'limiter.'.$name, new ChildDefinition('limiter'));
2965.             if (null !== $limiterConfig['lock_factory']) {
2966.                 if (!interface_exists(LockInterface::class)) {
2967.                     throw new LogicException(sprintf('Rate limiter "%s" requires the Lock component to be installed. Try running "composer require symfony/lock".', $name));
2968.                 }
2970.                 if (!$this->isInitializedConfigEnabled('lock')) {
2971.                     throw new LogicException(sprintf('Rate limiter "%s" requires the Lock component to be configured.', $name));
2972.                 }
2974.                 $limiter->replaceArgument(2, new Reference($limiterConfig['lock_factory']));
2975.             }
2976.             unset($limiterConfig['lock_factory']);
2978.             if (null === $storageId = $limiterConfig['storage_service'] ?? null) {
2979.                 $container->register($storageId = 'limiter.storage.'.$name, CacheStorage::class)->addArgument(new Reference($limiterConfig['cache_pool']));
2980.             }
2982.             $limiter->replaceArgument(1, new Reference($storageId));
2983.             unset($limiterConfig['storage_service'], $limiterConfig['cache_pool']);
2985.             $limiterConfig['id'] = $name;
2986.             $limiter->replaceArgument(0, $limiterConfig);
2988.             $container->registerAliasForArgument($limiterId, RateLimiterFactory::class, $name.'.limiter');
2989.         }
2990.     }
2992.     /**
2993.      * @deprecated since Symfony 6.2
2994.      *
2995.      * @return void
2996.      */
2997.     public static function registerRateLimiter(ContainerBuilder $container, string $name, array $limiterConfig)
2998.     {
2999.         trigger_deprecation('symfony/framework-bundle', '6.2', 'The "%s()" method is deprecated.', __METHOD__);
3001.         // default configuration (when used by other DI extensions)
3002.         $limiterConfig += ['lock_factory' => 'lock.factory', 'cache_pool' => 'cache.rate_limiter'];
3004.         $limiter = $container->setDefinition($limiterId = 'limiter.'.$name, new ChildDefinition('limiter'));
3006.         if (null !== $limiterConfig['lock_factory']) {
3007.             if (!interface_exists(LockInterface::class)) {
3008.                 throw new LogicException(sprintf('Rate limiter "%s" requires the Lock component to be installed. Try running "composer require symfony/lock".', $name));
3009.             }
3010.             if (!$container->hasDefinition('lock.factory.abstract')) {
3011.                 throw new LogicException(sprintf('Rate limiter "%s" requires the Lock component to be configured.', $name));
3012.             }
3014.             $limiter->replaceArgument(2, new Reference($limiterConfig['lock_factory']));
3015.         }
3016.         unset($limiterConfig['lock_factory']);
3018.         if (null === $storageId = $limiterConfig['storage_service'] ?? null) {
3019.             $container->register($storageId = 'limiter.storage.'.$name, CacheStorage::class)->addArgument(new Reference($limiterConfig['cache_pool']));
3020.         }
3022.         $limiter->replaceArgument(1, new Reference($storageId));
3023.         unset($limiterConfig['storage_service'], $limiterConfig['cache_pool']);
3025.         $limiterConfig['id'] = $name;
3026.         $limiter->replaceArgument(0, $limiterConfig);
3028.         $container->registerAliasForArgument($limiterId, RateLimiterFactory::class, $name.'.limiter');
3029.     }
3031.     private function registerUidConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
3032.     {
3033.         $loader->load('uid.php');
3035.         $container->getDefinition('uuid.factory')
3036.             ->setArguments([
3037.                 $config['default_uuid_version'],
3038.                 $config['time_based_uuid_version'],
3039.                 $config['name_based_uuid_version'],
3040.                 UuidV4::class,
3041.                 $config['time_based_uuid_node'] ?? null,
3042.                 $config['name_based_uuid_namespace'] ?? null,
3043.             ])
3044.         ;
3046.         if (isset($config['name_based_uuid_namespace'])) {
3047.             $container->getDefinition('name_based_uuid.factory')
3048.                 ->setArguments([$config['name_based_uuid_namespace']]);
3049.         }
3050.     }
3052.     private function registerHtmlSanitizerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
3053.     {
3054.         $loader->load('html_sanitizer.php');
3056.         foreach ($config['sanitizers'] as $sanitizerName => $sanitizerConfig) {
3057.             $configId = 'html_sanitizer.config.'.$sanitizerName;
3058.             $def = $container->register($configId, HtmlSanitizerConfig::class);
3060.             // Base
3061.             if ($sanitizerConfig['allow_safe_elements']) {
3062.                 $def->addMethodCall('allowSafeElements', [], true);
3063.             }
3065.             if ($sanitizerConfig['allow_static_elements']) {
3066.                 $def->addMethodCall('allowStaticElements', [], true);
3067.             }
3069.             // Configures elements
3070.             foreach ($sanitizerConfig['allow_elements'] as $element => $attributes) {
3071.                 $def->addMethodCall('allowElement', [$element, $attributes], true);
3072.             }
3074.             foreach ($sanitizerConfig['block_elements'] as $element) {
3075.                 $def->addMethodCall('blockElement', [$element], true);
3076.             }
3078.             foreach ($sanitizerConfig['drop_elements'] as $element) {
3079.                 $def->addMethodCall('dropElement', [$element], true);
3080.             }
3082.             // Configures attributes
3083.             foreach ($sanitizerConfig['allow_attributes'] as $attribute => $elements) {
3084.                 $def->addMethodCall('allowAttribute', [$attribute, $elements], true);
3085.             }
3087.             foreach ($sanitizerConfig['drop_attributes'] as $attribute => $elements) {
3088.                 $def->addMethodCall('dropAttribute', [$attribute, $elements], true);
3089.             }
3091.             // Force attributes
3092.             foreach ($sanitizerConfig['force_attributes'] as $element => $attributes) {
3093.                 foreach ($attributes as $attrName => $attrValue) {
3094.                     $def->addMethodCall('forceAttribute', [$element, $attrName, $attrValue], true);
3095.                 }
3096.             }
3098.             // Settings
3099.             $def->addMethodCall('forceHttpsUrls', [$sanitizerConfig['force_https_urls']], true);
3100.             if ($sanitizerConfig['allowed_link_schemes']) {
3101.                 $def->addMethodCall('allowLinkSchemes', [$sanitizerConfig['allowed_link_schemes']], true);
3102.             }
3103.             $def->addMethodCall('allowLinkHosts', [$sanitizerConfig['allowed_link_hosts']], true);
3104.             $def->addMethodCall('allowRelativeLinks', [$sanitizerConfig['allow_relative_links']], true);
3105.             if ($sanitizerConfig['allowed_media_schemes']) {
3106.                 $def->addMethodCall('allowMediaSchemes', [$sanitizerConfig['allowed_media_schemes']], true);
3107.             }
3108.             $def->addMethodCall('allowMediaHosts', [$sanitizerConfig['allowed_media_hosts']], true);
3109.             $def->addMethodCall('allowRelativeMedias', [$sanitizerConfig['allow_relative_medias']], true);
3111.             // Custom attribute sanitizers
3112.             foreach ($sanitizerConfig['with_attribute_sanitizers'] as $serviceName) {
3113.                 $def->addMethodCall('withAttributeSanitizer', [new Reference($serviceName)], true);
3114.             }
3116.             foreach ($sanitizerConfig['without_attribute_sanitizers'] as $serviceName) {
3117.                 $def->addMethodCall('withoutAttributeSanitizer', [new Reference($serviceName)], true);
3118.             }
3120.             if ($sanitizerConfig['max_input_length']) {
3121.                 $def->addMethodCall('withMaxInputLength', [$sanitizerConfig['max_input_length']], true);
3122.             }
3124.             // Create the sanitizer and link its config
3125.             $sanitizerId = 'html_sanitizer.sanitizer.'.$sanitizerName;
3126.             $container->register($sanitizerId, HtmlSanitizer::class)
3127.                 ->addTag('html_sanitizer', ['sanitizer' => $sanitizerName])
3128.                 ->addArgument(new Reference($configId));
3130.             if ('default' !== $sanitizerName) {
3131.                 $container->registerAliasForArgument($sanitizerId, HtmlSanitizerInterface::class, $sanitizerName);
3132.             }
3133.         }
3134.     }
3136.     private function resolveTrustedHeaders(array $headers): int
3137.     {
3138.         $trustedHeaders = 0;
3140.         foreach ($headers as $h) {
3141.             $trustedHeaders |= match ($h) {
3142.                 'forwarded' => Request::HEADER_FORWARDED,
3143.                 'x-forwarded-for' => Request::HEADER_X_FORWARDED_FOR,
3144.                 'x-forwarded-host' => Request::HEADER_X_FORWARDED_HOST,
3145.                 'x-forwarded-proto' => Request::HEADER_X_FORWARDED_PROTO,
3146.                 'x-forwarded-port' => Request::HEADER_X_FORWARDED_PORT,
3147.                 'x-forwarded-prefix' => Request::HEADER_X_FORWARDED_PREFIX,
3148.                 default => 0,
3149.             };
3150.         }
3152.         return $trustedHeaders;
3153.     }
3155.     public function getXsdValidationBasePath(): string|false
3156.     {
3157.         return \dirname(__DIR__).'/Resources/config/schema';
3158.     }
3160.     public function getNamespace(): string
3161.     {
3162.         return 'http://symfony.com/schema/dic/symfony';
3163.     }
3165.     protected function isConfigEnabled(ContainerBuilder $container, array $config): bool
3166.     {
3167.         throw new \LogicException('To prevent using outdated configuration, you must use the "readConfigEnabled" method instead.');
3168.     }
3170.     private function isInitializedConfigEnabled(string $path): bool
3171.     {
3172.         if (isset($this->configsEnabled[$path])) {
3173.             return $this->configsEnabled[$path];
3174.         }
3176.         throw new LogicException(sprintf('Can not read config enabled at "%s" because it has not been initialized.', $path));
3177.     }
3179.     private function readConfigEnabled(string $path, ContainerBuilder $container, array $config): bool
3180.     {
3181.         return $this->configsEnabled[$path] ??= parent::isConfigEnabled($container, $config);
3182.     }
3184.     private function writeConfigEnabled(string $path, bool $value, array &$config): void
3185.     {
3186.         if (isset($this->configsEnabled[$path])) {
3187.             throw new LogicException('Can not change config enabled because it has already been read.');
3188.         }
3190.         $this->configsEnabled[$path] = $value;
3191.         $config['enabled'] = $value;
3192.     }
3194.     private function getPublicDirectory(ContainerBuilder $container): string
3195.     {
3196.         $projectDir = $container->getParameter('kernel.project_dir');
3197.         $defaultPublicDir = $projectDir.'/public';
3199.         $composerFilePath = $projectDir.'/composer.json';
3201.         if (!file_exists($composerFilePath)) {
3202.             return $defaultPublicDir;
3203.         }
3205.         $container->addResource(new FileResource($composerFilePath));
3206.         $composerConfig = json_decode(file_get_contents($composerFilePath), true);
3208.         return isset($composerConfig['extra']['public-dir']) ? $projectDir.'/'.$composerConfig['extra']['public-dir'] : $defaultPublicDir;
3209.     }
3210. }