/** * Publish recorded events on the event bus * * @param ActionEvent $actionEvent */ public function onEventStoreCommitPost(ActionEvent $actionEvent) { $recordedEvents = $actionEvent->getParam('recordedEvents', new \ArrayIterator()); foreach ($recordedEvents as $recordedEvent) { $this->eventBus->dispatch($recordedEvent); } }
/** * @param ActionEvent $actionEvent */ public function onEventStoreCommitPost(ActionEvent $actionEvent) { $this->queuedActionEvents[] = $actionEvent; if (!$this->inConfirmSelectMode) { $this->inConfirmSelectMode = true; while ($actionEvent = array_shift($this->queuedActionEvents)) { $fallback = new \ArrayIterator(); $recordedEvents = $actionEvent->getParam('recordedEvents', $fallback); if ($fallback !== $recordedEvents) { $this->producer->confirmSelect(); } $countRecordedEvents = 0; foreach ($recordedEvents as $recordedEvent) { $this->eventBus->dispatch($recordedEvent); $countRecordedEvents++; } if ($fallback !== $recordedEvents) { $this->producer->setConfirmCallback(function (int $deliveryTag, bool $multiple) use($countRecordedEvents) { return $deliveryTag !== $countRecordedEvents; }, function (int $deliveryTag, bool $multiple, bool $requeue) use(&$result) { throw new RuntimeException('Could not publish all events'); }); $this->producer->waitForConfirm($this->timeout); } } $this->inConfirmSelectMode = false; } }
/** * @param BernardMessage $message */ public function routeMessage(BernardMessage $message) { $proophMessage = $message->getProophMessage(); if ($proophMessage->messageType() === Message::TYPE_COMMAND) { $this->commandBus->dispatch($proophMessage); } else { $this->eventBus->dispatch($proophMessage); } }
/** * @interitdoc */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next) { $eventName = $request->getAttribute(self::NAME_ATTRIBUTE); if (null === $eventName) { return $next($request, $response, new RuntimeException(sprintf('Event name attribute ("%s") was not found in request.', self::NAME_ATTRIBUTE), Middleware::STATUS_CODE_BAD_REQUEST)); } try { $event = $this->eventFactory->createMessageFromArray($eventName, ['payload' => $request->getParsedBody(), 'metadata' => $this->metadataGatherer->getFromRequest($request)]); $this->eventBus->dispatch($event); return $response->withStatus(Middleware::STATUS_CODE_ACCEPTED); } catch (\Exception $e) { return $next($request, $response, new RuntimeException(sprintf('An error occurred during dispatching of event "%s"', $eventName), Middleware::STATUS_CODE_INTERNAL_SERVER_ERROR, $e)); } }
/** * @interitdoc */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next) { $payload = null; $messageName = 'UNKNOWN'; try { $payload = $request->getParsedBody(); if (is_array($payload) && isset($payload['message_name'])) { $messageName = $payload['message_name']; } MessageDataAssertion::assert($payload); $message = $this->messageFactory->createMessageFromArray($payload['message_name'], $payload); switch ($message->messageType()) { case Message::TYPE_COMMAND: $this->commandBus->dispatch($message); return $response->withStatus(Middleware::STATUS_CODE_ACCEPTED); case Message::TYPE_EVENT: $this->eventBus->dispatch($message); return $response->withStatus(Middleware::STATUS_CODE_ACCEPTED); case Message::TYPE_QUERY: return $this->responseStrategy->fromPromise($this->queryBus->dispatch($message)); default: return $next($request, $response, new RuntimeException(sprintf('Invalid message type "%s" for message "%s".', $message->messageType(), $messageName), Middleware::STATUS_CODE_BAD_REQUEST)); } } catch (\Assert\InvalidArgumentException $e) { return $next($request, $response, new RuntimeException($e->getMessage(), Middleware::STATUS_CODE_BAD_REQUEST, $e)); } catch (\Exception $e) { return $next($request, $response, new RuntimeException(sprintf('An error occurred during dispatching of message "%s"', $messageName), Middleware::STATUS_CODE_INTERNAL_SERVER_ERROR, $e)); } }
/** * Perform a message */ public function perform() { $messageClass = $this->args['message_class']; /* @var $message \Prooph\Common\Messaging\RemoteMessage*/ $message = $messageClass::fromArray($this->args['message_data']); if ($message->header()->type() === MessageHeader::TYPE_COMMAND) { try { $this->commandBus->dispatch($message); } catch (CommandDispatchException $ex) { throw $ex->getPrevious(); } } else { try { $this->eventBus->dispatch($message); } catch (EventDispatchException $ex) { throw $ex->getPrevious(); } } }
/** * @param ActionEvent $actionEvent */ public function onEventStoreCommitPost(ActionEvent $actionEvent) { $this->queuedActionEvents[] = $actionEvent; if (!$this->inTransaction) { $this->inTransaction = true; while ($actionEvent = array_shift($this->queuedActionEvents)) { $fallback = new \ArrayIterator(); $recordedEvents = $actionEvent->getParam('recordedEvents', $fallback); if ($fallback !== $recordedEvents) { $this->producer->startTransaction(); } foreach ($recordedEvents as $recordedEvent) { $this->eventBus->dispatch($recordedEvent); } if ($fallback !== $recordedEvents) { $this->producer->commitTransaction(); } } $this->inTransaction = false; } }
/** * @test */ public function it_invokes_all_listeners() { $handler = new MessageHandler(); $this->eventBus->getActionEventEmitter()->attachListener(MessageBus::EVENT_ROUTE, function (ActionEvent $e) use($handler) { if ($e->getParam(MessageBus::EVENT_PARAM_MESSAGE_NAME) === CustomMessage::class) { $e->setParam(EventBus::EVENT_PARAM_EVENT_LISTENERS, [$handler, $handler]); } }); $customMessage = new CustomMessage("foo"); $this->eventBus->dispatch($customMessage); $this->assertSame($customMessage, $handler->getLastMessage()); $this->assertEquals(2, $handler->getInvokeCounter()); }
/** * @test */ public function it_invokes_processing_event_on_workflow_message_handler() { $userData = array('id' => 1, 'name' => 'Alex', 'address' => array('street' => 'Main Street', 'streetNumber' => 10, 'zip' => '12345', 'city' => 'Test City')); $user = UserDictionary::fromNativeValue($userData); $wfEvent = WorkflowMessage::newDataCollected($user, 'test-case', NodeName::defaultName()); $eventBus = new EventBus(); $eventRouter = new EventRouter(); $eventRouter->route($wfEvent->messageName())->to($this->workflowMessageHandler); $eventBus->utilize($eventRouter); $eventBus->utilize(new HandleWorkflowMessageInvokeStrategy()); $eventBus->dispatch($wfEvent); $this->assertSame($wfEvent, $this->workflowMessageHandler->lastWorkflowMessage()); }
/** * @param Envelope $envelope * @param Queue $queue * @return DeliveryResult */ public function __invoke(Envelope $envelope, Queue $queue) : DeliveryResult { $data = json_decode($envelope->getBody(), true); if (!isset($data['created_at'])) { return DeliveryResult::MSG_REJECT(); } $data['created_at'] = DateTimeImmutable::createFromFormat('Y-m-d\\TH:i:s.u', $data['created_at'], new DateTimeZone('UTC')); if (false === $data['created_at']) { return DeliveryResult::MSG_REJECT(); } try { $event = $this->messageFactory->createMessageFromArray($envelope->getType(), $data); $this->eventBus->dispatch($event); } catch (\Throwable $e) { while ($e = $e->getPrevious()) { if ($e instanceof ConcurrencyException) { return DeliveryResult::MSG_REJECT_REQUEUE(); } } return DeliveryResult::MSG_REJECT(); } return DeliveryResult::MSG_ACK(); }
/** * @test */ public function it_sends_a_sub_process_finished_event_via_message_dispatcher_to_a_handler() { $taskListPosition = TaskListPosition::at(TaskListId::linkWith(NodeName::defaultName(), ProcessId::generate()), 1); $wfMessage = $this->getUserDataCollectedTestMessage(); $wfMessage->connectToProcessTask($taskListPosition); $logMessage = LogMessage::logDebugMsg("Just a fake event", $wfMessage); $subProcessFinished = SubProcessFinished::record(NodeName::defaultName(), $taskListPosition->taskListId()->processId(), true, $logMessage, $taskListPosition); $eventBus = new EventBus(); $eventRouter = new EventRouter(); $eventRouter->route(SubProcessFinished::MSG_NAME)->to($this->messageDispatcher); $eventBus->utilize($eventRouter); $eventBus->utilize(new ForwardToRemoteMessageDispatcherStrategy(new FromProcessingMessageTranslator())); $eventBus->dispatch($subProcessFinished); /** @var $receivedMessage SubProcessFinished */ $receivedMessage = $this->receivedMessage; $this->assertInstanceOf(get_class($subProcessFinished), $receivedMessage); $this->assertTrue($taskListPosition->taskListId()->processId()->equals($receivedMessage->subProcessId())); $this->assertTrue($taskListPosition->equals($receivedMessage->parentTaskListPosition())); $this->assertTrue($subProcessFinished->uuid()->equals($receivedMessage->uuid())); $this->assertTrue($logMessage->uuid()->equals($receivedMessage->lastMessage()->uuid())); $this->assertEquals($logMessage->technicalMsg(), $receivedMessage->lastMessage()->technicalMsg()); $this->assertEquals($subProcessFinished->createdAt()->format('Y-m-d H:i:s'), $receivedMessage->createdAt()->format('Y-m-d H:i:s')); }
/** * Dispatch a tick event * * @return array */ public function tickAction() { $this->eventBus->dispatch(TickOccurred::record()); return new JsonModel(['success' => true]); }
/** * @test */ public function it_passes_log_message_to_running_process_using_an_event_bus_with_processor_utilities() { $wfMessage = $this->getUserDataCollectedTestMessage(); $this->getTestWorkflowProcessor()->receiveMessage($wfMessage); $receivedMessage = $this->workflowMessageHandler->lastWorkflowMessage(); $logMessage = LogMessage::logInfoDataProcessingStarted($receivedMessage); //Set up EventBus $eventBus = new EventBus(); $eventBus->utilize(new SingleTargetMessageRouter($this->getTestWorkflowProcessor())); $eventBus->utilize(new WorkflowProcessorInvokeStrategy()); //Publish LogMessage $eventBus->dispatch($logMessage); $this->assertNotNull($this->lastPostCommitEvent); $recordedEvents = $this->lastPostCommitEvent->getRecordedEvents(); $eventNames = []; foreach ($recordedEvents as $recordedEvent) { $eventNames[] = $recordedEvent->messageName(); } $expectedEventNames = ['Prooph\\Processing\\Processor\\Task\\Event\\LogMessageReceived']; $this->assertEquals($expectedEventNames, $eventNames); }
public function publishChangesOf(ProcessingConfig $processingConfig) { foreach ($processingConfig->popRecordedEvents() as $recordedEvent) { $this->eventBus->dispatch($recordedEvent); } }