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\AnnotationRegistry;
16. use Doctrine\Common\Annotations\Reader;
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\BrowserKit\AbstractBrowser;
35. use Symfony\Component\Cache\Adapter\AdapterInterface;
36. use Symfony\Component\Cache\Adapter\ArrayAdapter;
37. use Symfony\Component\Cache\Adapter\ChainAdapter;
38. use Symfony\Component\Cache\Adapter\TagAwareAdapter;
39. use Symfony\Component\Cache\DependencyInjection\CachePoolPass;
40. use Symfony\Component\Cache\Marshaller\DefaultMarshaller;
41. use Symfony\Component\Cache\Marshaller\MarshallerInterface;
42. use Symfony\Component\Cache\ResettableInterface;
43. use Symfony\Component\Clock\ClockInterface;
44. use Symfony\Component\Config\Definition\ConfigurationInterface;
45. use Symfony\Component\Config\FileLocator;
46. use Symfony\Component\Config\Loader\LoaderInterface;
47. use Symfony\Component\Config\Resource\DirectoryResource;
48. use Symfony\Component\Config\ResourceCheckerInterface;
49. use Symfony\Component\Console\Application;
50. use Symfony\Component\Console\Command\Command;
51. use Symfony\Component\DependencyInjection\Alias;
52. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
53. use Symfony\Component\DependencyInjection\ChildDefinition;
54. use Symfony\Component\DependencyInjection\Compiler\ServiceLocatorTagPass;
55. use Symfony\Component\DependencyInjection\ContainerBuilder;
56. use Symfony\Component\DependencyInjection\ContainerInterface;
57. use Symfony\Component\DependencyInjection\Definition;
58. use Symfony\Component\DependencyInjection\EnvVarLoaderInterface;
59. use Symfony\Component\DependencyInjection\EnvVarProcessorInterface;
60. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
61. use Symfony\Component\DependencyInjection\Exception\LogicException;
62. use Symfony\Component\DependencyInjection\Loader\PhpFileLoader;
63. use Symfony\Component\DependencyInjection\Parameter;
64. use Symfony\Component\DependencyInjection\Reference;
65. use Symfony\Component\DependencyInjection\ServiceLocator;
66. use Symfony\Component\Dotenv\Command\DebugCommand;
67. use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
68. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
69. use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
70. use Symfony\Component\Finder\Finder;
71. use Symfony\Component\Form\ChoiceList\Factory\CachingFactoryDecorator;
72. use Symfony\Component\Form\Extension\HtmlSanitizer\Type\TextTypeHtmlSanitizerExtension;
73. use Symfony\Component\Form\Form;
74. use Symfony\Component\Form\FormTypeExtensionInterface;
75. use Symfony\Component\Form\FormTypeGuesserInterface;
76. use Symfony\Component\Form\FormTypeInterface;
77. use Symfony\Component\HtmlSanitizer\HtmlSanitizer;
78. use Symfony\Component\HtmlSanitizer\HtmlSanitizerConfig;
79. use Symfony\Component\HtmlSanitizer\HtmlSanitizerInterface;
80. use Symfony\Component\HttpClient\MockHttpClient;
81. use Symfony\Component\HttpClient\Retry\GenericRetryStrategy;
82. use Symfony\Component\HttpClient\RetryableHttpClient;
83. use Symfony\Component\HttpClient\ScopingHttpClient;
84. use Symfony\Component\HttpFoundation\Request;
85. use Symfony\Component\HttpKernel\Attribute\AsController;
86. use Symfony\Component\HttpKernel\CacheClearer\CacheClearerInterface;
87. use Symfony\Component\HttpKernel\CacheWarmer\CacheWarmerInterface;
88. use Symfony\Component\HttpKernel\Controller\ArgumentResolver\BackedEnumValueResolver;
89. use Symfony\Component\HttpKernel\Controller\ArgumentResolver\UidValueResolver;
90. use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
91. use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
92. use Symfony\Component\HttpKernel\DataCollector\DataCollectorInterface;
93. use Symfony\Component\HttpKernel\DependencyInjection\Extension;
94. use Symfony\Component\Lock\LockFactory;
95. use Symfony\Component\Lock\LockInterface;
96. use Symfony\Component\Lock\PersistingStoreInterface;
97. use Symfony\Component\Lock\Store\StoreFactory;
98. use Symfony\Component\Mailer\Bridge\Amazon\Transport\SesTransportFactory;
99. use Symfony\Component\Mailer\Bridge\Google\Transport\GmailTransportFactory;
100. use Symfony\Component\Mailer\Bridge\Infobip\Transport\InfobipTransportFactory as InfobipMailerTransportFactory;
101. use Symfony\Component\Mailer\Bridge\Mailchimp\Transport\MandrillTransportFactory;
102. use Symfony\Component\Mailer\Bridge\Mailgun\Transport\MailgunTransportFactory;
103. use Symfony\Component\Mailer\Bridge\Mailjet\Transport\MailjetTransportFactory;
104. use Symfony\Component\Mailer\Bridge\MailPace\Transport\MailPaceTransportFactory;
105. use Symfony\Component\Mailer\Bridge\OhMySmtp\Transport\OhMySmtpTransportFactory;
106. use Symfony\Component\Mailer\Bridge\Postmark\Transport\PostmarkTransportFactory;
107. use Symfony\Component\Mailer\Bridge\Sendgrid\Transport\SendgridTransportFactory;
108. use Symfony\Component\Mailer\Bridge\Sendinblue\Transport\SendinblueTransportFactory;
109. use Symfony\Component\Mailer\Command\MailerTestCommand;
110. use Symfony\Component\Mailer\EventListener\MessengerTransportListener;
111. use Symfony\Component\Mailer\Mailer;
112. use Symfony\Component\Mercure\HubRegistry;
113. use Symfony\Component\Messenger\Attribute\AsMessageHandler;
114. use Symfony\Component\Messenger\Bridge\AmazonSqs\Transport\AmazonSqsTransportFactory;
115. use Symfony\Component\Messenger\Bridge\Amqp\Transport\AmqpTransportFactory;
116. use Symfony\Component\Messenger\Bridge\Beanstalkd\Transport\BeanstalkdTransportFactory;
117. use Symfony\Component\Messenger\Bridge\Redis\Transport\RedisTransportFactory;
118. use Symfony\Component\Messenger\Command\StatsCommand;
119. use Symfony\Component\Messenger\Handler\BatchHandlerInterface;
120. use Symfony\Component\Messenger\Handler\MessageHandlerInterface;
121. use Symfony\Component\Messenger\MessageBus;
122. use Symfony\Component\Messenger\MessageBusInterface;
123. use Symfony\Component\Messenger\Middleware\RouterContextMiddleware;
124. use Symfony\Component\Messenger\Transport\Serialization\SerializerInterface;
125. use Symfony\Component\Messenger\Transport\TransportFactoryInterface;
126. use Symfony\Component\Messenger\Transport\TransportInterface;
127. use Symfony\Component\Mime\Header\Headers;
128. use Symfony\Component\Mime\MimeTypeGuesserInterface;
129. use Symfony\Component\Mime\MimeTypes;
130. use Symfony\Component\Notifier\Bridge\AllMySms\AllMySmsTransportFactory;
131. use Symfony\Component\Notifier\Bridge\AmazonSns\AmazonSnsTransportFactory;
132. use Symfony\Component\Notifier\Bridge\Chatwork\ChatworkTransportFactory;
133. use Symfony\Component\Notifier\Bridge\Clickatell\ClickatellTransportFactory;
134. use Symfony\Component\Notifier\Bridge\ContactEveryone\ContactEveryoneTransportFactory;
135. use Symfony\Component\Notifier\Bridge\Discord\DiscordTransportFactory;
136. use Symfony\Component\Notifier\Bridge\Engagespot\EngagespotTransportFactory;
137. use Symfony\Component\Notifier\Bridge\Esendex\EsendexTransportFactory;
138. use Symfony\Component\Notifier\Bridge\Expo\ExpoTransportFactory;
139. use Symfony\Component\Notifier\Bridge\FakeChat\FakeChatTransportFactory;
140. use Symfony\Component\Notifier\Bridge\FakeSms\FakeSmsTransportFactory;
141. use Symfony\Component\Notifier\Bridge\Firebase\FirebaseTransportFactory;
142. use Symfony\Component\Notifier\Bridge\FortySixElks\FortySixElksTransportFactory;
143. use Symfony\Component\Notifier\Bridge\FreeMobile\FreeMobileTransportFactory;
144. use Symfony\Component\Notifier\Bridge\GatewayApi\GatewayApiTransportFactory;
145. use Symfony\Component\Notifier\Bridge\Gitter\GitterTransportFactory;
146. use Symfony\Component\Notifier\Bridge\GoogleChat\GoogleChatTransportFactory;
147. use Symfony\Component\Notifier\Bridge\Infobip\InfobipTransportFactory;
148. use Symfony\Component\Notifier\Bridge\Iqsms\IqsmsTransportFactory;
149. use Symfony\Component\Notifier\Bridge\KazInfoTeh\KazInfoTehTransportFactory;
150. use Symfony\Component\Notifier\Bridge\LightSms\LightSmsTransportFactory;
151. use Symfony\Component\Notifier\Bridge\LinkedIn\LinkedInTransportFactory;
152. use Symfony\Component\Notifier\Bridge\Mailjet\MailjetTransportFactory as MailjetNotifierTransportFactory;
153. use Symfony\Component\Notifier\Bridge\Mattermost\MattermostTransportFactory;
154. use Symfony\Component\Notifier\Bridge\Mercure\MercureTransportFactory;
155. use Symfony\Component\Notifier\Bridge\MessageBird\MessageBirdTransport;
156. use Symfony\Component\Notifier\Bridge\MessageMedia\MessageMediaTransportFactory;
157. use Symfony\Component\Notifier\Bridge\MicrosoftTeams\MicrosoftTeamsTransportFactory;
158. use Symfony\Component\Notifier\Bridge\Mobyt\MobytTransportFactory;
159. use Symfony\Component\Notifier\Bridge\Octopush\OctopushTransportFactory;
160. use Symfony\Component\Notifier\Bridge\OneSignal\OneSignalTransportFactory;
161. use Symfony\Component\Notifier\Bridge\OrangeSms\OrangeSmsTransportFactory;
162. use Symfony\Component\Notifier\Bridge\OvhCloud\OvhCloudTransportFactory;
163. use Symfony\Component\Notifier\Bridge\RocketChat\RocketChatTransportFactory;
164. use Symfony\Component\Notifier\Bridge\Sendberry\SendberryTransportFactory;
165. use Symfony\Component\Notifier\Bridge\Sendinblue\SendinblueTransportFactory as SendinblueNotifierTransportFactory;
166. use Symfony\Component\Notifier\Bridge\Sinch\SinchTransportFactory;
167. use Symfony\Component\Notifier\Bridge\Slack\SlackTransportFactory;
168. use Symfony\Component\Notifier\Bridge\Sms77\Sms77TransportFactory;
169. use Symfony\Component\Notifier\Bridge\Smsapi\SmsapiTransportFactory;
170. use Symfony\Component\Notifier\Bridge\SmsBiuras\SmsBiurasTransportFactory;
171. use Symfony\Component\Notifier\Bridge\Smsc\SmscTransportFactory;
172. use Symfony\Component\Notifier\Bridge\SmsFactor\SmsFactorTransportFactory;
173. use Symfony\Component\Notifier\Bridge\SpotHit\SpotHitTransportFactory;
174. use Symfony\Component\Notifier\Bridge\Telegram\TelegramTransportFactory;
175. use Symfony\Component\Notifier\Bridge\Telnyx\TelnyxTransportFactory;
176. use Symfony\Component\Notifier\Bridge\TurboSms\TurboSmsTransport;
177. use Symfony\Component\Notifier\Bridge\Twilio\TwilioTransportFactory;
178. use Symfony\Component\Notifier\Bridge\Vonage\VonageTransportFactory;
179. use Symfony\Component\Notifier\Bridge\Yunpian\YunpianTransportFactory;
180. use Symfony\Component\Notifier\Bridge\Zendesk\ZendeskTransportFactory;
181. use Symfony\Component\Notifier\Bridge\Zulip\ZulipTransportFactory;
182. use Symfony\Component\Notifier\ChatterInterface;
183. use Symfony\Component\Notifier\Notifier;
184. use Symfony\Component\Notifier\Recipient\Recipient;
185. use Symfony\Component\Notifier\TexterInterface;
186. use Symfony\Component\Notifier\Transport\TransportFactoryInterface as NotifierTransportFactoryInterface;
187. use Symfony\Component\PropertyAccess\PropertyAccessor;
188. use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
189. use Symfony\Component\PropertyInfo\Extractor\PhpStanExtractor;
190. use Symfony\Component\PropertyInfo\PropertyAccessExtractorInterface;
191. use Symfony\Component\PropertyInfo\PropertyDescriptionExtractorInterface;
192. use Symfony\Component\PropertyInfo\PropertyInfoExtractorInterface;
193. use Symfony\Component\PropertyInfo\PropertyInitializableExtractorInterface;
194. use Symfony\Component\PropertyInfo\PropertyListExtractorInterface;
195. use Symfony\Component\PropertyInfo\PropertyReadInfoExtractorInterface;
196. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
197. use Symfony\Component\PropertyInfo\PropertyWriteInfoExtractorInterface;
198. use Symfony\Component\RateLimiter\LimiterInterface;
199. use Symfony\Component\RateLimiter\RateLimiterFactory;
200. use Symfony\Component\RateLimiter\Storage\CacheStorage;
201. use Symfony\Component\Routing\Loader\Psr4DirectoryLoader;
202. use Symfony\Component\Security\Core\AuthenticationEvents;
203. use Symfony\Component\Security\Core\Exception\AuthenticationException;
204. use Symfony\Component\Security\Csrf\CsrfTokenManagerInterface;
205. use Symfony\Component\Semaphore\PersistingStoreInterface as SemaphoreStoreInterface;
206. use Symfony\Component\Semaphore\Semaphore;
207. use Symfony\Component\Semaphore\SemaphoreFactory;
208. use Symfony\Component\Semaphore\Store\StoreFactory as SemaphoreStoreFactory;
209. use Symfony\Component\Serializer\Encoder\DecoderInterface;
210. use Symfony\Component\Serializer\Encoder\EncoderInterface;
211. use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
212. use Symfony\Component\Serializer\Mapping\Loader\XmlFileLoader;
213. use Symfony\Component\Serializer\Mapping\Loader\YamlFileLoader;
214. use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
215. use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
216. use Symfony\Component\Serializer\Normalizer\UnwrappingDenormalizer;
217. use Symfony\Component\Stopwatch\Stopwatch;
218. use Symfony\Component\String\LazyString;
219. use Symfony\Component\String\Slugger\SluggerInterface;
220. use Symfony\Component\Translation\Bridge\Crowdin\CrowdinProviderFactory;
221. use Symfony\Component\Translation\Bridge\Loco\LocoProviderFactory;
222. use Symfony\Component\Translation\Bridge\Lokalise\LokaliseProviderFactory;
223. use Symfony\Component\Translation\Command\XliffLintCommand as BaseXliffLintCommand;
224. use Symfony\Component\Translation\Extractor\PhpAstExtractor;
225. use Symfony\Component\Translation\LocaleSwitcher;
226. use Symfony\Component\Translation\PseudoLocalizationTranslator;
227. use Symfony\Component\Translation\Translator;
228. use Symfony\Component\Uid\Factory\UuidFactory;
229. use Symfony\Component\Uid\UuidV4;
230. use Symfony\Component\Validator\Constraints\WhenValidator;
231. use Symfony\Component\Validator\ConstraintValidatorInterface;
232. use Symfony\Component\Validator\Mapping\Loader\PropertyInfoLoader;
233. use Symfony\Component\Validator\ObjectInitializerInterface;
234. use Symfony\Component\Validator\Validation;
235. use Symfony\Component\WebLink\HttpHeaderSerializer;
236. use Symfony\Component\Workflow;
237. use Symfony\Component\Workflow\WorkflowInterface;
238. use Symfony\Component\Yaml\Command\LintCommand as BaseYamlLintCommand;
239. use Symfony\Component\Yaml\Yaml;
240. use Symfony\Contracts\Cache\CacheInterface;
241. use Symfony\Contracts\Cache\CallbackInterface;
242. use Symfony\Contracts\Cache\TagAwareCacheInterface;
243. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
244. use Symfony\Contracts\HttpClient\HttpClientInterface;
245. use Symfony\Contracts\Service\ResetInterface;
246. use Symfony\Contracts\Service\ServiceSubscriberInterface;
247. use Symfony\Contracts\Translation\LocaleAwareInterface;
249. /**
250.  * Process the configuration and prepare the dependency injection container with
251.  * parameters and services.
252.  */
253. class FrameworkExtension extends Extension
254. {
255.     private array $configsEnabled = [];
257.     /**
258.      * Responds to the app.config configuration parameter.
259.      *
260.      * @throws LogicException
261.      */
262.     public function load(array $configs, ContainerBuilder $container)
263.     {
264.         $loader = new PhpFileLoader($container, new FileLocator(\dirname(__DIR__).'/Resources/config'));
266.         if (class_exists(InstalledVersions::class) && InstalledVersions::isInstalled('symfony/symfony') && 'symfony/symfony' !== (InstalledVersions::getRootPackage()['name'] ?? '')) {
267.             trigger_deprecation('symfony/symfony', '6.1', 'Requiring the "symfony/symfony" package is deprecated; replace it with standalone components instead.');
268.         }
270.         $loader->load('web.php');
272.         if (!class_exists(BackedEnumValueResolver::class)) {
273.             $container->removeDefinition('argument_resolver.backed_enum_resolver');
274.         }
276.         $loader->load('services.php');
277.         $loader->load('fragment_renderer.php');
278.         $loader->load('error_renderer.php');
280.         if (!ContainerBuilder::willBeAvailable('symfony/clock', ClockInterface::class, ['symfony/framework-bundle'])) {
281.             $container->removeDefinition('clock');
282.             $container->removeAlias(ClockInterface::class);
283.             $container->removeAlias(PsrClockInterface::class);
284.         }
286.         $container->registerAliasForArgument('parameter_bag', PsrContainerInterface::class);
288.         if ($this->hasConsole()) {
289.             $loader->load('console.php');
291.             if (!class_exists(BaseXliffLintCommand::class)) {
292.                 $container->removeDefinition('console.command.xliff_lint');
293.             }
294.             if (!class_exists(BaseYamlLintCommand::class)) {
295.                 $container->removeDefinition('console.command.yaml_lint');
296.             }
298.             if (!class_exists(DebugCommand::class)) {
299.                 $container->removeDefinition('console.command.dotenv_debug');
300.             }
301.         }
303.         // Load Cache configuration first as it is used by other components
304.         $loader->load('cache.php');
306.         $configuration = $this->getConfiguration($configs, $container);
307.         $config = $this->processConfiguration($configuration, $configs);
309.         // warmup config enabled
310.         $this->readConfigEnabled('annotations', $container, $config['annotations']);
311.         $this->readConfigEnabled('translator', $container, $config['translator']);
312.         $this->readConfigEnabled('property_access', $container, $config['property_access']);
313.         $this->readConfigEnabled('profiler', $container, $config['profiler']);
315.         // A translator must always be registered (as support is included by
316.         // default in the Form and Validator component). If disabled, an identity
317.         // translator will be used and everything will still work as expected.
318.         if ($this->readConfigEnabled('translator', $container, $config['translator']) || $this->readConfigEnabled('form', $container, $config['form']) || $this->readConfigEnabled('validation', $container, $config['validation'])) {
319.             if (!class_exists(Translator::class) && $this->readConfigEnabled('translator', $container, $config['translator'])) {
320.                 throw new LogicException('Translation support cannot be enabled as the Translation component is not installed. Try running "composer require symfony/translation".');
321.             }
323.             if (class_exists(Translator::class)) {
324.                 $loader->load('identity_translator.php');
325.             }
326.         }
328.         $container->getDefinition('locale_listener')->replaceArgument(3, $config['set_locale_from_accept_language']);
329.         $container->getDefinition('response_listener')->replaceArgument(1, $config['set_content_language_from_locale']);
330.         $container->getDefinition('http_kernel')->replaceArgument(4, $config['handle_all_throwables'] ?? false);
332.         // If the slugger is used but the String component is not available, we should throw an error
333.         if (!ContainerBuilder::willBeAvailable('symfony/string', SluggerInterface::class, ['symfony/framework-bundle'])) {
334.             $container->register('slugger', 'stdClass')
335.                 ->addError('You cannot use the "slugger" service since the String component is not installed. Try running "composer require symfony/string".');
336.         } else {
337.             if (!ContainerBuilder::willBeAvailable('symfony/translation', LocaleAwareInterface::class, ['symfony/framework-bundle'])) {
338.                 $container->register('slugger', 'stdClass')
339.                     ->addError('You cannot use the "slugger" service since the Translation contracts are not installed. Try running "composer require symfony/translation".');
340.             }
342.             if (!\extension_loaded('intl') && !\defined('PHPUNIT_COMPOSER_INSTALL')) {
343.                 trigger_deprecation('', '', 'Please install the "intl" PHP extension for best performance.');
344.             }
345.         }
347.         if (isset($config['secret'])) {
348.             $container->setParameter('kernel.secret', $config['secret']);
349.         }
351.         $container->setParameter('kernel.http_method_override', $config['http_method_override']);
352.         $container->setParameter('kernel.trust_x_sendfile_type_header', $config['trust_x_sendfile_type_header']);
353.         $container->setParameter('kernel.trusted_hosts', $config['trusted_hosts']);
354.         $container->setParameter('kernel.default_locale', $config['default_locale']);
355.         $container->setParameter('kernel.enabled_locales', $config['enabled_locales']);
356.         $container->setParameter('kernel.error_controller', $config['error_controller']);
358.         if (($config['trusted_proxies'] ?? false) && ($config['trusted_headers'] ?? false)) {
359.             $container->setParameter('kernel.trusted_proxies', $config['trusted_proxies']);
360.             $container->setParameter('kernel.trusted_headers', $this->resolveTrustedHeaders($config['trusted_headers']));
361.         }
363.         if (!$container->hasParameter('debug.file_link_format')) {
364.             $container->setParameter('debug.file_link_format', $config['ide']);
365.         }
367.         if (!empty($config['test'])) {
368.             $loader->load('test.php');
370.             if (!class_exists(AbstractBrowser::class)) {
371.                 $container->removeDefinition('test.client');
372.             }
373.         }
375.         if ($this->readConfigEnabled('request', $container, $config['request'])) {
376.             $this->registerRequestConfiguration($config['request'], $container, $loader);
377.         }
379.         if ($this->readConfigEnabled('assets', $container, $config['assets'])) {
380.             if (!class_exists(\Symfony\Component\Asset\Package::class)) {
381.                 throw new LogicException('Asset support cannot be enabled as the Asset component is not installed. Try running "composer require symfony/asset".');
382.             }
384.             $this->registerAssetsConfiguration($config['assets'], $container, $loader);
385.         }
387.         if ($this->readConfigEnabled('http_client', $container, $config['http_client'])) {
388.             $this->registerHttpClientConfiguration($config['http_client'], $container, $loader);
389.         }
391.         if ($this->readConfigEnabled('mailer', $container, $config['mailer'])) {
392.             $this->registerMailerConfiguration($config['mailer'], $container, $loader);
394.             if (!$this->hasConsole() || !class_exists(MailerTestCommand::class)) {
395.                 $container->removeDefinition('console.command.mailer_test');
396.             }
397.         }
399.         $propertyInfoEnabled = $this->readConfigEnabled('property_info', $container, $config['property_info']);
400.         $this->registerHttpCacheConfiguration($config['http_cache'], $container, $config['http_method_override']);
401.         $this->registerEsiConfiguration($config['esi'], $container, $loader);
402.         $this->registerSsiConfiguration($config['ssi'], $container, $loader);
403.         $this->registerFragmentsConfiguration($config['fragments'], $container, $loader);
404.         $this->registerTranslatorConfiguration($config['translator'], $container, $loader, $config['default_locale'], $config['enabled_locales']);
405.         $this->registerWorkflowConfiguration($config['workflows'], $container, $loader);
406.         $this->registerDebugConfiguration($config['php_errors'], $container, $loader);
407.         $this->registerRouterConfiguration($config['router'], $container, $loader, $config['enabled_locales']);
408.         $this->registerAnnotationsConfiguration($config['annotations'], $container, $loader);
409.         $this->registerPropertyAccessConfiguration($config['property_access'], $container, $loader);
410.         $this->registerSecretsConfiguration($config['secrets'], $container, $loader);
412.         $container->getDefinition('exception_listener')->replaceArgument(3, $config['exceptions']);
414.         if ($this->readConfigEnabled('serializer', $container, $config['serializer'])) {
415.             if (!class_exists(\Symfony\Component\Serializer\Serializer::class)) {
416.                 throw new LogicException('Serializer support cannot be enabled as the Serializer component is not installed. Try running "composer require symfony/serializer-pack".');
417.             }
419.             $this->registerSerializerConfiguration($config['serializer'], $container, $loader);
420.         }
422.         if ($propertyInfoEnabled) {
423.             $this->registerPropertyInfoConfiguration($container, $loader);
424.         }
426.         if ($this->readConfigEnabled('lock', $container, $config['lock'])) {
427.             $this->registerLockConfiguration($config['lock'], $container, $loader);
428.         }
430.         if ($this->readConfigEnabled('semaphore', $container, $config['semaphore'])) {
431.             $this->registerSemaphoreConfiguration($config['semaphore'], $container, $loader);
432.         }
434.         if ($this->readConfigEnabled('rate_limiter', $container, $config['rate_limiter'])) {
435.             if (!interface_exists(LimiterInterface::class)) {
436.                 throw new LogicException('Rate limiter support cannot be enabled as the RateLimiter component is not installed. Try running "composer require symfony/rate-limiter".');
437.             }
439.             $this->registerRateLimiterConfiguration($config['rate_limiter'], $container, $loader);
440.         }
442.         if ($this->readConfigEnabled('web_link', $container, $config['web_link'])) {
443.             if (!class_exists(HttpHeaderSerializer::class)) {
444.                 throw new LogicException('WebLink support cannot be enabled as the WebLink component is not installed. Try running "composer require symfony/weblink".');
445.             }
447.             $loader->load('web_link.php');
448.         }
450.         if ($this->readConfigEnabled('uid', $container, $config['uid'])) {
451.             if (!class_exists(UuidFactory::class)) {
452.                 throw new LogicException('Uid support cannot be enabled as the Uid component is not installed. Try running "composer require symfony/uid".');
453.             }
455.             $this->registerUidConfiguration($config['uid'], $container, $loader);
456.         } else {
457.             $container->removeDefinition('argument_resolver.uid');
458.         }
460.         // register cache before session so both can share the connection services
461.         $this->registerCacheConfiguration($config['cache'], $container);
463.         if ($this->readConfigEnabled('session', $container, $config['session'])) {
464.             if (!\extension_loaded('session')) {
465.                 throw new LogicException('Session support cannot be enabled as the session extension is not installed. See https://php.net/session.installation for instructions.');
466.             }
468.             $this->registerSessionConfiguration($config['session'], $container, $loader);
469.             if (!empty($config['test'])) {
470.                 // test listener will replace the existing session listener
471.                 // as we are aliasing to avoid duplicated registered events
472.                 $container->setAlias('session_listener', 'test.session.listener');
473.             }
474.         } elseif (!empty($config['test'])) {
475.             $container->removeDefinition('test.session.listener');
476.         }
478.         // csrf depends on session being registered
479.         if (null === $config['csrf_protection']['enabled']) {
480.             $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']);
481.         }
482.         $this->registerSecurityCsrfConfiguration($config['csrf_protection'], $container, $loader);
484.         // form depends on csrf being registered
485.         if ($this->readConfigEnabled('form', $container, $config['form'])) {
486.             if (!class_exists(Form::class)) {
487.                 throw new LogicException('Form support cannot be enabled as the Form component is not installed. Try running "composer require symfony/form".');
488.             }
490.             $this->registerFormConfiguration($config, $container, $loader);
492.             if (ContainerBuilder::willBeAvailable('symfony/validator', Validation::class, ['symfony/framework-bundle', 'symfony/form'])) {
493.                 $this->writeConfigEnabled('validation', true, $config['validation']);
494.             } else {
495.                 $container->setParameter('validator.translation_domain', 'validators');
497.                 $container->removeDefinition('form.type_extension.form.validator');
498.                 $container->removeDefinition('form.type_guesser.validator');
499.             }
500.             if (!$this->readConfigEnabled('html_sanitizer', $container, $config['html_sanitizer']) || !class_exists(TextTypeHtmlSanitizerExtension::class)) {
501.                 $container->removeDefinition('form.type_extension.form.html_sanitizer');
502.             }
503.         } else {
504.             $container->removeDefinition('console.command.form_debug');
505.         }
507.         // validation depends on form, annotations being registered
508.         $this->registerValidationConfiguration($config['validation'], $container, $loader, $propertyInfoEnabled);
510.         // messenger depends on validation being registered
511.         if ($this->readConfigEnabled('messenger', $container, $config['messenger'])) {
512.             $this->registerMessengerConfiguration($config['messenger'], $container, $loader, $config['validation']);
513.         } else {
514.             $container->removeDefinition('console.command.messenger_consume_messages');
515.             $container->removeDefinition('console.command.messenger_stats');
516.             $container->removeDefinition('console.command.messenger_debug');
517.             $container->removeDefinition('console.command.messenger_stop_workers');
518.             $container->removeDefinition('console.command.messenger_setup_transports');
519.             $container->removeDefinition('console.command.messenger_failed_messages_retry');
520.             $container->removeDefinition('console.command.messenger_failed_messages_show');
521.             $container->removeDefinition('console.command.messenger_failed_messages_remove');
522.             $container->removeDefinition('cache.messenger.restart_workers_signal');
524.             if ($container->hasDefinition('messenger.transport.amqp.factory') && !class_exists(AmqpTransportFactory::class)) {
525.                 if (class_exists(\Symfony\Component\Messenger\Transport\AmqpExt\AmqpTransportFactory::class)) {
526.                     $container->getDefinition('messenger.transport.amqp.factory')
527.                         ->setClass(\Symfony\Component\Messenger\Transport\AmqpExt\AmqpTransportFactory::class)
528.                         ->addTag('messenger.transport_factory');
529.                 } else {
530.                     $container->removeDefinition('messenger.transport.amqp.factory');
531.                 }
532.             }
534.             if ($container->hasDefinition('messenger.transport.redis.factory') && !class_exists(RedisTransportFactory::class)) {
535.                 if (class_exists(\Symfony\Component\Messenger\Transport\RedisExt\RedisTransportFactory::class)) {
536.                     $container->getDefinition('messenger.transport.redis.factory')
537.                         ->setClass(\Symfony\Component\Messenger\Transport\RedisExt\RedisTransportFactory::class)
538.                         ->addTag('messenger.transport_factory');
539.                 } else {
540.                     $container->removeDefinition('messenger.transport.redis.factory');
541.                 }
542.             }
543.         }
545.         // notifier depends on messenger, mailer being registered
546.         if ($this->readConfigEnabled('notifier', $container, $config['notifier'])) {
547.             $this->registerNotifierConfiguration($config['notifier'], $container, $loader);
548.         }
550.         // profiler depends on form, validation, translation, messenger, mailer, http-client, notifier, serializer being registered
551.         $this->registerProfilerConfiguration($config['profiler'], $container, $loader);
553.         if ($this->readConfigEnabled('html_sanitizer', $container, $config['html_sanitizer'])) {
554.             if (!class_exists(HtmlSanitizerConfig::class)) {
555.                 throw new LogicException('HtmlSanitizer support cannot be enabled as the HtmlSanitizer component is not installed. Try running "composer require symfony/html-sanitizer".');
556.             }
558.             $this->registerHtmlSanitizerConfiguration($config['html_sanitizer'], $container, $loader);
559.         }
561.         $this->addAnnotatedClassesToCompile([
562.             '**\\Controller\\',
563.             '**\\Entity\\',
565.             // Added explicitly so that we don't rely on the class map being dumped to make it work
566.             AbstractController::class,
567.         ]);
569.         if (ContainerBuilder::willBeAvailable('symfony/mime', MimeTypes::class, ['symfony/framework-bundle'])) {
570.             $loader->load('mime_type.php');
571.         }
573.         $container->registerForAutoconfiguration(PackageInterface::class)
574.             ->addTag('assets.package');
575.         $container->registerForAutoconfiguration(Command::class)
576.             ->addTag('console.command');
577.         $container->registerForAutoconfiguration(ResourceCheckerInterface::class)
578.             ->addTag('config_cache.resource_checker');
579.         $container->registerForAutoconfiguration(EnvVarLoaderInterface::class)
580.             ->addTag('container.env_var_loader');
581.         $container->registerForAutoconfiguration(EnvVarProcessorInterface::class)
582.             ->addTag('container.env_var_processor');
583.         $container->registerForAutoconfiguration(CallbackInterface::class)
584.             ->addTag('container.reversible');
585.         $container->registerForAutoconfiguration(ServiceLocator::class)
586.             ->addTag('container.service_locator');
587.         $container->registerForAutoconfiguration(ServiceSubscriberInterface::class)
588.             ->addTag('container.service_subscriber');
589.         $container->registerForAutoconfiguration(ArgumentValueResolverInterface::class)
590.             ->addTag('controller.argument_value_resolver');
591.         $container->registerForAutoconfiguration(ValueResolverInterface::class)
592.             ->addTag('controller.argument_value_resolver');
593.         $container->registerForAutoconfiguration(AbstractController::class)
594.             ->addTag('controller.service_arguments');
595.         $container->registerForAutoconfiguration(DataCollectorInterface::class)
596.             ->addTag('data_collector');
597.         $container->registerForAutoconfiguration(FormTypeInterface::class)
598.             ->addTag('form.type');
599.         $container->registerForAutoconfiguration(FormTypeGuesserInterface::class)
600.             ->addTag('form.type_guesser');
601.         $container->registerForAutoconfiguration(FormTypeExtensionInterface::class)
602.             ->addTag('form.type_extension');
603.         $container->registerForAutoconfiguration(CacheClearerInterface::class)
604.             ->addTag('kernel.cache_clearer');
605.         $container->registerForAutoconfiguration(CacheWarmerInterface::class)
606.             ->addTag('kernel.cache_warmer');
607.         $container->registerForAutoconfiguration(EventDispatcherInterface::class)
608.             ->addTag('event_dispatcher.dispatcher');
609.         $container->registerForAutoconfiguration(EventSubscriberInterface::class)
610.             ->addTag('kernel.event_subscriber');
611.         $container->registerForAutoconfiguration(LocaleAwareInterface::class)
612.             ->addTag('kernel.locale_aware');
613.         $container->registerForAutoconfiguration(ResetInterface::class)
614.             ->addTag('kernel.reset', ['method' => 'reset']);
616.         if (!interface_exists(MarshallerInterface::class)) {
617.             $container->registerForAutoconfiguration(ResettableInterface::class)
618.                 ->addTag('kernel.reset', ['method' => 'reset']);
619.         }
621.         $container->registerForAutoconfiguration(PropertyListExtractorInterface::class)
622.             ->addTag('property_info.list_extractor');
623.         $container->registerForAutoconfiguration(PropertyTypeExtractorInterface::class)
624.             ->addTag('property_info.type_extractor');
625.         $container->registerForAutoconfiguration(PropertyDescriptionExtractorInterface::class)
626.             ->addTag('property_info.description_extractor');
627.         $container->registerForAutoconfiguration(PropertyAccessExtractorInterface::class)
628.             ->addTag('property_info.access_extractor');
629.         $container->registerForAutoconfiguration(PropertyInitializableExtractorInterface::class)
630.             ->addTag('property_info.initializable_extractor');
631.         $container->registerForAutoconfiguration(EncoderInterface::class)
632.             ->addTag('serializer.encoder');
633.         $container->registerForAutoconfiguration(DecoderInterface::class)
634.             ->addTag('serializer.encoder');
635.         $container->registerForAutoconfiguration(NormalizerInterface::class)
636.             ->addTag('serializer.normalizer');
637.         $container->registerForAutoconfiguration(DenormalizerInterface::class)
638.             ->addTag('serializer.normalizer');
639.         $container->registerForAutoconfiguration(ConstraintValidatorInterface::class)
640.             ->addTag('validator.constraint_validator');
641.         $container->registerForAutoconfiguration(ObjectInitializerInterface::class)
642.             ->addTag('validator.initializer');
643.         $container->registerForAutoconfiguration(MessageHandlerInterface::class)
644.             ->addTag('messenger.message_handler');
645.         $container->registerForAutoconfiguration(BatchHandlerInterface::class)
646.             ->addTag('messenger.message_handler');
647.         $container->registerForAutoconfiguration(TransportFactoryInterface::class)
648.             ->addTag('messenger.transport_factory');
649.         $container->registerForAutoconfiguration(MimeTypeGuesserInterface::class)
650.             ->addTag('mime.mime_type_guesser');
651.         $container->registerForAutoconfiguration(LoggerAwareInterface::class)
652.             ->addMethodCall('setLogger', [new Reference('logger')]);
654.         $container->registerAttributeForAutoconfiguration(AsEventListener::class, static function (ChildDefinition $definition, AsEventListener $attribute, \ReflectionClass|\ReflectionMethod $reflector) {
655.             $tagAttributes = get_object_vars($attribute);
656.             if ($reflector instanceof \ReflectionMethod) {
657.                 if (isset($tagAttributes['method'])) {
658.                     throw new LogicException(sprintf('AsEventListener attribute cannot declare a method on "%s::%s()".', $reflector->class, $reflector->name));
659.                 }
660.                 $tagAttributes['method'] = $reflector->getName();
661.             }
662.             $definition->addTag('kernel.event_listener', $tagAttributes);
663.         });
664.         $container->registerAttributeForAutoconfiguration(AsController::class, static function (ChildDefinition $definition, AsController $attribute): void {
665.             $definition->addTag('controller.service_arguments');
666.         });
668.         $container->registerAttributeForAutoconfiguration(AsMessageHandler::class, static function (ChildDefinition $definition, AsMessageHandler $attribute, \ReflectionClass|\ReflectionMethod $reflector): void {
669.             $tagAttributes = get_object_vars($attribute);
670.             $tagAttributes['from_transport'] = $tagAttributes['fromTransport'];
671.             unset($tagAttributes['fromTransport']);
672.             if ($reflector instanceof \ReflectionMethod) {
673.                 if (isset($tagAttributes['method'])) {
674.                     throw new LogicException(sprintf('AsMessageHandler attribute cannot declare a method on "%s::%s()".', $reflector->class, $reflector->name));
675.                 }
676.                 $tagAttributes['method'] = $reflector->getName();
677.             }
678.             $definition->addTag('messenger.message_handler', $tagAttributes);
679.         });
681.         if (!$container->getParameter('kernel.debug')) {
682.             // remove tagged iterator argument for resource checkers
683.             $container->getDefinition('config_cache_factory')->setArguments([]);
684.         }
686.         if (!$config['disallow_search_engine_index'] ?? false) {
687.             $container->removeDefinition('disallow_search_engine_index_response_listener');
688.         }
690.         $container->registerForAutoconfiguration(RouteLoaderInterface::class)
691.             ->addTag('routing.route_loader');
693.         $container->setParameter('container.behavior_describing_tags', [
694.             'annotations.cached_reader',
695.             'container.do_not_inline',
696.             'container.service_locator',
697.             'container.service_subscriber',
698.             'kernel.event_subscriber',
699.             'kernel.event_listener',
700.             'kernel.locale_aware',
701.             'kernel.reset',
702.         ]);
703.     }
705.     public function getConfiguration(array $config, ContainerBuilder $container): ?ConfigurationInterface
706.     {
707.         return new Configuration($container->getParameter('kernel.debug'));
708.     }
710.     protected function hasConsole(): bool
711.     {
712.         return class_exists(Application::class);
713.     }
715.     private function registerFormConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
716.     {
717.         $loader->load('form.php');
719.         if (null === $config['form']['csrf_protection']['enabled']) {
720.             $this->writeConfigEnabled('form.csrf_protection', $config['csrf_protection']['enabled'], $config['form']['csrf_protection']);
721.         }
723.         if ($this->readConfigEnabled('form.csrf_protection', $container, $config['form']['csrf_protection'])) {
724.             if (!$container->hasDefinition('security.csrf.token_generator')) {
725.                 throw new \LogicException('To use form CSRF protection, "framework.csrf_protection" must be enabled.');
726.             }
728.             $loader->load('form_csrf.php');
730.             $container->setParameter('form.type_extension.csrf.enabled', true);
731.             $container->setParameter('form.type_extension.csrf.field_name', $config['form']['csrf_protection']['field_name']);
732.         } else {
733.             $container->setParameter('form.type_extension.csrf.enabled', false);
734.         }
736.         if (!ContainerBuilder::willBeAvailable('symfony/translation', Translator::class, ['symfony/framework-bundle', 'symfony/form'])) {
737.             $container->removeDefinition('form.type_extension.upload.validator');
738.         }
739.         if (!method_exists(CachingFactoryDecorator::class, 'reset')) {
740.             $container->getDefinition('form.choice_list_factory.cached')
741.                 ->clearTag('kernel.reset')
742.             ;
743.         }
744.     }
746.     private function registerHttpCacheConfiguration(array $config, ContainerBuilder $container, bool $httpMethodOverride)
747.     {
748.         $options = $config;
749.         unset($options['enabled']);
751.         if (!$options['private_headers']) {
752.             unset($options['private_headers']);
753.         }
755.         $container->getDefinition('http_cache')
756.             ->setPublic($config['enabled'])
757.             ->replaceArgument(3, $options);
759.         if ($httpMethodOverride) {
760.             $container->getDefinition('http_cache')
761.                   ->addArgument((new Definition('void'))
762.                       ->setFactory([Request::class, 'enableHttpMethodParameterOverride'])
763.                   );
764.         }
765.     }
767.     private function registerEsiConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
768.     {
769.         if (!$this->readConfigEnabled('esi', $container, $config)) {
770.             $container->removeDefinition('fragment.renderer.esi');
772.             return;
773.         }
775.         $loader->load('esi.php');
776.     }
778.     private function registerSsiConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
779.     {
780.         if (!$this->readConfigEnabled('ssi', $container, $config)) {
781.             $container->removeDefinition('fragment.renderer.ssi');
783.             return;
784.         }
786.         $loader->load('ssi.php');
787.     }
789.     private function registerFragmentsConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
790.     {
791.         if (!$this->readConfigEnabled('fragments', $container, $config)) {
792.             $container->removeDefinition('fragment.renderer.hinclude');
794.             return;
795.         }
797.         $container->setParameter('fragment.renderer.hinclude.global_template', $config['hinclude_default_template']);
799.         $loader->load('fragment_listener.php');
800.         $container->setParameter('fragment.path', $config['path']);
801.     }
803.     private function registerProfilerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
804.     {
805.         if (!$this->readConfigEnabled('profiler', $container, $config)) {
806.             // this is needed for the WebProfiler to work even if the profiler is disabled
807.             $container->setParameter('data_collector.templates', []);
809.             return;
810.         }
812.         $loader->load('profiling.php');
813.         $loader->load('collectors.php');
814.         $loader->load('cache_debug.php');
816.         if ($this->isInitializedConfigEnabled('form')) {
817.             $loader->load('form_debug.php');
818.         }
820.         if ($this->isInitializedConfigEnabled('validation')) {
821.             $loader->load('validator_debug.php');
822.         }
824.         if ($this->isInitializedConfigEnabled('translator')) {
825.             $loader->load('translation_debug.php');
827.             $container->getDefinition('translator.data_collector')->setDecoratedService('translator');
828.         }
830.         if ($this->isInitializedConfigEnabled('messenger')) {
831.             $loader->load('messenger_debug.php');
832.         }
834.         if ($this->isInitializedConfigEnabled('mailer')) {
835.             $loader->load('mailer_debug.php');
836.         }
838.         if ($this->isInitializedConfigEnabled('http_client')) {
839.             $loader->load('http_client_debug.php');
840.         }
842.         if ($this->isInitializedConfigEnabled('notifier')) {
843.             $loader->load('notifier_debug.php');
844.         }
846.         if ($this->isInitializedConfigEnabled('serializer') && $config['collect_serializer_data']) {
847.             $loader->load('serializer_debug.php');
848.         }
850.         $container->setParameter('profiler_listener.only_exceptions', $config['only_exceptions']);
851.         $container->setParameter('profiler_listener.only_main_requests', $config['only_main_requests']);
853.         // Choose storage class based on the DSN
854.         [$class] = explode(':', $config['dsn'], 2);
855.         if ('file' !== $class) {
856.             throw new \LogicException(sprintf('Driver "%s" is not supported for the profiler.', $class));
857.         }
859.         $container->setParameter('profiler.storage.dsn', $config['dsn']);
861.         $container->getDefinition('profiler')
862.             ->addArgument($config['collect'])
863.             ->addTag('kernel.reset', ['method' => 'reset']);
865.         $container->getDefinition('profiler_listener')
866.             ->addArgument($config['collect_parameter']);
867.     }
869.     private function registerWorkflowConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
870.     {
871.         if (!$config['enabled']) {
872.             $container->removeDefinition('console.command.workflow_dump');
874.             return;
875.         }
877.         if (!class_exists(Workflow\Workflow::class)) {
878.             throw new LogicException('Workflow support cannot be enabled as the Workflow component is not installed. Try running "composer require symfony/workflow".');
879.         }
881.         $loader->load('workflow.php');
883.         $registryDefinition = $container->getDefinition('.workflow.registry');
885.         foreach ($config['workflows'] as $name => $workflow) {
886.             $type = $workflow['type'];
887.             $workflowId = sprintf('%s.%s', $type, $name);
889.             // Process Metadata (workflow + places (transition is done in the "create transition" block))
890.             $metadataStoreDefinition = new Definition(Workflow\Metadata\InMemoryMetadataStore::class, [[], [], null]);
891.             if ($workflow['metadata']) {
892.                 $metadataStoreDefinition->replaceArgument(0, $workflow['metadata']);
893.             }
894.             $placesMetadata = [];
895.             foreach ($workflow['places'] as $place) {
896.                 if ($place['metadata']) {
897.                     $placesMetadata[$place['name']] = $place['metadata'];
898.                 }
899.             }
900.             if ($placesMetadata) {
901.                 $metadataStoreDefinition->replaceArgument(1, $placesMetadata);
902.             }
904.             // Create transitions
905.             $transitions = [];
906.             $guardsConfiguration = [];
907.             $transitionsMetadataDefinition = new Definition(\SplObjectStorage::class);
908.             // Global transition counter per workflow
909.             $transitionCounter = 0;
910.             foreach ($workflow['transitions'] as $transition) {
911.                 if ('workflow' === $type) {
912.                     $transitionDefinition = new Definition(Workflow\Transition::class, [$transition['name'], $transition['from'], $transition['to']]);
913.                     $transitionDefinition->setPublic(false);
914.                     $transitionId = sprintf('.%s.transition.%s', $workflowId, $transitionCounter++);
915.                     $container->setDefinition($transitionId, $transitionDefinition);
916.                     $transitions[] = new Reference($transitionId);
917.                     if (isset($transition['guard'])) {
918.                         $configuration = new Definition(Workflow\EventListener\GuardExpression::class);
919.                         $configuration->addArgument(new Reference($transitionId));
920.                         $configuration->addArgument($transition['guard']);
921.                         $configuration->setPublic(false);
922.                         $eventName = sprintf('workflow.%s.guard.%s', $name, $transition['name']);
923.                         $guardsConfiguration[$eventName][] = $configuration;
924.                     }
925.                     if ($transition['metadata']) {
926.                         $transitionsMetadataDefinition->addMethodCall('attach', [
927.                             new Reference($transitionId),
928.                             $transition['metadata'],
929.                         ]);
930.                     }
931.                 } elseif ('state_machine' === $type) {
932.                     foreach ($transition['from'] as $from) {
933.                         foreach ($transition['to'] as $to) {
934.                             $transitionDefinition = new Definition(Workflow\Transition::class, [$transition['name'], $from, $to]);
935.                             $transitionDefinition->setPublic(false);
936.                             $transitionId = sprintf('.%s.transition.%s', $workflowId, $transitionCounter++);
937.                             $container->setDefinition($transitionId, $transitionDefinition);
938.                             $transitions[] = new Reference($transitionId);
939.                             if (isset($transition['guard'])) {
940.                                 $configuration = new Definition(Workflow\EventListener\GuardExpression::class);
941.                                 $configuration->addArgument(new Reference($transitionId));
942.                                 $configuration->addArgument($transition['guard']);
943.                                 $configuration->setPublic(false);
944.                                 $eventName = sprintf('workflow.%s.guard.%s', $name, $transition['name']);
945.                                 $guardsConfiguration[$eventName][] = $configuration;
946.                             }
947.                             if ($transition['metadata']) {
948.                                 $transitionsMetadataDefinition->addMethodCall('attach', [
949.                                     new Reference($transitionId),
950.                                     $transition['metadata'],
951.                                 ]);
952.                             }
953.                         }
954.                     }
955.                 }
956.             }
957.             $metadataStoreDefinition->replaceArgument(2, $transitionsMetadataDefinition);
958.             $container->setDefinition(sprintf('%s.metadata_store', $workflowId), $metadataStoreDefinition);
960.             // Create places
961.             $places = array_column($workflow['places'], 'name');
962.             $initialMarking = $workflow['initial_marking'] ?? [];
964.             // Create a Definition
965.             $definitionDefinition = new Definition(Workflow\Definition::class);
966.             $definitionDefinition->setPublic(false);
967.             $definitionDefinition->addArgument($places);
968.             $definitionDefinition->addArgument($transitions);
969.             $definitionDefinition->addArgument($initialMarking);
970.             $definitionDefinition->addArgument(new Reference(sprintf('%s.metadata_store', $workflowId)));
972.             // Create MarkingStore
973.             if (isset($workflow['marking_store']['type'])) {
974.                 $markingStoreDefinition = new ChildDefinition('workflow.marking_store.method');
975.                 $markingStoreDefinition->setArguments([
976.                     'state_machine' === $type, // single state
977.                     $workflow['marking_store']['property'],
978.                 ]);
979.             } elseif (isset($workflow['marking_store']['service'])) {
980.                 $markingStoreDefinition = new Reference($workflow['marking_store']['service']);
981.             }
983.             // Create Workflow
984.             $workflowDefinition = new ChildDefinition(sprintf('%s.abstract', $type));
985.             $workflowDefinition->replaceArgument(0, new Reference(sprintf('%s.definition', $workflowId)));
986.             $workflowDefinition->replaceArgument(1, $markingStoreDefinition ?? null);
987.             $workflowDefinition->replaceArgument(3, $name);
988.             $workflowDefinition->replaceArgument(4, $workflow['events_to_dispatch']);
990.             $workflowDefinition->addTag('workflow', ['name' => $name]);
991.             if ('workflow' === $type) {
992.                 $workflowDefinition->addTag('workflow.workflow', ['name' => $name]);
993.             } elseif ('state_machine' === $type) {
994.                 $workflowDefinition->addTag('workflow.state_machine', ['name' => $name]);
995.             }
997.             // Store to container
998.             $container->setDefinition($workflowId, $workflowDefinition);
999.             $container->setDefinition(sprintf('%s.definition', $workflowId), $definitionDefinition);
1000.             $container->registerAliasForArgument($workflowId, WorkflowInterface::class, $name.'.'.$type);
1002.             // Validate Workflow
1003.             if ('state_machine' === $workflow['type']) {
1004.                 $validator = new Workflow\Validator\StateMachineValidator();
1005.             } else {
1006.                 $validator = new Workflow\Validator\WorkflowValidator();
1007.             }
1009.             $trs = array_map(function (Reference $ref) use ($container): Workflow\Transition {
1010.                 return $container->get((string) $ref);
1011.             }, $transitions);
1012.             $realDefinition = new Workflow\Definition($places, $trs, $initialMarking);
1013.             $validator->validate($realDefinition, $name);
1015.             // Add workflow to Registry
1016.             if ($workflow['supports']) {
1017.                 foreach ($workflow['supports'] as $supportedClassName) {
1018.                     $strategyDefinition = new Definition(Workflow\SupportStrategy\InstanceOfSupportStrategy::class, [$supportedClassName]);
1019.                     $strategyDefinition->setPublic(false);
1020.                     $registryDefinition->addMethodCall('addWorkflow', [new Reference($workflowId), $strategyDefinition]);
1021.                 }
1022.             } elseif (isset($workflow['support_strategy'])) {
1023.                 $registryDefinition->addMethodCall('addWorkflow', [new Reference($workflowId), new Reference($workflow['support_strategy'])]);
1024.             }
1026.             // Enable the AuditTrail
1027.             if ($workflow['audit_trail']['enabled']) {
1028.                 $listener = new Definition(Workflow\EventListener\AuditTrailListener::class);
1029.                 $listener->addTag('monolog.logger', ['channel' => 'workflow']);
1030.                 $listener->addTag('kernel.event_listener', ['event' => sprintf('workflow.%s.leave', $name), 'method' => 'onLeave']);
1031.                 $listener->addTag('kernel.event_listener', ['event' => sprintf('workflow.%s.transition', $name), 'method' => 'onTransition']);
1032.                 $listener->addTag('kernel.event_listener', ['event' => sprintf('workflow.%s.enter', $name), 'method' => 'onEnter']);
1033.                 $listener->addArgument(new Reference('logger'));
1034.                 $container->setDefinition(sprintf('.%s.listener.audit_trail', $workflowId), $listener);
1035.             }
1037.             // Add Guard Listener
1038.             if ($guardsConfiguration) {
1039.                 if (!class_exists(ExpressionLanguage::class)) {
1040.                     throw new LogicException('Cannot guard workflows as the ExpressionLanguage component is not installed. Try running "composer require symfony/expression-language".');
1041.                 }
1043.                 if (!class_exists(AuthenticationEvents::class)) {
1044.                     throw new LogicException('Cannot guard workflows as the Security component is not installed. Try running "composer require symfony/security-core".');
1045.                 }
1047.                 $guard = new Definition(Workflow\EventListener\GuardListener::class);
1049.                 $guard->setArguments([
1050.                     $guardsConfiguration,
1051.                     new Reference('workflow.security.expression_language'),
1052.                     new Reference('security.token_storage'),
1053.                     new Reference('security.authorization_checker'),
1054.                     new Reference('security.authentication.trust_resolver'),
1055.                     new Reference('security.role_hierarchy'),
1056.                     new Reference('validator', ContainerInterface::NULL_ON_INVALID_REFERENCE),
1057.                 ]);
1058.                 foreach ($guardsConfiguration as $eventName => $config) {
1059.                     $guard->addTag('kernel.event_listener', ['event' => $eventName, 'method' => 'onTransition']);
1060.                 }
1062.                 $container->setDefinition(sprintf('.%s.listener.guard', $workflowId), $guard);
1063.                 $container->setParameter('workflow.has_guard_listeners', true);
1064.             }
1065.         }
1066.     }
1068.     private function registerDebugConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
1069.     {
1070.         $loader->load('debug_prod.php');
1072.         if (class_exists(Stopwatch::class)) {
1073.             $container->register('debug.stopwatch', Stopwatch::class)
1074.                 ->addArgument(true)
1075.                 ->addTag('kernel.reset', ['method' => 'reset']);
1076.             $container->setAlias(Stopwatch::class, new Alias('debug.stopwatch', false));
1077.         }
1079.         $debug = $container->getParameter('kernel.debug');
1081.         if ($debug) {
1082.             $container->setParameter('debug.container.dump', '%kernel.build_dir%/%kernel.container_class%.xml');
1083.         }
1085.         if ($debug && class_exists(Stopwatch::class)) {
1086.             $loader->load('debug.php');
1087.         }
1089.         $definition = $container->findDefinition('debug.debug_handlers_listener');
1091.         if (false === $config['log']) {
1092.             $definition->replaceArgument(1, null);
1093.         } elseif (true !== $config['log']) {
1094.             $definition->replaceArgument(2, $config['log']);
1095.         }
1097.         if (!$config['throw']) {
1098.             $container->setParameter('debug.error_handler.throw_at', 0);
1099.         }
1101.         if ($debug && class_exists(DebugProcessor::class)) {
1102.             $definition = new Definition(DebugProcessor::class);
1103.             $definition->setPublic(false);
1104.             $definition->addArgument(new Reference('request_stack'));
1105.             $container->setDefinition('debug.log_processor', $definition);
1106.         }
1107.     }
1109.     private function registerRouterConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader, array $enabledLocales = [])
1110.     {
1111.         if (!$this->readConfigEnabled('router', $container, $config)) {
1112.             $container->removeDefinition('console.command.router_debug');
1113.             $container->removeDefinition('console.command.router_match');
1114.             $container->removeDefinition('messenger.middleware.router_context');
1116.             return;
1117.         }
1118.         if (!class_exists(RouterContextMiddleware::class)) {
1119.             $container->removeDefinition('messenger.middleware.router_context');
1120.         }
1122.         $loader->load('routing.php');
1124.         if ($config['utf8']) {
1125.             $container->getDefinition('routing.loader')->replaceArgument(1, ['utf8' => true]);
1126.         }
1128.         if ($enabledLocales) {
1129.             $enabledLocales = implode('|', array_map('preg_quote', $enabledLocales));
1130.             $container->getDefinition('routing.loader')->replaceArgument(2, ['_locale' => $enabledLocales]);
1131.         }
1133.         if (!ContainerBuilder::willBeAvailable('symfony/expression-language', ExpressionLanguage::class, ['symfony/framework-bundle', 'symfony/routing'])) {
1134.             $container->removeDefinition('router.expression_language_provider');
1135.         }
1137.         $container->setParameter('router.resource', $config['resource']);
1138.         $container->setParameter('router.cache_dir', $config['cache_dir']);
1139.         $router = $container->findDefinition('router.default');
1140.         $argument = $router->getArgument(2);
1141.         $argument['strict_requirements'] = $config['strict_requirements'];
1142.         if (isset($config['type'])) {
1143.             $argument['resource_type'] = $config['type'];
1144.         }
1145.         $router->replaceArgument(2, $argument);
1147.         $container->setParameter('request_listener.http_port', $config['http_port']);
1148.         $container->setParameter('request_listener.https_port', $config['https_port']);
1150.         if (null !== $config['default_uri']) {
1151.             $container->getDefinition('router.request_context')
1152.                 ->replaceArgument(0, $config['default_uri']);
1153.         }
1155.         if (!class_exists(Psr4DirectoryLoader::class)) {
1156.             $container->removeDefinition('routing.loader.psr4');
1157.         }
1158.     }
1160.     private function registerSessionConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
1161.     {
1162.         $loader->load('session.php');
1164.         // session storage
1165.         $container->setAlias('session.storage.factory', $config['storage_factory_id']);
1167.         $options = ['cache_limiter' => '0'];
1168.         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) {
1169.             if (isset($config[$key])) {
1170.                 $options[$key] = $config[$key];
1171.             }
1172.         }
1174.         if ('auto' === ($options['cookie_secure'] ?? null)) {
1175.             $container->getDefinition('session.storage.factory.native')->replaceArgument(3, true);
1176.             $container->getDefinition('session.storage.factory.php_bridge')->replaceArgument(2, true);
1177.         }
1179.         $container->setParameter('session.storage.options', $options);
1181.         // session handler (the internal callback registered with PHP session management)
1182.         if (null === $config['handler_id']) {
1183.             // Set the handler class to be null
1184.             $container->getDefinition('session.storage.factory.native')->replaceArgument(1, null);
1185.             $container->getDefinition('session.storage.factory.php_bridge')->replaceArgument(0, null);
1187.             $container->setAlias('session.handler', 'session.handler.native_file');
1188.         } else {
1189.             $container->resolveEnvPlaceholders($config['handler_id'], null, $usedEnvs);
1191.             if ($usedEnvs || preg_match('#^[a-z]++://#', $config['handler_id'])) {
1192.                 $id = '.cache_connection.'.ContainerBuilder::hash($config['handler_id']);
1194.                 $container->getDefinition('session.abstract_handler')
1195.                     ->replaceArgument(0, $container->hasDefinition($id) ? new Reference($id) : $config['handler_id']);
1197.                 $container->setAlias('session.handler', 'session.abstract_handler');
1198.             } else {
1199.                 $container->setAlias('session.handler', $config['handler_id']);
1200.             }
1201.         }
1203.         $container->setParameter('session.save_path', $config['save_path']);
1205.         $container->setParameter('session.metadata.update_threshold', $config['metadata_update_threshold']);
1206.     }
1208.     private function registerRequestConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
1209.     {
1210.         if ($config['formats']) {
1211.             $loader->load('request.php');
1213.             $listener = $container->getDefinition('request.add_request_formats_listener');
1214.             $listener->replaceArgument(0, $config['formats']);
1215.         }
1216.     }
1218.     private function registerAssetsConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
1219.     {
1220.         $loader->load('assets.php');
1222.         if ($config['version_strategy']) {
1223.             $defaultVersion = new Reference($config['version_strategy']);
1224.         } else {
1225.             $defaultVersion = $this->createVersion($container, $config['version'], $config['version_format'], $config['json_manifest_path'], '_default', $config['strict_mode']);
1226.         }
1228.         $defaultPackage = $this->createPackageDefinition($config['base_path'], $config['base_urls'], $defaultVersion);
1229.         $container->setDefinition('assets._default_package', $defaultPackage);
1231.         foreach ($config['packages'] as $name => $package) {
1232.             if (null !== $package['version_strategy']) {
1233.                 $version = new Reference($package['version_strategy']);
1234.             } elseif (!\array_key_exists('version', $package) && null === $package['json_manifest_path']) {
1235.                 // if neither version nor json_manifest_path are specified, use the default
1236.                 $version = $defaultVersion;
1237.             } else {
1238.                 // let format fallback to main version_format
1239.                 $format = $package['version_format'] ?: $config['version_format'];
1240.                 $version = $package['version'] ?? null;
1241.                 $version = $this->createVersion($container, $version, $format, $package['json_manifest_path'], $name, $package['strict_mode']);
1242.             }
1244.             $packageDefinition = $this->createPackageDefinition($package['base_path'], $package['base_urls'], $version)
1245.                 ->addTag('assets.package', ['package' => $name]);
1246.             $container->setDefinition('assets._package_'.$name, $packageDefinition);
1247.             $container->registerAliasForArgument('assets._package_'.$name, PackageInterface::class, $name.'.package');
1248.         }
1249.     }
1251.     /**
1252.      * Returns a definition for an asset package.
1253.      */
1254.     private function createPackageDefinition(?string $basePath, array $baseUrls, Reference $version): Definition
1255.     {
1256.         if ($basePath && $baseUrls) {
1257.             throw new \LogicException('An asset package cannot have base URLs and base paths.');
1258.         }
1260.         $package = new ChildDefinition($baseUrls ? 'assets.url_package' : 'assets.path_package');
1261.         $package
1262.             ->setPublic(false)
1263.             ->replaceArgument(0, $baseUrls ?: $basePath)
1264.             ->replaceArgument(1, $version)
1265.         ;
1267.         return $package;
1268.     }
1270.     private function createVersion(ContainerBuilder $container, ?string $version, ?string $format, ?string $jsonManifestPath, string $name, bool $strictMode): Reference
1271.     {
1272.         // Configuration prevents $version and $jsonManifestPath from being set
1273.         if (null !== $version) {
1274.             $def = new ChildDefinition('assets.static_version_strategy');
1275.             $def
1276.                 ->replaceArgument(0, $version)
1277.                 ->replaceArgument(1, $format)
1278.             ;
1279.             $container->setDefinition('assets._version_'.$name, $def);
1281.             return new Reference('assets._version_'.$name);
1282.         }
1284.         if (null !== $jsonManifestPath) {
1285.             $def = new ChildDefinition('assets.json_manifest_version_strategy');
1286.             $def->replaceArgument(0, $jsonManifestPath);
1287.             $def->replaceArgument(2, $strictMode);
1288.             $container->setDefinition('assets._version_'.$name, $def);
1290.             return new Reference('assets._version_'.$name);
1291.         }
1293.         return new Reference('assets.empty_version_strategy');
1294.     }
1296.     private function registerTranslatorConfiguration(array $config, ContainerBuilder $container, LoaderInterface $loader, string $defaultLocale, array $enabledLocales)
1297.     {
1298.         if (!$this->readConfigEnabled('translator', $container, $config)) {
1299.             $container->removeDefinition('console.command.translation_debug');
1300.             $container->removeDefinition('console.command.translation_extract');
1301.             $container->removeDefinition('console.command.translation_pull');
1302.             $container->removeDefinition('console.command.translation_push');
1304.             return;
1305.         }
1307.         $loader->load('translation.php');
1309.         if (!ContainerBuilder::willBeAvailable('symfony/translation', LocaleSwitcher::class, ['symfony/framework-bundle'])) {
1310.             $container->removeDefinition('translation.locale_switcher');
1311.         }
1313.         // don't use ContainerBuilder::willBeAvailable() as these are not needed in production
1314.         if (interface_exists(Parser::class) && class_exists(PhpAstExtractor::class)) {
1315.             $container->removeDefinition('translation.extractor.php');
1316.         } else {
1317.             $container->removeDefinition('translation.extractor.php_ast');
1318.         }
1320.         $loader->load('translation_providers.php');
1322.         // Use the "real" translator instead of the identity default
1323.         $container->setAlias('translator', 'translator.default')->setPublic(true);
1324.         $container->setAlias('translator.formatter', new Alias($config['formatter'], false));
1325.         $translator = $container->findDefinition('translator.default');
1326.         $translator->addMethodCall('setFallbackLocales', [$config['fallbacks'] ?: [$defaultLocale]]);
1328.         $defaultOptions = $translator->getArgument(4);
1329.         $defaultOptions['cache_dir'] = $config['cache_dir'];
1330.         $translator->setArgument(4, $defaultOptions);
1331.         $translator->setArgument(5, $enabledLocales);
1333.         $container->setParameter('translator.logging', $config['logging']);
1334.         $container->setParameter('translator.default_path', $config['default_path']);
1336.         // Discover translation directories
1337.         $dirs = [];
1338.         $transPaths = [];
1339.         $nonExistingDirs = [];
1340.         if (ContainerBuilder::willBeAvailable('symfony/validator', Validation::class, ['symfony/framework-bundle', 'symfony/translation'])) {
1341.             $r = new \ReflectionClass(Validation::class);
1343.             $dirs[] = $transPaths[] = \dirname($r->getFileName()).'/Resources/translations';
1344.         }
1345.         if (ContainerBuilder::willBeAvailable('symfony/form', Form::class, ['symfony/framework-bundle', 'symfony/translation'])) {
1346.             $r = new \ReflectionClass(Form::class);
1348.             $dirs[] = $transPaths[] = \dirname($r->getFileName()).'/Resources/translations';
1349.         }
1350.         if (ContainerBuilder::willBeAvailable('symfony/security-core', AuthenticationException::class, ['symfony/framework-bundle', 'symfony/translation'])) {
1351.             $r = new \ReflectionClass(AuthenticationException::class);
1353.             $dirs[] = $transPaths[] = \dirname($r->getFileName(), 2).'/Resources/translations';
1354.         }
1355.         $defaultDir = $container->getParameterBag()->resolveValue($config['default_path']);
1356.         foreach ($container->getParameter('kernel.bundles_metadata') as $name => $bundle) {
1357.             if ($container->fileExists($dir = $bundle['path'].'/Resources/translations') || $container->fileExists($dir = $bundle['path'].'/translations')) {
1358.                 $dirs[] = $dir;
1359.             } else {
1360.                 $nonExistingDirs[] = $dir;
1361.             }
1362.         }
1364.         foreach ($config['paths'] as $dir) {
1365.             if ($container->fileExists($dir)) {
1366.                 $dirs[] = $transPaths[] = $dir;
1367.             } else {
1368.                 throw new \UnexpectedValueException(sprintf('"%s" defined in translator.paths does not exist or is not a directory.', $dir));
1369.             }
1370.         }
1372.         if ($container->hasDefinition('console.command.translation_debug')) {
1373.             $container->getDefinition('console.command.translation_debug')->replaceArgument(5, $transPaths);
1374.         }
1376.         if ($container->hasDefinition('console.command.translation_extract')) {
1377.             $container->getDefinition('console.command.translation_extract')->replaceArgument(6, $transPaths);
1378.         }
1380.         if (null === $defaultDir) {
1381.             // allow null
1382.         } elseif ($container->fileExists($defaultDir)) {
1383.             $dirs[] = $defaultDir;
1384.         } else {
1385.             $nonExistingDirs[] = $defaultDir;
1386.         }
1388.         // Register translation resources
1389.         if ($dirs) {
1390.             $files = [];
1392.             foreach ($dirs as $dir) {
1393.                 $finder = Finder::create()
1394.                     ->followLinks()
1395.                     ->files()
1396.                     ->filter(function (\SplFileInfo $file) {
1397.                         return 2 <= substr_count($file->getBasename(), '.') && preg_match('/\.\w+$/', $file->getBasename());
1398.                     })
1399.                     ->in($dir)
1400.                     ->sortByName()
1401.                 ;
1402.                 foreach ($finder as $file) {
1403.                     $fileNameParts = explode('.', basename($file));
1404.                     $locale = $fileNameParts[\count($fileNameParts) - 2];
1405.                     if (!isset($files[$locale])) {
1406.                         $files[$locale] = [];
1407.                     }
1409.                     $files[$locale][] = (string) $file;
1410.                 }
1411.             }
1413.             $projectDir = $container->getParameter('kernel.project_dir');
1415.             $options = array_merge(
1416.                 $translator->getArgument(4),
1417.                 [
1418.                     'resource_files' => $files,
1419.                     'scanned_directories' => $scannedDirectories = array_merge($dirs, $nonExistingDirs),
1420.                     'cache_vary' => [
1421.                         'scanned_directories' => array_map(static function (string $dir) use ($projectDir): string {
1422.                             return str_starts_with($dir, $projectDir.'/') ? substr($dir, 1 + \strlen($projectDir)) : $dir;
1423.                         }, $scannedDirectories),
1424.                     ],
1425.                 ]
1426.             );
1428.             $translator->replaceArgument(4, $options);
1429.         }
1431.         if ($config['pseudo_localization']['enabled']) {
1432.             $options = $config['pseudo_localization'];
1433.             unset($options['enabled']);
1435.             $container
1436.                 ->register('translator.pseudo', PseudoLocalizationTranslator::class)
1437.                 ->setDecoratedService('translator', null, -1) // Lower priority than "translator.data_collector"
1438.                 ->setArguments([
1439.                     new Reference('translator.pseudo.inner'),
1440.                     $options,
1441.                 ]);
1442.         }
1444.         $classToServices = [
1445.             CrowdinProviderFactory::class => 'translation.provider_factory.crowdin',
1446.             LocoProviderFactory::class => 'translation.provider_factory.loco',
1447.             LokaliseProviderFactory::class => 'translation.provider_factory.lokalise',
1448.         ];
1450.         $parentPackages = ['symfony/framework-bundle', 'symfony/translation', 'symfony/http-client'];
1452.         foreach ($classToServices as $class => $service) {
1453.             $package = substr($service, \strlen('translation.provider_factory.'));
1455.             if (!$container->hasDefinition('http_client') || !ContainerBuilder::willBeAvailable(sprintf('symfony/%s-translation-provider', $package), $class, $parentPackages)) {
1456.                 $container->removeDefinition($service);
1457.             }
1458.         }
1460.         if (!$config['providers']) {
1461.             return;
1462.         }
1464.         $locales = $enabledLocales;
1466.         foreach ($config['providers'] as $provider) {
1467.             if ($provider['locales']) {
1468.                 $locales += $provider['locales'];
1469.             }
1470.         }
1472.         $locales = array_unique($locales);
1474.         $container->getDefinition('console.command.translation_pull')
1475.             ->replaceArgument(4, array_merge($transPaths, [$config['default_path']]))
1476.             ->replaceArgument(5, $locales)
1477.         ;
1479.         $container->getDefinition('console.command.translation_push')
1480.             ->replaceArgument(2, array_merge($transPaths, [$config['default_path']]))
1481.             ->replaceArgument(3, $locales)
1482.         ;
1484.         $container->getDefinition('translation.provider_collection_factory')
1485.             ->replaceArgument(1, $locales)
1486.         ;
1488.         $container->getDefinition('translation.provider_collection')->setArgument(0, $config['providers']);
1489.     }
1491.     private function registerValidationConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader, bool $propertyInfoEnabled)
1492.     {
1493.         if (!$this->readConfigEnabled('validation', $container, $config)) {
1494.             $container->removeDefinition('console.command.validator_debug');
1496.             return;
1497.         }
1499.         if (!class_exists(Validation::class)) {
1500.             throw new LogicException('Validation support cannot be enabled as the Validator component is not installed. Try running "composer require symfony/validator".');
1501.         }
1503.         if (!isset($config['email_validation_mode'])) {
1504.             $config['email_validation_mode'] = 'loose';
1505.         }
1507.         $loader->load('validator.php');
1509.         $validatorBuilder = $container->getDefinition('validator.builder');
1511.         $container->setParameter('validator.translation_domain', $config['translation_domain']);
1513.         $files = ['xml' => [], 'yml' => []];
1514.         $this->registerValidatorMapping($container, $config, $files);
1516.         if (!empty($files['xml'])) {
1517.             $validatorBuilder->addMethodCall('addXmlMappings', [$files['xml']]);
1518.         }
1520.         if (!empty($files['yml'])) {
1521.             $validatorBuilder->addMethodCall('addYamlMappings', [$files['yml']]);
1522.         }
1524.         $definition = $container->findDefinition('validator.email');
1525.         $definition->replaceArgument(0, $config['email_validation_mode']);
1527.         if (\array_key_exists('enable_annotations', $config) && $config['enable_annotations']) {
1528.             $validatorBuilder->addMethodCall('enableAnnotationMapping', [true]);
1529.             if ($this->isInitializedConfigEnabled('annotations')) {
1530.                 $validatorBuilder->addMethodCall('setDoctrineAnnotationReader', [new Reference('annotation_reader')]);
1531.             }
1532.         }
1534.         if (\array_key_exists('static_method', $config) && $config['static_method']) {
1535.             foreach ($config['static_method'] as $methodName) {
1536.                 $validatorBuilder->addMethodCall('addMethodMapping', [$methodName]);
1537.             }
1538.         }
1540.         if (!$container->getParameter('kernel.debug')) {
1541.             $validatorBuilder->addMethodCall('setMappingCache', [new Reference('validator.mapping.cache.adapter')]);
1542.         }
1544.         $container->setParameter('validator.auto_mapping', $config['auto_mapping']);
1545.         if (!$propertyInfoEnabled || !class_exists(PropertyInfoLoader::class)) {
1546.             $container->removeDefinition('validator.property_info_loader');
1547.         }
1549.         $container
1550.             ->getDefinition('validator.not_compromised_password')
1551.             ->setArgument(2, $config['not_compromised_password']['enabled'])
1552.             ->setArgument(3, $config['not_compromised_password']['endpoint'])
1553.         ;
1555.         if (!class_exists(ExpressionLanguage::class)) {
1556.             $container->removeDefinition('validator.expression_language');
1557.         }
1559.         if (!class_exists(WhenValidator::class)) {
1560.             $container->removeDefinition('validator.when');
1561.         }
1562.     }
1564.     private function registerValidatorMapping(ContainerBuilder $container, array $config, array &$files)
1565.     {
1566.         $fileRecorder = function ($extension, $path) use (&$files) {
1567.             $files['yaml' === $extension ? 'yml' : $extension][] = $path;
1568.         };
1570.         if (ContainerBuilder::willBeAvailable('symfony/form', Form::class, ['symfony/framework-bundle', 'symfony/validator'])) {
1571.             $reflClass = new \ReflectionClass(Form::class);
1572.             $fileRecorder('xml', \dirname($reflClass->getFileName()).'/Resources/config/validation.xml');
1573.         }
1575.         foreach ($container->getParameter('kernel.bundles_metadata') as $bundle) {
1576.             $configDir = is_dir($bundle['path'].'/Resources/config') ? $bundle['path'].'/Resources/config' : $bundle['path'].'/config';
1578.             if (
1579.                 $container->fileExists($file = $configDir.'/validation.yaml', false) ||
1580.                 $container->fileExists($file = $configDir.'/validation.yml', false)
1581.             ) {
1582.                 $fileRecorder('yml', $file);
1583.             }
1585.             if ($container->fileExists($file = $configDir.'/validation.xml', false)) {
1586.                 $fileRecorder('xml', $file);
1587.             }
1589.             if ($container->fileExists($dir = $configDir.'/validation', '/^$/')) {
1590.                 $this->registerMappingFilesFromDir($dir, $fileRecorder);
1591.             }
1592.         }
1594.         $projectDir = $container->getParameter('kernel.project_dir');
1595.         if ($container->fileExists($dir = $projectDir.'/config/validator', '/^$/')) {
1596.             $this->registerMappingFilesFromDir($dir, $fileRecorder);
1597.         }
1599.         $this->registerMappingFilesFromConfig($container, $config, $fileRecorder);
1600.     }
1602.     private function registerMappingFilesFromDir(string $dir, callable $fileRecorder)
1603.     {
1604.         foreach (Finder::create()->followLinks()->files()->in($dir)->name('/\.(xml|ya?ml)$/')->sortByName() as $file) {
1605.             $fileRecorder($file->getExtension(), $file->getRealPath());
1606.         }
1607.     }
1609.     private function registerMappingFilesFromConfig(ContainerBuilder $container, array $config, callable $fileRecorder)
1610.     {
1611.         foreach ($config['mapping']['paths'] as $path) {
1612.             if (is_dir($path)) {
1613.                 $this->registerMappingFilesFromDir($path, $fileRecorder);
1614.                 $container->addResource(new DirectoryResource($path, '/^$/'));
1615.             } elseif ($container->fileExists($path, false)) {
1616.                 if (!preg_match('/\.(xml|ya?ml)$/', $path, $matches)) {
1617.                     throw new \RuntimeException(sprintf('Unsupported mapping type in "%s", supported types are XML & Yaml.', $path));
1618.                 }
1619.                 $fileRecorder($matches[1], $path);
1620.             } else {
1621.                 throw new \RuntimeException(sprintf('Could not open file or directory "%s".', $path));
1622.             }
1623.         }
1624.     }
1626.     private function registerAnnotationsConfiguration(array $config, ContainerBuilder $container, LoaderInterface $loader)
1627.     {
1628.         if (!$this->isInitializedConfigEnabled('annotations')) {
1629.             return;
1630.         }
1632.         if (!class_exists(\Doctrine\Common\Annotations\Annotation::class)) {
1633.             throw new LogicException('Annotations cannot be enabled as the Doctrine Annotation library is not installed. Try running "composer require doctrine/annotations".');
1634.         }
1636.         $loader->load('annotations.php');
1638.         // registerUniqueLoader exists since doctrine/annotations v1.6
1639.         if (!method_exists(AnnotationRegistry::class, 'registerUniqueLoader')) {
1640.             // registerLoader exists only in doctrine/annotations v1
1641.             if (method_exists(AnnotationRegistry::class, 'registerLoader')) {
1642.                 $container->getDefinition('annotations.dummy_registry')
1643.                     ->setMethodCalls([['registerLoader', ['class_exists']]]);
1644.             } else {
1645.                 // remove the dummy registry when doctrine/annotations v2 is used
1646.                 $container->removeDefinition('annotations.dummy_registry');
1647.             }
1648.         }
1650.         if ('none' === $config['cache']) {
1651.             $container->removeDefinition('annotations.cached_reader');
1653.             return;
1654.         }
1656.         if ('php_array' === $config['cache']) {
1657.             $cacheService = 'annotations.cache_adapter';
1659.             // Enable warmer only if PHP array is used for cache
1660.             $definition = $container->findDefinition('annotations.cache_warmer');
1661.             $definition->addTag('kernel.cache_warmer');
1662.         } else {
1663.             $cacheService = 'annotations.filesystem_cache_adapter';
1664.             $cacheDir = $container->getParameterBag()->resolveValue($config['file_cache_dir']);
1666.             if (!is_dir($cacheDir) && false === @mkdir($cacheDir, 0777, true) && !is_dir($cacheDir)) {
1667.                 throw new \RuntimeException(sprintf('Could not create cache directory "%s".', $cacheDir));
1668.             }
1670.             $container
1671.                 ->getDefinition('annotations.filesystem_cache_adapter')
1672.                 ->replaceArgument(2, $cacheDir)
1673.             ;
1674.         }
1676.         $container
1677.             ->getDefinition('annotations.cached_reader')
1678.             ->replaceArgument(2, $config['debug'])
1679.             // reference the cache provider without using it until AddAnnotationsCachedReaderPass runs
1680.             ->addArgument(new ServiceClosureArgument(new Reference($cacheService)))
1681.         ;
1683.         $container->setAlias('annotation_reader', 'annotations.cached_reader');
1684.         $container->setAlias(Reader::class, new Alias('annotations.cached_reader', false));
1685.         $container->removeDefinition('annotations.psr_cached_reader');
1686.     }
1688.     private function registerPropertyAccessConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
1689.     {
1690.         if (!$this->readConfigEnabled('property_access', $container, $config)) {
1691.             return;
1692.         }
1694.         $loader->load('property_access.php');
1696.         $magicMethods = PropertyAccessor::DISALLOW_MAGIC_METHODS;
1697.         $magicMethods |= $config['magic_call'] ? PropertyAccessor::MAGIC_CALL : 0;
1698.         $magicMethods |= $config['magic_get'] ? PropertyAccessor::MAGIC_GET : 0;
1699.         $magicMethods |= $config['magic_set'] ? PropertyAccessor::MAGIC_SET : 0;
1701.         $throw = PropertyAccessor::DO_NOT_THROW;
1702.         $throw |= $config['throw_exception_on_invalid_index'] ? PropertyAccessor::THROW_ON_INVALID_INDEX : 0;
1703.         $throw |= $config['throw_exception_on_invalid_property_path'] ? PropertyAccessor::THROW_ON_INVALID_PROPERTY_PATH : 0;
1705.         $container
1706.             ->getDefinition('property_accessor')
1707.             ->replaceArgument(0, $magicMethods)
1708.             ->replaceArgument(1, $throw)
1709.             ->replaceArgument(3, new Reference(PropertyReadInfoExtractorInterface::class, ContainerInterface::NULL_ON_INVALID_REFERENCE))
1710.             ->replaceArgument(4, new Reference(PropertyWriteInfoExtractorInterface::class, ContainerInterface::NULL_ON_INVALID_REFERENCE))
1711.         ;
1712.     }
1714.     private function registerSecretsConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
1715.     {
1716.         if (!$this->readConfigEnabled('secrets', $container, $config)) {
1717.             $container->removeDefinition('console.command.secrets_set');
1718.             $container->removeDefinition('console.command.secrets_list');
1719.             $container->removeDefinition('console.command.secrets_remove');
1720.             $container->removeDefinition('console.command.secrets_generate_key');
1721.             $container->removeDefinition('console.command.secrets_decrypt_to_local');
1722.             $container->removeDefinition('console.command.secrets_encrypt_from_local');
1724.             return;
1725.         }
1727.         $loader->load('secrets.php');
1729.         $container->getDefinition('secrets.vault')->replaceArgument(0, $config['vault_directory']);
1731.         if ($config['local_dotenv_file']) {
1732.             $container->getDefinition('secrets.local_vault')->replaceArgument(0, $config['local_dotenv_file']);
1733.         } else {
1734.             $container->removeDefinition('secrets.local_vault');
1735.         }
1737.         if ($config['decryption_env_var']) {
1738.             if (!preg_match('/^(?:[-.\w\\\\]*+:)*+\w++$/', $config['decryption_env_var'])) {
1739.                 throw new InvalidArgumentException(sprintf('Invalid value "%s" set as "decryption_env_var": only "word" characters are allowed.', $config['decryption_env_var']));
1740.             }
1742.             if (ContainerBuilder::willBeAvailable('symfony/string', LazyString::class, ['symfony/framework-bundle'])) {
1743.                 $container->getDefinition('secrets.decryption_key')->replaceArgument(1, $config['decryption_env_var']);
1744.             } else {
1745.                 $container->getDefinition('secrets.vault')->replaceArgument(1, "%env({$config['decryption_env_var']})%");
1746.                 $container->removeDefinition('secrets.decryption_key');
1747.             }
1748.         } else {
1749.             $container->getDefinition('secrets.vault')->replaceArgument(1, null);
1750.             $container->removeDefinition('secrets.decryption_key');
1751.         }
1752.     }
1754.     private function registerSecurityCsrfConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
1755.     {
1756.         if (!$this->readConfigEnabled('csrf_protection', $container, $config)) {
1757.             return;
1758.         }
1760.         if (!class_exists(\Symfony\Component\Security\Csrf\CsrfToken::class)) {
1761.             throw new LogicException('CSRF support cannot be enabled as the Security CSRF component is not installed. Try running "composer require symfony/security-csrf".');
1762.         }
1764.         if (!$this->isInitializedConfigEnabled('session')) {
1765.             throw new \LogicException('CSRF protection needs sessions to be enabled.');
1766.         }
1768.         // Enable services for CSRF protection (even without forms)
1769.         $loader->load('security_csrf.php');
1771.         if (!class_exists(CsrfExtension::class)) {
1772.             $container->removeDefinition('twig.extension.security_csrf');
1773.         }
1774.     }
1776.     private function registerSerializerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
1777.     {
1778.         $loader->load('serializer.php');
1779.         if ($container->getParameter('kernel.debug')) {
1780.             $container->removeDefinition('serializer.mapping.cache_class_metadata_factory');
1781.         }
1783.         $chainLoader = $container->getDefinition('serializer.mapping.chain_loader');
1785.         if (!$this->isInitializedConfigEnabled('property_access')) {
1786.             $container->removeAlias('serializer.property_accessor');
1787.             $container->removeDefinition('serializer.normalizer.object');
1788.         }
1790.         if (!class_exists(Yaml::class)) {
1791.             $container->removeDefinition('serializer.encoder.yaml');
1792.         }
1794.         if (!class_exists(UnwrappingDenormalizer::class) || !$this->isInitializedConfigEnabled('property_access')) {
1795.             $container->removeDefinition('serializer.denormalizer.unwrapping');
1796.         }
1798.         if (!class_exists(Headers::class)) {
1799.             $container->removeDefinition('serializer.normalizer.mime_message');
1800.         }
1802.         $serializerLoaders = [];
1803.         if (isset($config['enable_annotations']) && $config['enable_annotations']) {
1804.             $annotationLoader = new Definition(
1805.                 AnnotationLoader::class,
1806.                 [new Reference('annotation_reader', ContainerInterface::NULL_ON_INVALID_REFERENCE)]
1807.             );
1808.             $annotationLoader->setPublic(false);
1810.             $serializerLoaders[] = $annotationLoader;
1811.         }
1813.         $fileRecorder = function ($extension, $path) use (&$serializerLoaders) {
1814.             $definition = new Definition(\in_array($extension, ['yaml', 'yml']) ? YamlFileLoader::class : XmlFileLoader::class, [$path]);
1815.             $definition->setPublic(false);
1816.             $serializerLoaders[] = $definition;
1817.         };
1819.         foreach ($container->getParameter('kernel.bundles_metadata') as $bundle) {
1820.             $configDir = is_dir($bundle['path'].'/Resources/config') ? $bundle['path'].'/Resources/config' : $bundle['path'].'/config';
1822.             if ($container->fileExists($file = $configDir.'/serialization.xml', false)) {
1823.                 $fileRecorder('xml', $file);
1824.             }
1826.             if (
1827.                 $container->fileExists($file = $configDir.'/serialization.yaml', false) ||
1828.                 $container->fileExists($file = $configDir.'/serialization.yml', false)
1829.             ) {
1830.                 $fileRecorder('yml', $file);
1831.             }
1833.             if ($container->fileExists($dir = $configDir.'/serialization', '/^$/')) {
1834.                 $this->registerMappingFilesFromDir($dir, $fileRecorder);
1835.             }
1836.         }
1838.         $projectDir = $container->getParameter('kernel.project_dir');
1839.         if ($container->fileExists($dir = $projectDir.'/config/serializer', '/^$/')) {
1840.             $this->registerMappingFilesFromDir($dir, $fileRecorder);
1841.         }
1843.         $this->registerMappingFilesFromConfig($container, $config, $fileRecorder);
1845.         $chainLoader->replaceArgument(0, $serializerLoaders);
1846.         $container->getDefinition('serializer.mapping.cache_warmer')->replaceArgument(0, $serializerLoaders);
1848.         if (isset($config['name_converter']) && $config['name_converter']) {
1849.             $container->getDefinition('serializer.name_converter.metadata_aware')->setArgument(1, new Reference($config['name_converter']));
1850.         }
1852.         if (isset($config['circular_reference_handler']) && $config['circular_reference_handler']) {
1853.             $arguments = $container->getDefinition('serializer.normalizer.object')->getArguments();
1854.             $context = ($arguments[6] ?? []) + ['circular_reference_handler' => new Reference($config['circular_reference_handler'])];
1855.             $container->getDefinition('serializer.normalizer.object')->setArgument(5, null);
1856.             $container->getDefinition('serializer.normalizer.object')->setArgument(6, $context);
1857.         }
1859.         if ($config['max_depth_handler'] ?? false) {
1860.             $defaultContext = $container->getDefinition('serializer.normalizer.object')->getArgument(6);
1861.             $defaultContext += ['max_depth_handler' => new Reference($config['max_depth_handler'])];
1862.             $container->getDefinition('serializer.normalizer.object')->replaceArgument(6, $defaultContext);
1863.         }
1865.         if (isset($config['default_context']) && $config['default_context']) {
1866.             $container->setParameter('serializer.default_context', $config['default_context']);
1867.         }
1868.     }
1870.     private function registerPropertyInfoConfiguration(ContainerBuilder $container, PhpFileLoader $loader)
1871.     {
1872.         if (!interface_exists(PropertyInfoExtractorInterface::class)) {
1873.             throw new LogicException('PropertyInfo support cannot be enabled as the PropertyInfo component is not installed. Try running "composer require symfony/property-info".');
1874.         }
1876.         $loader->load('property_info.php');
1878.         if (
1879.             ContainerBuilder::willBeAvailable('phpstan/phpdoc-parser', PhpDocParser::class, ['symfony/framework-bundle', 'symfony/property-info'])
1880.             && ContainerBuilder::willBeAvailable('phpdocumentor/type-resolver', ContextFactory::class, ['symfony/framework-bundle', 'symfony/property-info'])
1881.         ) {
1882.             $definition = $container->register('property_info.phpstan_extractor', PhpStanExtractor::class);
1883.             $definition->addTag('property_info.type_extractor', ['priority' => -1000]);
1884.         }
1886.         if (ContainerBuilder::willBeAvailable('phpdocumentor/reflection-docblock', DocBlockFactoryInterface::class, ['symfony/framework-bundle', 'symfony/property-info'], true)) {
1887.             $definition = $container->register('property_info.php_doc_extractor', PhpDocExtractor::class);
1888.             $definition->addTag('property_info.description_extractor', ['priority' => -1000]);
1889.             $definition->addTag('property_info.type_extractor', ['priority' => -1001]);
1890.         }
1892.         if ($container->getParameter('kernel.debug')) {
1893.             $container->removeDefinition('property_info.cache');
1894.         }
1895.     }
1897.     private function registerLockConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
1898.     {
1899.         $loader->load('lock.php');
1901.         foreach ($config['resources'] as $resourceName => $resourceStores) {
1902.             if (0 === \count($resourceStores)) {
1903.                 continue;
1904.             }
1906.             // Generate stores
1907.             $storeDefinitions = [];
1908.             foreach ($resourceStores as $resourceStore) {
1909.                 $storeDsn = $container->resolveEnvPlaceholders($resourceStore, null, $usedEnvs);
1910.                 $storeDefinition = new Definition(PersistingStoreInterface::class);
1911.                 $storeDefinition->setFactory([StoreFactory::class, 'createStore']);
1912.                 $storeDefinition->setArguments([$resourceStore]);
1914.                 $container->setDefinition($storeDefinitionId = '.lock.'.$resourceName.'.store.'.$container->hash($storeDsn), $storeDefinition);
1916.                 $storeDefinition = new Reference($storeDefinitionId);
1918.                 $storeDefinitions[] = $storeDefinition;
1919.             }
1921.             // Wrap array of stores with CombinedStore
1922.             if (\count($storeDefinitions) > 1) {
1923.                 $combinedDefinition = new ChildDefinition('lock.store.combined.abstract');
1924.                 $combinedDefinition->replaceArgument(0, $storeDefinitions);
1925.                 $container->setDefinition($storeDefinitionId = '.lock.'.$resourceName.'.store.'.$container->hash($resourceStores), $combinedDefinition);
1926.             }
1928.             // Generate factories for each resource
1929.             $factoryDefinition = new ChildDefinition('lock.factory.abstract');
1930.             $factoryDefinition->replaceArgument(0, new Reference($storeDefinitionId));
1931.             $container->setDefinition('lock.'.$resourceName.'.factory', $factoryDefinition);
1933.             // provide alias for default resource
1934.             if ('default' === $resourceName) {
1935.                 $container->setAlias('lock.factory', new Alias('lock.'.$resourceName.'.factory', false));
1936.                 $container->setAlias(LockFactory::class, new Alias('lock.factory', false));
1937.             } else {
1938.                 $container->registerAliasForArgument('lock.'.$resourceName.'.factory', LockFactory::class, $resourceName.'.lock.factory');
1939.             }
1940.         }
1941.     }
1943.     private function registerSemaphoreConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
1944.     {
1945.         $loader->load('semaphore.php');
1947.         foreach ($config['resources'] as $resourceName => $resourceStore) {
1948.             $storeDsn = $container->resolveEnvPlaceholders($resourceStore, null, $usedEnvs);
1949.             $storeDefinition = new Definition(SemaphoreStoreInterface::class);
1950.             $storeDefinition->setFactory([SemaphoreStoreFactory::class, 'createStore']);
1951.             $storeDefinition->setArguments([$resourceStore]);
1953.             $container->setDefinition($storeDefinitionId = '.semaphore.'.$resourceName.'.store.'.$container->hash($storeDsn), $storeDefinition);
1955.             // Generate factories for each resource
1956.             $factoryDefinition = new ChildDefinition('semaphore.factory.abstract');
1957.             $factoryDefinition->replaceArgument(0, new Reference($storeDefinitionId));
1958.             $container->setDefinition('semaphore.'.$resourceName.'.factory', $factoryDefinition);
1960.             // Generate services for semaphore instances
1961.             $semaphoreDefinition = new Definition(Semaphore::class);
1962.             $semaphoreDefinition->setPublic(false);
1963.             $semaphoreDefinition->setFactory([new Reference('semaphore.'.$resourceName.'.factory'), 'createSemaphore']);
1964.             $semaphoreDefinition->setArguments([$resourceName]);
1966.             // provide alias for default resource
1967.             if ('default' === $resourceName) {
1968.                 $container->setAlias('semaphore.factory', new Alias('semaphore.'.$resourceName.'.factory', false));
1969.                 $container->setAlias(SemaphoreFactory::class, new Alias('semaphore.factory', false));
1970.             } else {
1971.                 $container->registerAliasForArgument('semaphore.'.$resourceName.'.factory', SemaphoreFactory::class, $resourceName.'.semaphore.factory');
1972.             }
1973.         }
1974.     }
1976.     private function registerMessengerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader, array $validationConfig)
1977.     {
1978.         if (!interface_exists(MessageBusInterface::class)) {
1979.             throw new LogicException('Messenger support cannot be enabled as the Messenger component is not installed. Try running "composer require symfony/messenger".');
1980.         }
1982.         if (!$this->hasConsole() || !class_exists(StatsCommand::class)) {
1983.             $container->removeDefinition('console.command.messenger_stats');
1984.         }
1986.         $loader->load('messenger.php');
1988.         if (!interface_exists(DenormalizerInterface::class)) {
1989.             $container->removeDefinition('serializer.normalizer.flatten_exception');
1990.         }
1992.         if (ContainerBuilder::willBeAvailable('symfony/amqp-messenger', AmqpTransportFactory::class, ['symfony/framework-bundle', 'symfony/messenger'])) {
1993.             $container->getDefinition('messenger.transport.amqp.factory')->addTag('messenger.transport_factory');
1994.         }
1996.         if (ContainerBuilder::willBeAvailable('symfony/redis-messenger', RedisTransportFactory::class, ['symfony/framework-bundle', 'symfony/messenger'])) {
1997.             $container->getDefinition('messenger.transport.redis.factory')->addTag('messenger.transport_factory');
1998.         }
2000.         if (ContainerBuilder::willBeAvailable('symfony/amazon-sqs-messenger', AmazonSqsTransportFactory::class, ['symfony/framework-bundle', 'symfony/messenger'])) {
2001.             $container->getDefinition('messenger.transport.sqs.factory')->addTag('messenger.transport_factory');
2002.         }
2004.         if (ContainerBuilder::willBeAvailable('symfony/beanstalkd-messenger', BeanstalkdTransportFactory::class, ['symfony/framework-bundle', 'symfony/messenger'])) {
2005.             $container->getDefinition('messenger.transport.beanstalkd.factory')->addTag('messenger.transport_factory');
2006.         }
2008.         if (null === $config['default_bus'] && 1 === \count($config['buses'])) {
2009.             $config['default_bus'] = key($config['buses']);
2010.         }
2012.         $defaultMiddleware = [
2013.             'before' => [
2014.                 ['id' => 'add_bus_name_stamp_middleware'],
2015.                 ['id' => 'reject_redelivered_message_middleware'],
2016.                 ['id' => 'dispatch_after_current_bus'],
2017.                 ['id' => 'failed_message_processing_middleware'],
2018.             ],
2019.             'after' => [
2020.                 ['id' => 'send_message'],
2021.                 ['id' => 'handle_message'],
2022.             ],
2023.         ];
2024.         foreach ($config['buses'] as $busId => $bus) {
2025.             $middleware = $bus['middleware'];
2027.             if ($bus['default_middleware']['enabled']) {
2028.                 $defaultMiddleware['after'][0]['arguments'] = [$bus['default_middleware']['allow_no_senders']];
2029.                 $defaultMiddleware['after'][1]['arguments'] = [$bus['default_middleware']['allow_no_handlers']];
2031.                 // argument to add_bus_name_stamp_middleware
2032.                 $defaultMiddleware['before'][0]['arguments'] = [$busId];
2034.                 $middleware = array_merge($defaultMiddleware['before'], $middleware, $defaultMiddleware['after']);
2035.             }
2037.             foreach ($middleware as $middlewareItem) {
2038.                 if (!$validationConfig['enabled'] && \in_array($middlewareItem['id'], ['validation', 'messenger.middleware.validation'], true)) {
2039.                     throw new LogicException('The Validation middleware is only available when the Validator component is installed and enabled. Try running "composer require symfony/validator".');
2040.                 }
2041.             }
2043.             if ($container->getParameter('kernel.debug') && class_exists(Stopwatch::class)) {
2044.                 array_unshift($middleware, ['id' => 'traceable', 'arguments' => [$busId]]);
2045.             }
2047.             $container->setParameter($busId.'.middleware', $middleware);
2048.             $container->register($busId, MessageBus::class)->addArgument([])->addTag('messenger.bus');
2050.             if ($busId === $config['default_bus']) {
2051.                 $container->setAlias('messenger.default_bus', $busId)->setPublic(true);
2052.                 $container->setAlias(MessageBusInterface::class, $busId);
2053.             } else {
2054.                 $container->registerAliasForArgument($busId, MessageBusInterface::class);
2055.             }
2056.         }
2058.         if (empty($config['transports'])) {
2059.             $container->removeDefinition('messenger.transport.symfony_serializer');
2060.             $container->removeDefinition('messenger.transport.amqp.factory');
2061.             $container->removeDefinition('messenger.transport.redis.factory');
2062.             $container->removeDefinition('messenger.transport.sqs.factory');
2063.             $container->removeDefinition('messenger.transport.beanstalkd.factory');
2064.             $container->removeAlias(SerializerInterface::class);
2065.         } else {
2066.             $container->getDefinition('messenger.transport.symfony_serializer')
2067.                 ->replaceArgument(1, $config['serializer']['symfony_serializer']['format'])
2068.                 ->replaceArgument(2, $config['serializer']['symfony_serializer']['context']);
2069.             $container->setAlias('messenger.default_serializer', $config['serializer']['default_serializer']);
2070.         }
2072.         $failureTransports = [];
2073.         if ($config['failure_transport']) {
2074.             if (!isset($config['transports'][$config['failure_transport']])) {
2075.                 throw new LogicException(sprintf('Invalid Messenger configuration: the failure transport "%s" is not a valid transport or service id.', $config['failure_transport']));
2076.             }
2078.             $container->setAlias('messenger.failure_transports.default', 'messenger.transport.'.$config['failure_transport']);
2079.             $failureTransports[] = $config['failure_transport'];
2080.         }
2082.         $failureTransportsByName = [];
2083.         foreach ($config['transports'] as $name => $transport) {
2084.             if ($transport['failure_transport']) {
2085.                 $failureTransports[] = $transport['failure_transport'];
2086.                 $failureTransportsByName[$name] = $transport['failure_transport'];
2087.             } elseif ($config['failure_transport']) {
2088.                 $failureTransportsByName[$name] = $config['failure_transport'];
2089.             }
2090.         }
2092.         $senderAliases = [];
2093.         $transportRetryReferences = [];
2094.         $transportRateLimiterReferences = [];
2095.         foreach ($config['transports'] as $name => $transport) {
2096.             $serializerId = $transport['serializer'] ?? 'messenger.default_serializer';
2097.             $transportDefinition = (new Definition(TransportInterface::class))
2098.                 ->setFactory([new Reference('messenger.transport_factory'), 'createTransport'])
2099.                 ->setArguments([$transport['dsn'], $transport['options'] + ['transport_name' => $name], new Reference($serializerId)])
2100.                 ->addTag('messenger.receiver', [
2101.                         'alias' => $name,
2102.                         'is_failure_transport' => \in_array($name, $failureTransports),
2103.                     ]
2104.                 )
2105.             ;
2106.             $container->setDefinition($transportId = 'messenger.transport.'.$name, $transportDefinition);
2107.             $senderAliases[$name] = $transportId;
2109.             if (null !== $transport['retry_strategy']['service']) {
2110.                 $transportRetryReferences[$name] = new Reference($transport['retry_strategy']['service']);
2111.             } else {
2112.                 $retryServiceId = sprintf('messenger.retry.multiplier_retry_strategy.%s', $name);
2113.                 $retryDefinition = new ChildDefinition('messenger.retry.abstract_multiplier_retry_strategy');
2114.                 $retryDefinition
2115.                     ->replaceArgument(0, $transport['retry_strategy']['max_retries'])
2116.                     ->replaceArgument(1, $transport['retry_strategy']['delay'])
2117.                     ->replaceArgument(2, $transport['retry_strategy']['multiplier'])
2118.                     ->replaceArgument(3, $transport['retry_strategy']['max_delay']);
2119.                 $container->setDefinition($retryServiceId, $retryDefinition);
2121.                 $transportRetryReferences[$name] = new Reference($retryServiceId);
2122.             }
2124.             if ($transport['rate_limiter']) {
2125.                 if (!interface_exists(LimiterInterface::class)) {
2126.                     throw new LogicException('Rate limiter cannot be used within Messenger as the RateLimiter component is not installed. Try running "composer require symfony/rate-limiter".');
2127.                 }
2129.                 $transportRateLimiterReferences[$name] = new Reference('limiter.'.$transport['rate_limiter']);
2130.             }
2131.         }
2133.         $senderReferences = [];
2134.         // alias => service_id
2135.         foreach ($senderAliases as $alias => $serviceId) {
2136.             $senderReferences[$alias] = new Reference($serviceId);
2137.         }
2138.         // service_id => service_id
2139.         foreach ($senderAliases as $serviceId) {
2140.             $senderReferences[$serviceId] = new Reference($serviceId);
2141.         }
2143.         foreach ($config['transports'] as $name => $transport) {
2144.             if ($transport['failure_transport']) {
2145.                 if (!isset($senderReferences[$transport['failure_transport']])) {
2146.                     throw new LogicException(sprintf('Invalid Messenger configuration: the failure transport "%s" is not a valid transport or service id.', $transport['failure_transport']));
2147.                 }
2148.             }
2149.         }
2151.         $failureTransportReferencesByTransportName = array_map(function ($failureTransportName) use ($senderReferences) {
2152.             return $senderReferences[$failureTransportName];
2153.         }, $failureTransportsByName);
2155.         $messageToSendersMapping = [];
2156.         foreach ($config['routing'] as $message => $messageConfiguration) {
2157.             if ('*' !== $message && !class_exists($message) && !interface_exists($message, false)) {
2158.                 throw new LogicException(sprintf('Invalid Messenger routing configuration: class or interface "%s" not found.', $message));
2159.             }
2161.             // make sure senderAliases contains all senders
2162.             foreach ($messageConfiguration['senders'] as $sender) {
2163.                 if (!isset($senderReferences[$sender])) {
2164.                     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));
2165.                 }
2166.             }
2168.             $messageToSendersMapping[$message] = $messageConfiguration['senders'];
2169.         }
2171.         $sendersServiceLocator = ServiceLocatorTagPass::register($container, $senderReferences);
2173.         $container->getDefinition('messenger.senders_locator')
2174.             ->replaceArgument(0, $messageToSendersMapping)
2175.             ->replaceArgument(1, $sendersServiceLocator)
2176.         ;
2178.         $container->getDefinition('messenger.retry.send_failed_message_for_retry_listener')
2179.             ->replaceArgument(0, $sendersServiceLocator)
2180.         ;
2182.         $container->getDefinition('messenger.retry_strategy_locator')
2183.             ->replaceArgument(0, $transportRetryReferences);
2185.         if (!$transportRateLimiterReferences) {
2186.             $container->removeDefinition('messenger.rate_limiter_locator');
2187.         } else {
2188.             $container->getDefinition('messenger.rate_limiter_locator')
2189.                 ->replaceArgument(0, $transportRateLimiterReferences);
2190.         }
2192.         if (\count($failureTransports) > 0) {
2193.             $container->getDefinition('console.command.messenger_failed_messages_retry')
2194.                 ->replaceArgument(0, $config['failure_transport']);
2195.             $container->getDefinition('console.command.messenger_failed_messages_show')
2196.                 ->replaceArgument(0, $config['failure_transport']);
2197.             $container->getDefinition('console.command.messenger_failed_messages_remove')
2198.                 ->replaceArgument(0, $config['failure_transport']);
2200.             $failureTransportsByTransportNameServiceLocator = ServiceLocatorTagPass::register($container, $failureTransportReferencesByTransportName);
2201.             $container->getDefinition('messenger.failure.send_failed_message_to_failure_transport_listener')
2202.                 ->replaceArgument(0, $failureTransportsByTransportNameServiceLocator);
2203.         } else {
2204.             $container->removeDefinition('messenger.failure.send_failed_message_to_failure_transport_listener');
2205.             $container->removeDefinition('console.command.messenger_failed_messages_retry');
2206.             $container->removeDefinition('console.command.messenger_failed_messages_show');
2207.             $container->removeDefinition('console.command.messenger_failed_messages_remove');
2208.         }
2210.         if (!$container->hasDefinition('console.command.messenger_consume_messages')) {
2211.             $container->removeDefinition('messenger.listener.reset_services');
2212.         }
2213.     }
2215.     private function registerCacheConfiguration(array $config, ContainerBuilder $container)
2216.     {
2217.         if (!class_exists(DefaultMarshaller::class)) {
2218.             $container->removeDefinition('cache.default_marshaller');
2219.         }
2221.         $version = new Parameter('container.build_id');
2222.         $container->getDefinition('cache.adapter.apcu')->replaceArgument(2, $version);
2223.         $container->getDefinition('cache.adapter.system')->replaceArgument(2, $version);
2224.         $container->getDefinition('cache.adapter.filesystem')->replaceArgument(2, $config['directory']);
2226.         if (isset($config['prefix_seed'])) {
2227.             $container->setParameter('cache.prefix.seed', $config['prefix_seed']);
2228.         }
2229.         if ($container->hasParameter('cache.prefix.seed')) {
2230.             // Inline any env vars referenced in the parameter
2231.             $container->setParameter('cache.prefix.seed', $container->resolveEnvPlaceholders($container->getParameter('cache.prefix.seed'), true));
2232.         }
2233.         foreach (['psr6', 'redis', 'memcached', 'doctrine_dbal', 'pdo'] as $name) {
2234.             if (isset($config[$name = 'default_'.$name.'_provider'])) {
2235.                 $container->setAlias('cache.'.$name, new Alias(CachePoolPass::getServiceProvider($container, $config[$name]), false));
2236.             }
2237.         }
2238.         foreach (['app', 'system'] as $name) {
2239.             $config['pools']['cache.'.$name] = [
2240.                 'adapters' => [$config[$name]],
2241.                 'public' => true,
2242.                 'tags' => false,
2243.             ];
2244.         }
2245.         foreach ($config['pools'] as $name => $pool) {
2246.             $pool['adapters'] = $pool['adapters'] ?: ['cache.app'];
2248.             $isRedisTagAware = ['cache.adapter.redis_tag_aware'] === $pool['adapters'];
2249.             foreach ($pool['adapters'] as $provider => $adapter) {
2250.                 if (($config['pools'][$adapter]['adapters'] ?? null) === ['cache.adapter.redis_tag_aware']) {
2251.                     $isRedisTagAware = true;
2252.                 } elseif ($config['pools'][$adapter]['tags'] ?? false) {
2253.                     $pool['adapters'][$provider] = $adapter = '.'.$adapter.'.inner';
2254.                 }
2255.             }
2257.             if (1 === \count($pool['adapters'])) {
2258.                 if (!isset($pool['provider']) && !\is_int($provider)) {
2259.                     $pool['provider'] = $provider;
2260.                 }
2261.                 $definition = new ChildDefinition($adapter);
2262.             } else {
2263.                 $definition = new Definition(ChainAdapter::class, [$pool['adapters'], 0]);
2264.                 $pool['reset'] = 'reset';
2265.             }
2267.             if ($isRedisTagAware && 'cache.app' === $name) {
2268.                 $container->setAlias('cache.app.taggable', $name);
2269.                 $definition->addTag('cache.taggable', ['pool' => $name]);
2270.             } elseif ($isRedisTagAware) {
2271.                 $tagAwareId = $name;
2272.                 $container->setAlias('.'.$name.'.inner', $name);
2273.                 $definition->addTag('cache.taggable', ['pool' => $name]);
2274.             } elseif ($pool['tags']) {
2275.                 if (true !== $pool['tags'] && ($config['pools'][$pool['tags']]['tags'] ?? false)) {
2276.                     $pool['tags'] = '.'.$pool['tags'].'.inner';
2277.                 }
2278.                 $container->register($name, TagAwareAdapter::class)
2279.                     ->addArgument(new Reference('.'.$name.'.inner'))
2280.                     ->addArgument(true !== $pool['tags'] ? new Reference($pool['tags']) : null)
2281.                     ->setPublic($pool['public'])
2282.                     ->addTag('cache.taggable', ['pool' => $name])
2283.                 ;
2285.                 if (method_exists(TagAwareAdapter::class, 'setLogger')) {
2286.                     $container
2287.                         ->getDefinition($name)
2288.                         ->addMethodCall('setLogger', [new Reference('logger', ContainerInterface::IGNORE_ON_INVALID_REFERENCE)])
2289.                         ->addTag('monolog.logger', ['channel' => 'cache']);
2290.                 }
2292.                 $pool['name'] = $tagAwareId = $name;
2293.                 $pool['public'] = false;
2294.                 $name = '.'.$name.'.inner';
2295.             } elseif (!\in_array($name, ['cache.app', 'cache.system'], true)) {
2296.                 $tagAwareId = '.'.$name.'.taggable';
2297.                 $container->register($tagAwareId, TagAwareAdapter::class)
2298.                     ->addArgument(new Reference($name))
2299.                     ->addTag('cache.taggable', ['pool' => $name])
2300.                 ;
2301.             }
2303.             if (!\in_array($name, ['cache.app', 'cache.system'], true)) {
2304.                 $container->registerAliasForArgument($tagAwareId, TagAwareCacheInterface::class, $pool['name'] ?? $name);
2305.                 $container->registerAliasForArgument($name, CacheInterface::class, $pool['name'] ?? $name);
2306.                 $container->registerAliasForArgument($name, CacheItemPoolInterface::class, $pool['name'] ?? $name);
2307.             }
2309.             $definition->setPublic($pool['public']);
2310.             unset($pool['adapters'], $pool['public'], $pool['tags']);
2312.             $definition->addTag('cache.pool', $pool);
2313.             $container->setDefinition($name, $definition);
2314.         }
2316.         if (method_exists(PropertyAccessor::class, 'createCache')) {
2317.             $propertyAccessDefinition = $container->register('cache.property_access', AdapterInterface::class);
2318.             $propertyAccessDefinition->setPublic(false);
2320.             if (!$container->getParameter('kernel.debug')) {
2321.                 $propertyAccessDefinition->setFactory([PropertyAccessor::class, 'createCache']);
2322.                 $propertyAccessDefinition->setArguments(['', 0, $version, new Reference('logger', ContainerInterface::IGNORE_ON_INVALID_REFERENCE)]);
2323.                 $propertyAccessDefinition->addTag('cache.pool', ['clearer' => 'cache.system_clearer']);
2324.                 $propertyAccessDefinition->addTag('monolog.logger', ['channel' => 'cache']);
2325.             } else {
2326.                 $propertyAccessDefinition->setClass(ArrayAdapter::class);
2327.                 $propertyAccessDefinition->setArguments([0, false]);
2328.             }
2329.         }
2330.     }
2332.     private function registerHttpClientConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
2333.     {
2334.         $loader->load('http_client.php');
2336.         $options = $config['default_options'] ?? [];
2337.         $retryOptions = $options['retry_failed'] ?? ['enabled' => false];
2338.         unset($options['retry_failed']);
2339.         $container->getDefinition('http_client')->setArguments([$options, $config['max_host_connections'] ?? 6]);
2341.         if (!$hasPsr18 = ContainerBuilder::willBeAvailable('psr/http-client', ClientInterface::class, ['symfony/framework-bundle', 'symfony/http-client'])) {
2342.             $container->removeDefinition('psr18.http_client');
2343.             $container->removeAlias(ClientInterface::class);
2344.         }
2346.         if (!ContainerBuilder::willBeAvailable('php-http/httplug', HttpClient::class, ['symfony/framework-bundle', 'symfony/http-client'])) {
2347.             $container->removeDefinition(HttpClient::class);
2348.         }
2350.         if ($this->readConfigEnabled('http_client.retry_failed', $container, $retryOptions)) {
2351.             $this->registerRetryableHttpClient($retryOptions, 'http_client', $container);
2352.         }
2354.         $httpClientId = ($retryOptions['enabled'] ?? false) ? 'http_client.retryable.inner' : ($this->isInitializedConfigEnabled('profiler') ? '.debug.http_client.inner' : 'http_client');
2355.         foreach ($config['scoped_clients'] as $name => $scopeConfig) {
2356.             if ('http_client' === $name) {
2357.                 throw new InvalidArgumentException(sprintf('Invalid scope name: "%s" is reserved.', $name));
2358.             }
2360.             $scope = $scopeConfig['scope'] ?? null;
2361.             unset($scopeConfig['scope']);
2362.             $retryOptions = $scopeConfig['retry_failed'] ?? ['enabled' => false];
2363.             unset($scopeConfig['retry_failed']);
2365.             if (null === $scope) {
2366.                 $baseUri = $scopeConfig['base_uri'];
2367.                 unset($scopeConfig['base_uri']);
2369.                 $container->register($name, ScopingHttpClient::class)
2370.                     ->setFactory([ScopingHttpClient::class, 'forBaseUri'])
2371.                     ->setArguments([new Reference($httpClientId), $baseUri, $scopeConfig])
2372.                     ->addTag('http_client.client')
2373.                 ;
2374.             } else {
2375.                 $container->register($name, ScopingHttpClient::class)
2376.                     ->setArguments([new Reference($httpClientId), [$scope => $scopeConfig], $scope])
2377.                     ->addTag('http_client.client')
2378.                 ;
2379.             }
2381.             if ($this->readConfigEnabled('http_client.scoped_clients.'.$name.'retry_failed', $container, $retryOptions)) {
2382.                 $this->registerRetryableHttpClient($retryOptions, $name, $container);
2383.             }
2385.             $container->registerAliasForArgument($name, HttpClientInterface::class);
2387.             if ($hasPsr18) {
2388.                 $container->setDefinition('psr18.'.$name, new ChildDefinition('psr18.http_client'))
2389.                     ->replaceArgument(0, new Reference($name));
2391.                 $container->registerAliasForArgument('psr18.'.$name, ClientInterface::class, $name);
2392.             }
2393.         }
2395.         if ($responseFactoryId = $config['mock_response_factory'] ?? null) {
2396.             $container->register($httpClientId.'.mock_client', MockHttpClient::class)
2397.                 ->setDecoratedService($httpClientId, null, -10) // lower priority than TraceableHttpClient
2398.                 ->setArguments([new Reference($responseFactoryId)]);
2399.         }
2400.     }
2402.     private function registerRetryableHttpClient(array $options, string $name, ContainerBuilder $container)
2403.     {
2404.         if (!class_exists(RetryableHttpClient::class)) {
2405.             throw new LogicException('Support for retrying failed requests requires symfony/http-client 5.2 or higher, try upgrading.');
2406.         }
2408.         if (null !== $options['retry_strategy']) {
2409.             $retryStrategy = new Reference($options['retry_strategy']);
2410.         } else {
2411.             $retryStrategy = new ChildDefinition('http_client.abstract_retry_strategy');
2412.             $codes = [];
2413.             foreach ($options['http_codes'] as $code => $codeOptions) {
2414.                 if ($codeOptions['methods']) {
2415.                     $codes[$code] = $codeOptions['methods'];
2416.                 } else {
2417.                     $codes[] = $code;
2418.                 }
2419.             }
2421.             $retryStrategy
2422.                 ->replaceArgument(0, $codes ?: GenericRetryStrategy::DEFAULT_RETRY_STATUS_CODES)
2423.                 ->replaceArgument(1, $options['delay'])
2424.                 ->replaceArgument(2, $options['multiplier'])
2425.                 ->replaceArgument(3, $options['max_delay'])
2426.                 ->replaceArgument(4, $options['jitter']);
2427.             $container->setDefinition($name.'.retry_strategy', $retryStrategy);
2429.             $retryStrategy = new Reference($name.'.retry_strategy');
2430.         }
2432.         $container
2433.             ->register($name.'.retryable', RetryableHttpClient::class)
2434.             ->setDecoratedService($name, null, 10) // higher priority than TraceableHttpClient
2435.             ->setArguments([new Reference($name.'.retryable.inner'), $retryStrategy, $options['max_retries'], new Reference('logger')])
2436.             ->addTag('monolog.logger', ['channel' => 'http_client']);
2437.     }
2439.     private function registerMailerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
2440.     {
2441.         if (!class_exists(Mailer::class)) {
2442.             throw new LogicException('Mailer support cannot be enabled as the component is not installed. Try running "composer require symfony/mailer".');
2443.         }
2445.         $loader->load('mailer.php');
2446.         $loader->load('mailer_transports.php');
2447.         if (!\count($config['transports']) && null === $config['dsn']) {
2448.             $config['dsn'] = 'smtp://null';
2449.         }
2450.         $transports = $config['dsn'] ? ['main' => $config['dsn']] : $config['transports'];
2451.         $container->getDefinition('mailer.transports')->setArgument(0, $transports);
2452.         $container->getDefinition('mailer.default_transport')->setArgument(0, current($transports));
2454.         $mailer = $container->getDefinition('mailer.mailer');
2455.         if (false === $messageBus = $config['message_bus']) {
2456.             $mailer->replaceArgument(1, null);
2457.         } else {
2458.             $mailer->replaceArgument(1, $messageBus ? new Reference($messageBus) : new Reference('messenger.default_bus', ContainerInterface::NULL_ON_INVALID_REFERENCE));
2459.         }
2461.         $classToServices = [
2462.             GmailTransportFactory::class => 'mailer.transport_factory.gmail',
2463.             InfobipMailerTransportFactory::class => 'mailer.transport_factory.infobip',
2464.             MailgunTransportFactory::class => 'mailer.transport_factory.mailgun',
2465.             MailjetTransportFactory::class => 'mailer.transport_factory.mailjet',
2466.             MailPaceTransportFactory::class => 'mailer.transport_factory.mailpace',
2467.             MandrillTransportFactory::class => 'mailer.transport_factory.mailchimp',
2468.             OhMySmtpTransportFactory::class => 'mailer.transport_factory.ohmysmtp',
2469.             PostmarkTransportFactory::class => 'mailer.transport_factory.postmark',
2470.             SendgridTransportFactory::class => 'mailer.transport_factory.sendgrid',
2471.             SendinblueTransportFactory::class => 'mailer.transport_factory.sendinblue',
2472.             SesTransportFactory::class => 'mailer.transport_factory.amazon',
2473.         ];
2475.         foreach ($classToServices as $class => $service) {
2476.             $package = substr($service, \strlen('mailer.transport_factory.'));
2478.             if (!ContainerBuilder::willBeAvailable(sprintf('symfony/%s-mailer', 'gmail' === $package ? 'google' : $package), $class, ['symfony/framework-bundle', 'symfony/mailer'])) {
2479.                 $container->removeDefinition($service);
2480.             }
2481.         }
2483.         $envelopeListener = $container->getDefinition('mailer.envelope_listener');
2484.         $envelopeListener->setArgument(0, $config['envelope']['sender'] ?? null);
2485.         $envelopeListener->setArgument(1, $config['envelope']['recipients'] ?? null);
2487.         if ($config['headers']) {
2488.             $headers = new Definition(Headers::class);
2489.             foreach ($config['headers'] as $name => $data) {
2490.                 $value = $data['value'];
2491.                 if (\in_array(strtolower($name), ['from', 'to', 'cc', 'bcc', 'reply-to'])) {
2492.                     $value = (array) $value;
2493.                 }
2494.                 $headers->addMethodCall('addHeader', [$name, $value]);
2495.             }
2496.             $messageListener = $container->getDefinition('mailer.message_listener');
2497.             $messageListener->setArgument(0, $headers);
2498.         } else {
2499.             $container->removeDefinition('mailer.message_listener');
2500.         }
2502.         if (!class_exists(MessengerTransportListener::class)) {
2503.             $container->removeDefinition('mailer.messenger_transport_listener');
2504.         }
2505.     }
2507.     private function registerNotifierConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
2508.     {
2509.         if (!class_exists(Notifier::class)) {
2510.             throw new LogicException('Notifier support cannot be enabled as the component is not installed. Try running "composer require symfony/notifier".');
2511.         }
2513.         $loader->load('notifier.php');
2514.         $loader->load('notifier_transports.php');
2516.         if ($config['chatter_transports']) {
2517.             $container->getDefinition('chatter.transports')->setArgument(0, $config['chatter_transports']);
2518.         } else {
2519.             $container->removeDefinition('chatter');
2520.             $container->removeAlias(ChatterInterface::class);
2521.         }
2522.         if ($config['texter_transports']) {
2523.             $container->getDefinition('texter.transports')->setArgument(0, $config['texter_transports']);
2524.         } else {
2525.             $container->removeDefinition('texter');
2526.             $container->removeAlias(TexterInterface::class);
2527.         }
2529.         if ($this->isInitializedConfigEnabled('mailer')) {
2530.             $sender = $container->getDefinition('mailer.envelope_listener')->getArgument(0);
2531.             $container->getDefinition('notifier.channel.email')->setArgument(2, $sender);
2532.         } else {
2533.             $container->removeDefinition('notifier.channel.email');
2534.         }
2536.         if ($this->isInitializedConfigEnabled('messenger')) {
2537.             if ($config['notification_on_failed_messages']) {
2538.                 $container->getDefinition('notifier.failed_message_listener')->addTag('kernel.event_subscriber');
2539.             }
2541.             // as we have a bus, the channels don't need the transports
2542.             $container->getDefinition('notifier.channel.chat')->setArgument(0, null);
2543.             if ($container->hasDefinition('notifier.channel.email')) {
2544.                 $container->getDefinition('notifier.channel.email')->setArgument(0, null);
2545.             }
2546.             $container->getDefinition('notifier.channel.sms')->setArgument(0, null);
2547.             $container->getDefinition('notifier.channel.push')->setArgument(0, null);
2548.         }
2550.         $container->getDefinition('notifier.channel_policy')->setArgument(0, $config['channel_policy']);
2552.         $container->registerForAutoconfiguration(NotifierTransportFactoryInterface::class)
2553.             ->addTag('chatter.transport_factory');
2555.         $container->registerForAutoconfiguration(NotifierTransportFactoryInterface::class)
2556.             ->addTag('texter.transport_factory');
2558.         $classToServices = [
2559.             AllMySmsTransportFactory::class => 'notifier.transport_factory.all-my-sms',
2560.             AmazonSnsTransportFactory::class => 'notifier.transport_factory.amazon-sns',
2561.             ChatworkTransportFactory::class => 'notifier.transport_factory.chatwork',
2562.             ClickatellTransportFactory::class => 'notifier.transport_factory.clickatell',
2563.             ContactEveryoneTransportFactory::class => 'notifier.transport_factory.contact-everyone',
2564.             DiscordTransportFactory::class => 'notifier.transport_factory.discord',
2565.             EngagespotTransportFactory::class => 'notifier.transport_factory.engagespot',
2566.             EsendexTransportFactory::class => 'notifier.transport_factory.esendex',
2567.             ExpoTransportFactory::class => 'notifier.transport_factory.expo',
2568.             FakeChatTransportFactory::class => 'notifier.transport_factory.fake-chat',
2569.             FakeSmsTransportFactory::class => 'notifier.transport_factory.fake-sms',
2570.             FirebaseTransportFactory::class => 'notifier.transport_factory.firebase',
2571.             FortySixElksTransportFactory::class => 'notifier.transport_factory.forty-six-elks',
2572.             FreeMobileTransportFactory::class => 'notifier.transport_factory.free-mobile',
2573.             GatewayApiTransportFactory::class => 'notifier.transport_factory.gateway-api',
2574.             GitterTransportFactory::class => 'notifier.transport_factory.gitter',
2575.             GoogleChatTransportFactory::class => 'notifier.transport_factory.google-chat',
2576.             InfobipTransportFactory::class => 'notifier.transport_factory.infobip',
2577.             IqsmsTransportFactory::class => 'notifier.transport_factory.iqsms',
2578.             KazInfoTehTransportFactory::class => 'notifier.transport_factory.kaz-info-teh',
2579.             LightSmsTransportFactory::class => 'notifier.transport_factory.light-sms',
2580.             LinkedInTransportFactory::class => 'notifier.transport_factory.linked-in',
2581.             MailjetNotifierTransportFactory::class => 'notifier.transport_factory.mailjet',
2582.             MattermostTransportFactory::class => 'notifier.transport_factory.mattermost',
2583.             MercureTransportFactory::class => 'notifier.transport_factory.mercure',
2584.             MessageBirdTransport::class => 'notifier.transport_factory.message-bird',
2585.             MessageMediaTransportFactory::class => 'notifier.transport_factory.message-media',
2586.             MicrosoftTeamsTransportFactory::class => 'notifier.transport_factory.microsoft-teams',
2587.             MobytTransportFactory::class => 'notifier.transport_factory.mobyt',
2588.             OctopushTransportFactory::class => 'notifier.transport_factory.octopush',
2589.             OneSignalTransportFactory::class => 'notifier.transport_factory.one-signal',
2590.             OrangeSmsTransportFactory::class => 'notifier.transport_factory.orange-sms',
2591.             OvhCloudTransportFactory::class => 'notifier.transport_factory.ovh-cloud',
2592.             RocketChatTransportFactory::class => 'notifier.transport_factory.rocket-chat',
2593.             SendberryTransportFactory::class => 'notifier.transport_factory.sendberry',
2594.             SendinblueNotifierTransportFactory::class => 'notifier.transport_factory.sendinblue',
2595.             SinchTransportFactory::class => 'notifier.transport_factory.sinch',
2596.             SlackTransportFactory::class => 'notifier.transport_factory.slack',
2597.             Sms77TransportFactory::class => 'notifier.transport_factory.sms77',
2598.             SmsapiTransportFactory::class => 'notifier.transport_factory.smsapi',
2599.             SmsBiurasTransportFactory::class => 'notifier.transport_factory.sms-biuras',
2600.             SmscTransportFactory::class => 'notifier.transport_factory.smsc',
2601.             SmsFactorTransportFactory::class => 'notifier.transport_factory.sms-factor',
2602.             SpotHitTransportFactory::class => 'notifier.transport_factory.spot-hit',
2603.             TelegramTransportFactory::class => 'notifier.transport_factory.telegram',
2604.             TelnyxTransportFactory::class => 'notifier.transport_factory.telnyx',
2605.             TurboSmsTransport::class => 'notifier.transport_factory.turbo-sms',
2606.             TwilioTransportFactory::class => 'notifier.transport_factory.twilio',
2607.             VonageTransportFactory::class => 'notifier.transport_factory.vonage',
2608.             YunpianTransportFactory::class => 'notifier.transport_factory.yunpian',
2609.             ZendeskTransportFactory::class => 'notifier.transport_factory.zendesk',
2610.             ZulipTransportFactory::class => 'notifier.transport_factory.zulip',
2611.         ];
2613.         $parentPackages = ['symfony/framework-bundle', 'symfony/notifier'];
2615.         foreach ($classToServices as $class => $service) {
2616.             $package = substr($service, \strlen('notifier.transport_factory.'));
2618.             if (!ContainerBuilder::willBeAvailable(sprintf('symfony/%s-notifier', $package), $class, $parentPackages)) {
2619.                 $container->removeDefinition($service);
2620.             }
2621.         }
2623.         if (ContainerBuilder::willBeAvailable('symfony/mercure-notifier', MercureTransportFactory::class, $parentPackages) && ContainerBuilder::willBeAvailable('symfony/mercure-bundle', MercureBundle::class, $parentPackages) && \in_array(MercureBundle::class, $container->getParameter('kernel.bundles'), true)) {
2624.             $container->getDefinition($classToServices[MercureTransportFactory::class])
2625.                 ->replaceArgument('$registry', new Reference(HubRegistry::class));
2626.         } elseif (ContainerBuilder::willBeAvailable('symfony/mercure-notifier', MercureTransportFactory::class, $parentPackages)) {
2627.             $container->removeDefinition($classToServices[MercureTransportFactory::class]);
2628.         }
2630.         if (ContainerBuilder::willBeAvailable('symfony/fake-chat-notifier', FakeChatTransportFactory::class, ['symfony/framework-bundle', 'symfony/notifier', 'symfony/mailer'])) {
2631.             $container->getDefinition($classToServices[FakeChatTransportFactory::class])
2632.                 ->replaceArgument('$mailer', new Reference('mailer'))
2633.                 ->replaceArgument('$logger', new Reference('logger'));
2634.         }
2636.         if (ContainerBuilder::willBeAvailable('symfony/fake-sms-notifier', FakeSmsTransportFactory::class, ['symfony/framework-bundle', 'symfony/notifier', 'symfony/mailer'])) {
2637.             $container->getDefinition($classToServices[FakeSmsTransportFactory::class])
2638.                 ->replaceArgument('$mailer', new Reference('mailer'))
2639.                 ->replaceArgument('$logger', new Reference('logger'));
2640.         }
2642.         if (isset($config['admin_recipients'])) {
2643.             $notifier = $container->getDefinition('notifier');
2644.             foreach ($config['admin_recipients'] as $i => $recipient) {
2645.                 $id = 'notifier.admin_recipient.'.$i;
2646.                 $container->setDefinition($id, new Definition(Recipient::class, [$recipient['email'], $recipient['phone']]));
2647.                 $notifier->addMethodCall('addAdminRecipient', [new Reference($id)]);
2648.             }
2649.         }
2650.     }
2652.     private function registerRateLimiterConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
2653.     {
2654.         $loader->load('rate_limiter.php');
2656.         foreach ($config['limiters'] as $name => $limiterConfig) {
2657.             // default configuration (when used by other DI extensions)
2658.             $limiterConfig += ['lock_factory' => 'lock.factory', 'cache_pool' => 'cache.rate_limiter'];
2660.             $limiter = $container->setDefinition($limiterId = 'limiter.'.$name, new ChildDefinition('limiter'));
2662.             if (null !== $limiterConfig['lock_factory']) {
2663.                 if (!interface_exists(LockInterface::class)) {
2664.                     throw new LogicException(sprintf('Rate limiter "%s" requires the Lock component to be installed. Try running "composer require symfony/lock".', $name));
2665.                 }
2667.                 if (!$this->isInitializedConfigEnabled('lock')) {
2668.                     throw new LogicException(sprintf('Rate limiter "%s" requires the Lock component to be configured.', $name));
2669.                 }
2671.                 $limiter->replaceArgument(2, new Reference($limiterConfig['lock_factory']));
2672.             }
2673.             unset($limiterConfig['lock_factory']);
2675.             if (null === $storageId = $limiterConfig['storage_service'] ?? null) {
2676.                 $container->register($storageId = 'limiter.storage.'.$name, CacheStorage::class)->addArgument(new Reference($limiterConfig['cache_pool']));
2677.             }
2679.             $limiter->replaceArgument(1, new Reference($storageId));
2680.             unset($limiterConfig['storage_service'], $limiterConfig['cache_pool']);
2682.             $limiterConfig['id'] = $name;
2683.             $limiter->replaceArgument(0, $limiterConfig);
2685.             $container->registerAliasForArgument($limiterId, RateLimiterFactory::class, $name.'.limiter');
2686.         }
2687.     }
2689.     /**
2690.      * @deprecated since Symfony 6.2
2691.      */
2692.     public static function registerRateLimiter(ContainerBuilder $container, string $name, array $limiterConfig)
2693.     {
2694.         trigger_deprecation('symfony/framework-bundle', '6.2', 'The "%s()" method is deprecated.', __METHOD__);
2696.         // default configuration (when used by other DI extensions)
2697.         $limiterConfig += ['lock_factory' => 'lock.factory', 'cache_pool' => 'cache.rate_limiter'];
2699.         $limiter = $container->setDefinition($limiterId = 'limiter.'.$name, new ChildDefinition('limiter'));
2701.         if (null !== $limiterConfig['lock_factory']) {
2702.             if (!interface_exists(LockInterface::class)) {
2703.                 throw new LogicException(sprintf('Rate limiter "%s" requires the Lock component to be installed. Try running "composer require symfony/lock".', $name));
2704.             }
2705.             if (!$container->hasDefinition('lock.factory.abstract')) {
2706.                 throw new LogicException(sprintf('Rate limiter "%s" requires the Lock component to be configured.', $name));
2707.             }
2709.             $limiter->replaceArgument(2, new Reference($limiterConfig['lock_factory']));
2710.         }
2711.         unset($limiterConfig['lock_factory']);
2713.         if (null === $storageId = $limiterConfig['storage_service'] ?? null) {
2714.             $container->register($storageId = 'limiter.storage.'.$name, CacheStorage::class)->addArgument(new Reference($limiterConfig['cache_pool']));
2715.         }
2717.         $limiter->replaceArgument(1, new Reference($storageId));
2718.         unset($limiterConfig['storage_service'], $limiterConfig['cache_pool']);
2720.         $limiterConfig['id'] = $name;
2721.         $limiter->replaceArgument(0, $limiterConfig);
2723.         $container->registerAliasForArgument($limiterId, RateLimiterFactory::class, $name.'.limiter');
2724.     }
2726.     private function registerUidConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
2727.     {
2728.         $loader->load('uid.php');
2730.         $container->getDefinition('uuid.factory')
2731.             ->setArguments([
2732.                 $config['default_uuid_version'],
2733.                 $config['time_based_uuid_version'],
2734.                 $config['name_based_uuid_version'],
2735.                 UuidV4::class,
2736.                 $config['time_based_uuid_node'] ?? null,
2737.                 $config['name_based_uuid_namespace'] ?? null,
2738.             ])
2739.         ;
2741.         if (isset($config['name_based_uuid_namespace'])) {
2742.             $container->getDefinition('name_based_uuid.factory')
2743.                 ->setArguments([$config['name_based_uuid_namespace']]);
2744.         }
2746.         if (!class_exists(UidValueResolver::class)) {
2747.             $container->removeDefinition('argument_resolver.uid');
2748.         }
2749.     }
2751.     private function registerHtmlSanitizerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader)
2752.     {
2753.         $loader->load('html_sanitizer.php');
2755.         foreach ($config['sanitizers'] as $sanitizerName => $sanitizerConfig) {
2756.             $configId = 'html_sanitizer.config.'.$sanitizerName;
2757.             $def = $container->register($configId, HtmlSanitizerConfig::class);
2759.             // Base
2760.             if ($sanitizerConfig['allow_safe_elements']) {
2761.                 $def->addMethodCall('allowSafeElements', [], true);
2762.             }
2764.             if ($sanitizerConfig['allow_static_elements']) {
2765.                 $def->addMethodCall('allowStaticElements', [], true);
2766.             }
2768.             // Configures elements
2769.             foreach ($sanitizerConfig['allow_elements'] as $element => $attributes) {
2770.                 $def->addMethodCall('allowElement', [$element, $attributes], true);
2771.             }
2773.             foreach ($sanitizerConfig['block_elements'] as $element) {
2774.                 $def->addMethodCall('blockElement', [$element], true);
2775.             }
2777.             foreach ($sanitizerConfig['drop_elements'] as $element) {
2778.                 $def->addMethodCall('dropElement', [$element], true);
2779.             }
2781.             // Configures attributes
2782.             foreach ($sanitizerConfig['allow_attributes'] as $attribute => $elements) {
2783.                 $def->addMethodCall('allowAttribute', [$attribute, $elements], true);
2784.             }
2786.             foreach ($sanitizerConfig['drop_attributes'] as $attribute => $elements) {
2787.                 $def->addMethodCall('dropAttribute', [$attribute, $elements], true);
2788.             }
2790.             // Force attributes
2791.             foreach ($sanitizerConfig['force_attributes'] as $element => $attributes) {
2792.                 foreach ($attributes as $attrName => $attrValue) {
2793.                     $def->addMethodCall('forceAttribute', [$element, $attrName, $attrValue], true);
2794.                 }
2795.             }
2797.             // Settings
2798.             $def->addMethodCall('forceHttpsUrls', [$sanitizerConfig['force_https_urls']], true);
2799.             if ($sanitizerConfig['allowed_link_schemes']) {
2800.                 $def->addMethodCall('allowLinkSchemes', [$sanitizerConfig['allowed_link_schemes']], true);
2801.             }
2802.             $def->addMethodCall('allowLinkHosts', [$sanitizerConfig['allowed_link_hosts']], true);
2803.             $def->addMethodCall('allowRelativeLinks', [$sanitizerConfig['allow_relative_links']], true);
2804.             if ($sanitizerConfig['allowed_media_schemes']) {
2805.                 $def->addMethodCall('allowMediaSchemes', [$sanitizerConfig['allowed_media_schemes']], true);
2806.             }
2807.             $def->addMethodCall('allowMediaHosts', [$sanitizerConfig['allowed_media_hosts']], true);
2808.             $def->addMethodCall('allowRelativeMedias', [$sanitizerConfig['allow_relative_medias']], true);
2810.             // Custom attribute sanitizers
2811.             foreach ($sanitizerConfig['with_attribute_sanitizers'] as $serviceName) {
2812.                 $def->addMethodCall('withAttributeSanitizer', [new Reference($serviceName)], true);
2813.             }
2815.             foreach ($sanitizerConfig['without_attribute_sanitizers'] as $serviceName) {
2816.                 $def->addMethodCall('withoutAttributeSanitizer', [new Reference($serviceName)], true);
2817.             }
2819.             if ($sanitizerConfig['max_input_length']) {
2820.                 $def->addMethodCall('withMaxInputLength', [$sanitizerConfig['max_input_length']], true);
2821.             }
2823.             // Create the sanitizer and link its config
2824.             $sanitizerId = 'html_sanitizer.sanitizer.'.$sanitizerName;
2825.             $container->register($sanitizerId, HtmlSanitizer::class)
2826.                 ->addTag('html_sanitizer', ['sanitizer' => $sanitizerName])
2827.                 ->addArgument(new Reference($configId));
2829.             if ('default' !== $sanitizerName) {
2830.                 $container->registerAliasForArgument($sanitizerId, HtmlSanitizerInterface::class, $sanitizerName);
2831.             }
2832.         }
2833.     }
2835.     private function resolveTrustedHeaders(array $headers): int
2836.     {
2837.         $trustedHeaders = 0;
2839.         foreach ($headers as $h) {
2840.             $trustedHeaders |= match ($h) {
2841.                 'forwarded' => Request::HEADER_FORWARDED,
2842.                 'x-forwarded-for' => Request::HEADER_X_FORWARDED_FOR,
2843.                 'x-forwarded-host' => Request::HEADER_X_FORWARDED_HOST,
2844.                 'x-forwarded-proto' => Request::HEADER_X_FORWARDED_PROTO,
2845.                 'x-forwarded-port' => Request::HEADER_X_FORWARDED_PORT,
2846.                 'x-forwarded-prefix' => Request::HEADER_X_FORWARDED_PREFIX,
2847.                 default => 0,
2848.             };
2849.         }
2851.         return $trustedHeaders;
2852.     }
2854.     public function getXsdValidationBasePath(): string|false
2855.     {
2856.         return \dirname(__DIR__).'/Resources/config/schema';
2857.     }
2859.     public function getNamespace(): string
2860.     {
2861.         return 'http://symfony.com/schema/dic/symfony';
2862.     }
2864.     protected function isConfigEnabled(ContainerBuilder $container, array $config): bool
2865.     {
2866.         throw new \LogicException('To prevent using outdated configuration, you must use the "readConfigEnabled" method instead.');
2867.     }
2869.     private function isInitializedConfigEnabled(string $path): bool
2870.     {
2871.         if (isset($this->configsEnabled[$path])) {
2872.             return $this->configsEnabled[$path];
2873.         }
2875.         throw new LogicException(sprintf('Can not read config enabled at "%s" because it has not been initialized.', $path));
2876.     }
2878.     private function readConfigEnabled(string $path, ContainerBuilder $container, array $config): bool
2879.     {
2880.         return $this->configsEnabled[$path] ??= parent::isConfigEnabled($container, $config);
2881.     }
2883.     private function writeConfigEnabled(string $path, bool $value, array &$config): void
2884.     {
2885.         if (isset($this->configsEnabled[$path])) {
2886.             throw new LogicException('Can not change config enabled because it has already been read.');
2887.         }
2889.         $this->configsEnabled[$path] = $value;
2890.         $config['enabled'] = $value;
2891.     }
2892. }