/**
* @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())));
}
