vendor/symfony/messenger/DependencyInjection/MessengerPass.php line 133

Open in your IDE?
  1. <?php
  3. /*
  4. * This file is part of the Symfony package.
  5. *
  6. * (c) Fabien Potencier <fabien@symfony.com>
  7. *
  8. * For the full copyright and license information, please view the LICENSE
  9. * file that was distributed with this source code.
  10. */
  12. namespace Symfony\Component\Messenger\DependencyInjection;
  14. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  15. use Symfony\Component\DependencyInjection\ChildDefinition;
  16. use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
  17. use Symfony\Component\DependencyInjection\Compiler\ServiceLocatorTagPass;
  18. use Symfony\Component\DependencyInjection\ContainerBuilder;
  19. use Symfony\Component\DependencyInjection\Definition;
  20. use Symfony\Component\DependencyInjection\Exception\OutOfBoundsException;
  21. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  22. use Symfony\Component\DependencyInjection\Reference;
  23. use Symfony\Component\Messenger\Handler\HandlerDescriptor;
  24. use Symfony\Component\Messenger\Handler\HandlersLocator;
  25. use Symfony\Component\Messenger\Handler\MessageSubscriberInterface;
  26. use Symfony\Component\Messenger\TraceableMessageBus;
  27. use Symfony\Component\Messenger\Transport\Receiver\ReceiverInterface;
  29. /**
  30. * @author Samuel Roze <samuel.roze@gmail.com>
  31. */
  32. class MessengerPass implements CompilerPassInterface
  33. {
  34. private $handlerTag;
  35. private $busTag;
  36. private $receiverTag;
  38. public function __construct(string $handlerTag = 'messenger.message_handler', string $busTag = 'messenger.bus', string $receiverTag = 'messenger.receiver')
  39. {
  40. if (0 < \func_num_args()) {
  41. trigger_deprecation('symfony/messenger', '5.3', 'Configuring "%s" is deprecated.', __CLASS__);
  42. }
  44. $this->handlerTag = $handlerTag;
  45. $this->busTag = $busTag;
  46. $this->receiverTag = $receiverTag;
  47. }
  49. /**
  50. * {@inheritdoc}
  51. */
  52. public function process(ContainerBuilder $container)
  53. {
  54. $busIds = [];
  55. foreach ($container->findTaggedServiceIds($this->busTag) as $busId => $tags) {
  56. $busIds[] = $busId;
  57. if ($container->hasParameter($busMiddlewareParameter = $busId.'.middleware')) {
  58. $this->registerBusMiddleware($container, $busId, $container->getParameter($busMiddlewareParameter));
  60. $container->getParameterBag()->remove($busMiddlewareParameter);
  61. }
  63. if ($container->hasDefinition('data_collector.messenger')) {
  64. $this->registerBusToCollector($container, $busId);
  65. }
  66. }
  68. if ($container->hasDefinition('messenger.receiver_locator')) {
  69. $this->registerReceivers($container, $busIds);
  70. }
  71. $this->registerHandlers($container, $busIds);
  72. }
  74. private function registerHandlers(ContainerBuilder $container, array $busIds)
  75. {
  76. $definitions = [];
  77. $handlersByBusAndMessage = [];
  78. $handlerToOriginalServiceIdMapping = [];
  80. foreach ($container->findTaggedServiceIds($this->handlerTag, true) as $serviceId => $tags) {
  81. foreach ($tags as $tag) {
  82. if (isset($tag['bus']) && !\in_array($tag['bus'], $busIds, true)) {
  83. throw new RuntimeException(sprintf('Invalid handler service "%s": bus "%s" specified on the tag "%s" does not exist (known ones are: "%s").', $serviceId, $tag['bus'], $this->handlerTag, implode('", "', $busIds)));
  84. }
  86. $className = $this->getServiceClass($container, $serviceId);
  87. $r = $container->getReflectionClass($className);
  89. if (null === $r) {
  90. throw new RuntimeException(sprintf('Invalid service "%s": class "%s" does not exist.', $serviceId, $className));
  91. }
  93. if (isset($tag['handles'])) {
  94. $handles = isset($tag['method']) ? [$tag['handles'] => $tag['method']] : [$tag['handles']];
  95. } else {
  96. $handles = $this->guessHandledClasses($r, $serviceId);
  97. }
  99. $message = null;
  100. $handlerBuses = (array) ($tag['bus'] ?? $busIds);
  102. foreach ($handles as $message => $options) {
  103. $buses = $handlerBuses;
  105. if (\is_int($message)) {
  106. if (\is_string($options)) {
  107. $message = $options;
  108. $options = [];
  109. } else {
  110. throw new RuntimeException(sprintf('The handler configuration needs to return an array of messages or an associated array of message and configuration. Found value of type "%s" at position "%d" for service "%s".', get_debug_type($options), $message, $serviceId));
  111. }
  112. }
  114. if (\is_string($options)) {
  115. $options = ['method' => $options];
  116. }
  118. $options += array_filter($tag);
  119. unset($options['handles']);
  120. $priority = $options['priority'] ?? 0;
  121. $method = $options['method'] ?? '__invoke';
  123. if (isset($options['bus'])) {
  124. if (!\in_array($options['bus'], $busIds)) {
  125. $messageLocation = isset($tag['handles']) ? 'declared in your tag attribute "handles"' : ($r->implementsInterface(MessageSubscriberInterface::class) ? sprintf('returned by method "%s::getHandledMessages()"', $r->getName()) : sprintf('used as argument type in method "%s::%s()"', $r->getName(), $method));
  127. throw new RuntimeException(sprintf('Invalid configuration '.$messageLocation.' for message "%s": bus "%s" does not exist.', $message, $options['bus']));
  128. }
  130. $buses = [$options['bus']];
  131. }
  133. if ('*' !== $message && !class_exists($message) && !interface_exists($message, false)) {
  134. $messageLocation = isset($tag['handles']) ? 'declared in your tag attribute "handles"' : ($r->implementsInterface(MessageSubscriberInterface::class) ? sprintf('returned by method "%s::getHandledMessages()"', $r->getName()) : sprintf('used as argument type in method "%s::%s()"', $r->getName(), $method));
  136. throw new RuntimeException(sprintf('Invalid handler service "%s": class or interface "%s" '.$messageLocation.' not found.', $serviceId, $message));
  137. }
  139. if (!$r->hasMethod($method)) {
  140. throw new RuntimeException(sprintf('Invalid handler service "%s": method "%s::%s()" does not exist.', $serviceId, $r->getName(), $method));
  141. }
  143. if ('__invoke' !== $method) {
  144. $wrapperDefinition = (new Definition('Closure'))->addArgument([new Reference($serviceId), $method])->setFactory('Closure::fromCallable');
  146. $definitions[$definitionId = '.messenger.method_on_object_wrapper.'.ContainerBuilder::hash($message.':'.$priority.':'.$serviceId.':'.$method)] = $wrapperDefinition;
  147. } else {
  148. $definitionId = $serviceId;
  149. }
  151. $handlerToOriginalServiceIdMapping[$definitionId] = $serviceId;
  153. foreach ($buses as $handlerBus) {
  154. $handlersByBusAndMessage[$handlerBus][$message][$priority][] = [$definitionId, $options];
  155. }
  156. }
  158. if (null === $message) {
  159. throw new RuntimeException(sprintf('Invalid handler service "%s": method "%s::getHandledMessages()" must return one or more messages.', $serviceId, $r->getName()));
  160. }
  161. }
  162. }
  164. foreach ($handlersByBusAndMessage as $bus => $handlersByMessage) {
  165. foreach ($handlersByMessage as $message => $handlersByPriority) {
  166. krsort($handlersByPriority);
  167. $handlersByBusAndMessage[$bus][$message] = array_merge(...$handlersByPriority);
  168. }
  169. }
  171. $handlersLocatorMappingByBus = [];
  172. foreach ($handlersByBusAndMessage as $bus => $handlersByMessage) {
  173. foreach ($handlersByMessage as $message => $handlers) {
  174. $handlerDescriptors = [];
  175. foreach ($handlers as $handler) {
  176. $definitions[$definitionId = '.messenger.handler_descriptor.'.ContainerBuilder::hash($bus.':'.$message.':'.$handler[0])] = (new Definition(HandlerDescriptor::class))->setArguments([new Reference($handler[0]), $handler[1]]);
  177. $handlerDescriptors[] = new Reference($definitionId);
  178. }
  180. $handlersLocatorMappingByBus[$bus][$message] = new IteratorArgument($handlerDescriptors);
  181. }
  182. }
  183. $container->addDefinitions($definitions);
  185. foreach ($busIds as $bus) {
  186. $container->register($locatorId = $bus.'.messenger.handlers_locator', HandlersLocator::class)
  187. ->setArgument(0, $handlersLocatorMappingByBus[$bus] ?? [])
  188. ;
  189. if ($container->has($handleMessageId = $bus.'.middleware.handle_message')) {
  190. $container->getDefinition($handleMessageId)
  191. ->replaceArgument(0, new Reference($locatorId))
  192. ;
  193. }
  194. }
  196. if ($container->hasDefinition('console.command.messenger_debug')) {
  197. $debugCommandMapping = $handlersByBusAndMessage;
  198. foreach ($busIds as $bus) {
  199. if (!isset($debugCommandMapping[$bus])) {
  200. $debugCommandMapping[$bus] = [];
  201. }
  203. foreach ($debugCommandMapping[$bus] as $message => $handlers) {
  204. foreach ($handlers as $key => $handler) {
  205. $debugCommandMapping[$bus][$message][$key][0] = $handlerToOriginalServiceIdMapping[$handler[0]];
  206. }
  207. }
  208. }
  209. $container->getDefinition('console.command.messenger_debug')->replaceArgument(0, $debugCommandMapping);
  210. }
  211. }
  213. private function guessHandledClasses(\ReflectionClass $handlerClass, string $serviceId): iterable
  214. {
  215. if ($handlerClass->implementsInterface(MessageSubscriberInterface::class)) {
  216. return $handlerClass->getName()::getHandledMessages();
  217. }
  219. try {
  220. $method = $handlerClass->getMethod('__invoke');
  221. } catch (\ReflectionException $e) {
  222. throw new RuntimeException(sprintf('Invalid handler service "%s": class "%s" must have an "__invoke()" method.', $serviceId, $handlerClass->getName()));
  223. }
  225. if (0 === $method->getNumberOfRequiredParameters()) {
  226. throw new RuntimeException(sprintf('Invalid handler service "%s": method "%s::__invoke()" requires at least one argument, first one being the message it handles.', $serviceId, $handlerClass->getName()));
  227. }
  229. $parameters = $method->getParameters();
  230. if (!$type = $parameters[0]->getType()) {
  231. throw new RuntimeException(sprintf('Invalid handler service "%s": argument "$%s" of method "%s::__invoke()" must have a type-hint corresponding to the message class it handles.', $serviceId, $parameters[0]->getName(), $handlerClass->getName()));
  232. }
  234. if ($type instanceof \ReflectionUnionType) {
  235. $types = [];
  236. $invalidTypes = [];
  237. foreach ($type->getTypes() as $type) {
  238. if (!$type->isBuiltin()) {
  239. $types[] = (string) $type;
  240. } else {
  241. $invalidTypes[] = (string) $type;
  242. }
  243. }
  245. if ($types) {
  246. return $types;
  247. }
  249. throw new RuntimeException(sprintf('Invalid handler service "%s": type-hint of argument "$%s" in method "%s::__invoke()" must be a class , "%s" given.', $serviceId, $parameters[0]->getName(), $handlerClass->getName(), implode('|', $invalidTypes)));
  250. }
  252. if ($type->isBuiltin()) {
  253. throw new RuntimeException(sprintf('Invalid handler service "%s": type-hint of argument "$%s" in method "%s::__invoke()" must be a class , "%s" given.', $serviceId, $parameters[0]->getName(), $handlerClass->getName(), $type instanceof \ReflectionNamedType ? $type->getName() : (string) $type));
  254. }
  256. return [$type->getName()];
  257. }
  259. private function registerReceivers(ContainerBuilder $container, array $busIds)
  260. {
  261. $receiverMapping = [];
  262. $failureTransportsMap = [];
  263. if ($container->hasDefinition('console.command.messenger_failed_messages_retry')) {
  264. $commandDefinition = $container->getDefinition('console.command.messenger_failed_messages_retry');
  265. $globalReceiverName = $commandDefinition->getArgument(0);
  266. if (null !== $globalReceiverName) {
  267. if ($container->hasAlias('messenger.failure_transports.default')) {
  268. $failureTransportsMap[$globalReceiverName] = new Reference('messenger.failure_transports.default');
  269. } else {
  270. $failureTransportsMap[$globalReceiverName] = new Reference('messenger.transport.'.$globalReceiverName);
  271. }
  272. }
  273. }
  275. foreach ($container->findTaggedServiceIds($this->receiverTag) as $id => $tags) {
  276. $receiverClass = $this->getServiceClass($container, $id);
  277. if (!is_subclass_of($receiverClass, ReceiverInterface::class)) {
  278. throw new RuntimeException(sprintf('Invalid receiver "%s": class "%s" must implement interface "%s".', $id, $receiverClass, ReceiverInterface::class));
  279. }
  281. $receiverMapping[$id] = new Reference($id);
  283. foreach ($tags as $tag) {
  284. if (isset($tag['alias'])) {
  285. $receiverMapping[$tag['alias']] = $receiverMapping[$id];
  286. if ($tag['is_failure_transport'] ?? false) {
  287. $failureTransportsMap[$tag['alias']] = $receiverMapping[$id];
  288. }
  289. }
  290. }
  291. }
  293. $receiverNames = [];
  294. foreach ($receiverMapping as $name => $reference) {
  295. $receiverNames[(string) $reference] = $name;
  296. }
  298. $buses = [];
  299. foreach ($busIds as $busId) {
  300. $buses[$busId] = new Reference($busId);
  301. }
  303. if ($hasRoutableMessageBus = $container->hasDefinition('messenger.routable_message_bus')) {
  304. $container->getDefinition('messenger.routable_message_bus')
  305. ->replaceArgument(0, ServiceLocatorTagPass::register($container, $buses));
  306. }
  308. if ($container->hasDefinition('console.command.messenger_consume_messages')) {
  309. $consumeCommandDefinition = $container->getDefinition('console.command.messenger_consume_messages');
  311. if ($hasRoutableMessageBus) {
  312. $consumeCommandDefinition->replaceArgument(0, new Reference('messenger.routable_message_bus'));
  313. }
  315. $consumeCommandDefinition->replaceArgument(4, array_values($receiverNames));
  316. try {
  317. $consumeCommandDefinition->replaceArgument(6, $busIds);
  318. } catch (OutOfBoundsException $e) {
  319. // ignore to preserve compatibility with symfony/framework-bundle < 5.4
  320. }
  321. }
  323. if ($container->hasDefinition('console.command.messenger_setup_transports')) {
  324. $container->getDefinition('console.command.messenger_setup_transports')
  325. ->replaceArgument(1, array_values($receiverNames));
  326. }
  328. $container->getDefinition('messenger.receiver_locator')->replaceArgument(0, $receiverMapping);
  330. $failureTransportsLocator = ServiceLocatorTagPass::register($container, $failureTransportsMap);
  332. $failedCommandIds = [
  333. 'console.command.messenger_failed_messages_retry',
  334. 'console.command.messenger_failed_messages_show',
  335. 'console.command.messenger_failed_messages_remove',
  336. ];
  337. foreach ($failedCommandIds as $failedCommandId) {
  338. if ($container->hasDefinition($failedCommandId)) {
  339. $definition = $container->getDefinition($failedCommandId);
  340. $definition->replaceArgument(1, $failureTransportsLocator);
  341. }
  342. }
  343. }
  345. private function registerBusToCollector(ContainerBuilder $container, string $busId)
  346. {
  347. $container->setDefinition(
  348. $tracedBusId = 'debug.traced.'.$busId,
  349. (new Definition(TraceableMessageBus::class, [new Reference($tracedBusId.'.inner')]))->setDecoratedService($busId)
  350. );
  352. $container->getDefinition('data_collector.messenger')->addMethodCall('registerBus', [$busId, new Reference($tracedBusId)]);
  353. }
  355. private function registerBusMiddleware(ContainerBuilder $container, string $busId, array $middlewareCollection)
  356. {
  357. $middlewareReferences = [];
  358. foreach ($middlewareCollection as $middlewareItem) {
  359. $id = $middlewareItem['id'];
  360. $arguments = $middlewareItem['arguments'] ?? [];
  361. if (!$container->has($messengerMiddlewareId = 'messenger.middleware.'.$id)) {
  362. $messengerMiddlewareId = $id;
  363. }
  365. if (!$container->has($messengerMiddlewareId)) {
  366. throw new RuntimeException(sprintf('Invalid middleware: service "%s" not found.', $id));
  367. }
  369. if ($container->findDefinition($messengerMiddlewareId)->isAbstract()) {
  370. $childDefinition = new ChildDefinition($messengerMiddlewareId);
  371. $childDefinition->setArguments($arguments);
  372. if (isset($middlewareReferences[$messengerMiddlewareId = $busId.'.middleware.'.$id])) {
  373. $messengerMiddlewareId .= '.'.ContainerBuilder::hash($arguments);
  374. }
  375. $container->setDefinition($messengerMiddlewareId, $childDefinition);
  376. } elseif ($arguments) {
  377. throw new RuntimeException(sprintf('Invalid middleware factory "%s": a middleware factory must be an abstract definition.', $id));
  378. }
  380. $middlewareReferences[$messengerMiddlewareId] = new Reference($messengerMiddlewareId);
  381. }
  383. $container->getDefinition($busId)->replaceArgument(0, new IteratorArgument(array_values($middlewareReferences)));
  384. }
  386. private function getServiceClass(ContainerBuilder $container, string $serviceId): string
  387. {
  388. while (true) {
  389. $definition = $container->findDefinition($serviceId);
  391. if (!$definition->getClass() && $definition instanceof ChildDefinition) {
  392. $serviceId = $definition->getParent();
  394. continue;
  395. }
  397. return $definition->getClass();
  398. }
  399. }
  400. }