/** * @param DomainMessage $domainMessage */ private function publishWithAMQP(DomainMessage $domainMessage) { $payload = $domainMessage->getPayload(); $eventClass = get_class($payload); $this->logger->info("publishing message with event type {$eventClass} to exchange {$this->exchange}"); $this->channel->basic_publish($this->messageFactory->createAMQPMessage($domainMessage), $this->exchange); }
protected function applyEventCreated(EventCreated $eventCreated, DomainMessage $message) { $this->logger->debug('UDB2 event created, with url ' . $eventCreated->getUrl()); $xml = $this->retrieveXml($eventCreated->getUrl()); $enrichedEventCreated = EventCreatedEnrichedWithCdbXml::fromEventCreated($eventCreated, $xml, $this->cdbXmlNamespaceUri); $this->publish($enrichedEventCreated, $message->getMetadata()); }
/** * @param DomainMessage $domainMessage */ private function setLogContextFromDomainMessage(DomainMessage $domainMessage) { $this->logContext = []; $metadata = $domainMessage->getMetadata()->serialize(); if (isset($metadata['correlation_id'])) { $this->logContext['correlation_id'] = $metadata['correlation_id']; } }
/** * @inheritdoc */ public function isSatisfiedBy(DomainMessage $domainMessage) { $payload = $domainMessage->getPayload(); $payloadClass = get_class($payload); $this->logger->info("expected: {$this->typeName}, actual: {$payloadClass}"); $satisfied = is_a($payload, $this->typeName) || is_subclass_of($payload, $this->typeName); $this->logger->info('satisfied: ' . ($satisfied ? 'yes' : 'no')); return $satisfied; }
/** * @param DomainMessage $domainMessage */ public function handle(DomainMessage $domainMessage) { $event = $domainMessage->getPayload(); $method = $this->methodNameInflector->inflect($event); if (!method_exists($this, $method)) { return; } $this->{$method}($event, $domainMessage); }
public function handle(DomainMessage $domainMessage, SensitiveData $data = null) { $event = $domainMessage->getPayload(); $method = $this->getHandleMethod($event); if (!method_exists($this, $method)) { return; } $this->{$method}($event, $domainMessage, $data); }
/** * {@inheritdoc} */ public function normalize(DomainMessage $domainMessage) { $payloadType = get_class($domainMessage->getPayload()); if (isset($this->normalizers[$payloadType])) { /* @var DomainMessageNormalizerInterface $normalizer */ $normalizer = $this->normalizers[$payloadType]; return $normalizer->normalize($domainMessage); } return new DomainEventStream(array($domainMessage)); }
/** * @inheritdoc */ public function createBody(DomainMessage $domainMessage) { $this->guardSerializable($domainMessage->getMetadata()); $this->guardSerializable($domainMessage->getPayload()); $data = ['id' => $domainMessage->getId(), 'playhead' => $domainMessage->getPlayhead(), 'metadata' => $domainMessage->getMetadata()->serialize(), 'payload' => $domainMessage->getPayload()->serialize(), 'recorded_on' => $domainMessage->getRecordedOn()->toString()]; return json_encode($data); }
/** * @param DomainMessage $domainMessage * @return void */ public function handle(DomainMessage $domainMessage) { $event = $domainMessage->getPayload(); $eventName = $this->nameExtractor->extract($event); $eventHandlers = $this->handlerLocator->getHandlersForEvent($eventName); foreach ($eventHandlers as $handler) { $methodName = $this->methodNameInflector->inflect($event, $handler); // is_callable is used here instead of method_exists, as method_exists // will fail when given a handler that relies on __call. if (!is_callable([$handler, $methodName])) { throw CanNotInvokeHandlerException::forEvent($event, sprintf("Method '%s' does not exist on handler", is_object($methodName) ? get_class($methodName) : gettype($methodName))); } $handler->{$methodName}($event, $domainMessage); } }
public function setUp() { $this->emitter = \Mockery::spy(Emitter::class); $this->event = \Mockery::mock(EventInterface::class); $this->message = DomainMessage::recordNow(0, 0, new Metadata(), $this->event); $this->eventPublishingListener = new EventPublishingListener($this->emitter); }
/** * @test */ public function it_merges_the_metadata_instances_on_andMetadata() { $domainMessage = DomainMessage::recordNow('id', 42, Metadata::kv('bar', 1337), 'payload'); $newMessage = $domainMessage->andMetadata(Metadata::kv('foo', 42)); $expected = new Metadata(array('bar' => 1337, 'foo' => 42)); $this->assertEquals($expected, $newMessage->getMetadata()); }
/** * @test * @expectedException \Assert\InvalidArgumentException */ public function it_throws_an_exception_if_the_static_method_does_not_exist() { // make sure events exist in the event store $id = 'y0l0'; $this->eventStore->append($id, new DomainEventStream(array(DomainMessage::recordNow(42, 0, new Metadata(array()), new DidEvent())))); $repository = $this->repositoryWithStaticAggregateFactory('someUnknownStaticmethod'); $repository->load('y0l0'); }
public function setUp() { $this->event = \Mockery::mock(EventInterface::class); $this->context = \Mockery::mock(Context::class); $this->metadata = \Mockery::mock(Metadata::class); $this->message = DomainMessage::recordNow('id', 0, $this->metadata, $this->event); $this->handler = \Mockery::mock(MessageEventHandler::class); $this->serviceUnderTest = new DomainMessageListener($this->handler); }
/** * Handles the event by delegating it to Saga('s) related to the event. */ public function handle(DomainMessage $domainMessage) { $event = $domainMessage->getPayload(); foreach ($this->sagas as $sagaType => $saga) { $metadata = $this->metadataFactory->create($saga); if (!$metadata->handles($event)) { continue; } $state = $this->stateManager->findOneBy($metadata->criteria($event), $sagaType); if (null === $state) { continue; } $this->eventDispatcher->dispatch(SagaManagerInterface::EVENT_PRE_HANDLE, array($sagaType, $state->getId())); $newState = $saga->handle($event, $state); $this->eventDispatcher->dispatch(SagaManagerInterface::EVENT_POST_HANDLE, array($sagaType, $state->getId())); $this->repository->save($newState, $sagaType); } }
private function toDomainEventStream(array $events) { $messages = array(); $playhead = -1; foreach ($events as $event) { $playhead++; $messages[] = DomainMessage::recordNow(1, $playhead, new Metadata(array()), $event); } return new DomainEventStream($messages); }
/** * @test */ public function when_appending_one_event_from_a_event_stream_fails_it_rolls_back_all_changes() { $this->expectException(IlluminateEventStoreException::class); // this test is a bit of an hack, by mocking the DateTime object we make // the append() method of the event store throw an exception $time = $this->prophesize(\Broadway\Domain\DateTime::class); $time->toString()->willThrow(new \Exception('This is an invalid event')); $eventStream = new DomainEventStream([DomainMessage::recordNow('aggregate-1', 0, new Metadata(array()), new ADomainEvent()), new DomainMessage('aggregate-1', 1, new Metadata(array()), new ADomainEvent(), $time->reveal())]); $this->store->append('aggregate-1', $eventStream); }
/** * @test */ public function it_publishes_events_and_sensitive_date_to_subscribed_processors() { $domainMessage = DomainMessage::recordNow(1, 1, new Metadata([]), new \stdClass()); $sensitiveData = new SensitiveData(['foo' => 'bar']); $processor1 = $this->prophesize(SensitiveDataEventListenerInterface::class); $processor1->handle($domainMessage, $sensitiveData)->shouldBeCalled(); $processor2 = $this->prophesize(SensitiveDataEventListenerInterface::class); $processor2->handle($domainMessage, $sensitiveData)->shouldBeCalled(); $manager = new SensitiveDataManager([$processor1->reveal(), $processor2->reveal()]); $manager->setSensitiveData($sensitiveData); $manager->handle($domainMessage); }
public function attachExistingEvents($events, $id) { $messages = array(); foreach ($events as $event) { $playhead = $this->getPlayhead($id); $playhead++; $messages[] = DomainMessage::recordNow($id, $playhead, new Metadata(array()), $event); $this->playheads[$id] = $playhead; } $domainEventStream = new DomainEventStream($messages); $this->store->append($id, $domainEventStream); $this->eventBus->publish($domainEventStream); }
public function eventHandling() { // Create the event bus and subscribe the created event listener $eventBus = new SimpleEventBus(); $eventListener = new MyEventListener(); $eventBus->subscribe($eventListener); // Create a domain event stream to publish $metadata = new Metadata(['source' => 'example']); $domainMessage = DomainMessage::recordNow(42, 1, $metadata, new stdClass()); $domainEventStream = new DomainEventStream([$domainMessage]); // Publish the message, and get output from the event handler \o/ $eventBus->publish($domainEventStream); }
/** * @param array $givens * * @return Scenario */ public function given(array $givens = null) { if ($givens === null) { return $this; } $messages = array(); $playhead = -1; foreach ($givens as $event) { $playhead++; $messages[] = DomainMessage::recordNow($this->aggregateId, $playhead, new Metadata(array()), $event); } $this->aggregateRootInstance = $this->factory->create($this->aggregateRootClass, new DomainEventStream($messages)); return $this; }
/** * @param array $events * * @return Scenario */ public function given(array $events = null) { if ($events === null) { return $this; } $messages = array(); $playhead = -1; foreach ($events as $event) { $playhead++; $messages[] = DomainMessage::recordNow($this->aggregateId, $playhead, new Metadata(array()), $event); } $this->eventStore->append($this->aggregateId, new DomainEventStream($messages)); return $this; }
/** * @param DomainMessage $message * * @return mixed */ private static function getContext(DomainMessage $message) { $metadataArray = $message->getMetadata()->serialize(); $context = isset($metadataArray[ContextEnricher::CONTEXT]) ? $metadataArray[ContextEnricher::CONTEXT] : null; return $context; }
/** * Handles an error * * @param EventInterface $error * @param mixed $context * * @return void */ public function handle(EventInterface $error, $context = null) { $this->eventBus->publish(new DomainEventStream([DomainMessage::recordNow(null, null, new Metadata([ContextEnricher::CONTEXT => $context]), $error)])); }
/** * Appends an event to the event store */ private function appendEvent(DomainMessage $event) { $this->connection->table($this->table)->insert(['uuid' => (string) $event->getId(), 'playhead' => (int) $event->getPlayhead(), 'metadata' => $this->serialize($event->getMetadata()), 'payload' => $this->serialize($event->getPayload()), 'recorded_on' => $event->getRecordedOn()->toString(), 'type' => $event->getType()]); }
private function createDomainMessage($playhead, $payload) { return DomainMessage::recordNow(1, $playhead, new Metadata([]), $payload); }
/** * @param InputInterface $input * @param OutputInterface $output * @param DomainMessage $domainMessage */ private function interactOnDomainMessage(InputInterface $input, OutputInterface $output, DomainMessage $domainMessage) { $metadata = ""; $payload = ""; $reflector = new DomainMessageReflector($domainMessage); $questionHelper = new QuestionHelper(); $question = new ConfirmationQuestion('Continue to next playhead? (Y/n)', true); $reflections = $reflector->reflect(DomainMessageReflector::METADATA); foreach ($reflections as $property => $value) { $metadata = $metadata . $property . ': ' . $value . " "; } $reflections = $reflector->reflect(DomainMessageReflector::PAYLOAD); foreach ($reflections as $property => $value) { $payload = $payload . $property . ': ' . $value . " "; } $table = new Table($output); $table->setHeaders(array("Property", "Value"))->setRows(array(array("Id", $domainMessage->getId()), array("Recorded at", $domainMessage->getRecordedOn()->toString()), array("Playhead number", $domainMessage->getPlayhead()), array("Command", $domainMessage->getType())))->render(); $table = new Table($output); $table->setHeaders(array("Metadata"))->setRows(array(array($metadata)))->render(); $table = new Table($output); $table->setHeaders(array("Payload"))->setRows(array(array($payload)))->render(); if (false === $questionHelper->ask($input, $output, $question)) { exit("replaying stopped"); } }
private function insertMessage(Connection $connection, DomainMessage $domainMessage) { $data = array('uuid' => $this->convertIdentifierToStorageValue((string) $domainMessage->getId()), 'playhead' => $domainMessage->getPlayhead(), 'metadata' => json_encode($this->metadataSerializer->serialize($domainMessage->getMetadata())), 'payload' => json_encode($this->payloadSerializer->serialize($domainMessage->getPayload())), 'recorded_on' => $domainMessage->getRecordedOn()->toString(), 'type' => $domainMessage->getType()); $connection->insert($this->tableName, $data); }
/** * @inheritdoc */ public function createBody(DomainMessage $domainMessage) { $this->guardSerializable($domainMessage->getPayload()); return json_encode($domainMessage->getPayload()->serialize()); }
/** * @param DomainMessage $domainMessage * @return array */ public function createProperties(DomainMessage $domainMessage) { return ['correlation_id' => $domainMessage->getId() . '-' . $domainMessage->getPlayhead()]; }
public function whenRegistrationRequestSubmitted(RegistrationRequestSubmitted $event, DomainMessage $message) { $this->statuses->save(new RequestStatus($event->registrationRequestId(), $event->FullName()->fullName(), false, false, false, false, DateTimeImmutable::createFromFormat(\Broadway\Domain\DateTime::FORMAT_STRING, $message->getRecordedOn()->toString()))); }