Build your own message (command/query/event) bus on top of Symfony Messenger and learn all its extension points.

1. Symfony Messenger
Build your own Command | Query | Event Bus
Michał Kurzeja
@michalkurzeja
michal@accesto.com

2. CQS
Command Query Separation
Fetch value or change state, never both!

3. CQRS
Command
+handler
Query
+handler

4. Command Bus
Query Bus
Event Bus

5. Command | Query | Event Bus
Fundamental differences

6. Command Bus Query Bus Event Bus
# of handlers 1 1 0-N
Can return value No Yes No
Async? Might be Shouldn’t Might be

7. But this talk is not about CQRS….

8. Existing Message Bus solutions
Tactician
Simple Bus
Prooph Service Bus
Symfony Messenger
A PSR around the corner….

9. Symfony Messenger
composer require symfony/messenger

10. Unfortunately, a bit complicated approach

11. Example 1 - Simple command bus

12. Idea
Simple Todo list

13. class AddNewTodo
{
/**
* @var UuidInterface
*/
private $uuid;
/**
* @var string
*/
private $task;
/**
* @var DateTimeImmutable
*/
private $deadline;
/**
* @var bool
*/
private $done;
Command

14. class AddNewToDoHandler
{
/**
* @var ToDoRepository
*/
private $repository;
public function __invoke(AddNewTodo $addNewTodo)
{
$todo = new ToDo(
$addNewTodo->uuid(),
$addNewTodo->task(),
$addNewTodo->done(),
$addNewTodo->deadline()
);
$this->repository->save($todo);
}
}
Handler

15. $c[AddNewToDoHandler::class] = function ($c) {
return new AddNewToDoHandler($c[ToDoRepository::class]);
};
DI config

16. $c['command_bus.handler_locator'] = function ($c) {
return new HandlersLocator([
AddNewTodo::class => [AddNewToDoHandler::class => $c[AddNewToDoHandler::class]],
]);
};
Map Command -> Handler

17. $c['command_bus'] = function ($c) {
return new MessageBus(
[
new HandleMessageMiddleware($c['command_bus.handler_locator']),
]
);
};

18. $addNewTodo = AddNewTodo::add($uuid, $task, $deadline);
$this->container['command_bus']->dispatch($addNewTodo);

19. Middleware

20. Middleware 1 Middleware 2 Middleware 3
// logic
next() // logic
next() // logic
next()
// more logic
// more logic
// more logic

21. Example 2 - additional middleware

22. Middleware - let’s add logging*
* Not really needed as it is already implemented

23. class LoggingMiddleware implements MiddlewareInterface
{
public function handle(Envelope $envelope, StackInterface $stack): Envelope
{
$message = $envelope->getMessage();
$this->logger->debug(sprintf('Started handling of %s', get_class($message)));
$result = $stack->next()->handle($envelope, $stack);
$this->logger->debug(sprintf('Finished handling of %s', get_class($message)));
return $result;
}
}

24. Middleware use-cases
DB Transaction
Dispatch event
Validate command
….

25. Example 3 - Envelopes

26. Envelope - Request tracking

27. class RequestIdStamp implements StampInterface
{
/**
* @var string
*/
private $requestId;
public function __construct(string $requestId)
{
$this->requestId = $requestId;
}
public function requestId(): string
{
return $this->requestId;
}
}

28. $requestId = Uuid::uuid4()->toString();
$addNewTodo = AddNewTodo::add($uuid, $task, $deadline);
$this->container['command_bus']->dispatch(
(new Envelope($addNewTodo))->with(new RequestIdStamp($requestId))
);

29. $requestId = null;
$requestIdStamps = $envelope->all(RequestIdStamp::class);
if (count($requestIdStamps)) {
$requestId = $requestIdStamps[0]->requestId();
}
$this->logger->debug(sprintf('[%s] Started handling of %s',
$requestId, get_class($message)));
$result = $stack->next()->handle($envelope, $stack);
$this->logger->debug(sprintf('[%s] Finished handling of %s',
$requestId, get_class($message)));

30. Example 4 - transports

32. Transport - csv file

33. class FileSender implements SenderInterface
{
public function send(Envelope $envelope): Envelope
{
$file = fopen($this->filePath, 'a');
$message = $envelope->getMessage();
fputcsv(
$file,
[
$message->uuid()->toString(),
$message->task(),
$message->deadline() ? $message->deadline()->format('Y-m-d') : '',
$message->done() ? 'Y' : 'N',
]
);
fclose($file);
return $envelope;
}
}

34. class FileReceiver implements ReceiverInterface
{
public function receive(callable $handler): void
{
$file = fopen($this->filePath, 'r');
while (!$this->shouldStop) {
while (($data = fgetcsv($file)) !== false) {
try {
$deadline = new DateTimeImmutable($data[3]);
} catch (Exception $e) {
$deadline = null;
}
$addTodo = new AddNewTodo(
Uuid::fromString($data[0]),
$data[1],
$data[2] === 'Y',
$deadline
);
$handler(new Envelope($addTodo));
}
sleep(1);
}
fclose($file);
}
}

35. Query Bus

36. class ListTodo
{
}

37. class ListTodoHandler
{
/**
* @var ToDoRepository
*/
private $repository;
public function __construct(ToDoRepository $repository)
{
$this->repository = $repository;
}
public function __invoke(ListTodo $listTodo)
{
return $this->repository->findAll();
}
}

38. $c[ListTodoHandler::class] = function ($c) {
return new ListTodoHandler($c[ToDoRepository::class]);
};
$c['query_bus.handler_locator'] = function ($c) {
return new HandlersLocator([
ListTodo::class => [ListTodoHandler::class =>
$c[ListTodoHandler::class]]
]);
};
$c['query_bus'] = function ($c) {
return new MessageBus(
[
new HandleMessageMiddleware($c['query_bus.handler_locator']),
]
);
};

39. /**
* @var $envelope Envelope
*/
$envelope = $this->container['query_bus']->dispatch(new ListTodo());
/**
* @var $handledStamp HandledStamp
*/
$handledStamp = $envelope->last(HandledStamp::class);
$todos = $handledStamp->getResult();

40. Event Bus

41. Send e-mail with new todo

42. class TodoAdded
{
/**
* @var UuidInterface
*/
private $uuid;
/**
* @var string
*/
private $task;
/**
* @var DateTimeImmutable
*/
private $deadline;
/**
* @var bool
*/
private $done;
public static function fromCommand(AddNewTodo $addNewTodo): TodoAdded
{
return new self($addNewTodo->uuid(), $addNewTodo->task(), $addNewTodo->deadline(),
$addNewTodo->done());
}

43. class SendNewTodoToEmail
{
public function __invoke(TodoAdded $todoAdded)
{
printf("nNew todo e-mail notification: %sn", $todoAdded->task());
}
}

44. class AddNewToDoHandler
{
/**
* @var MessageBus
*/
private $eventBus;
public function __invoke(AddNewTodo $addNewTodo)
{
(…)
$todoAdded = TodoAdded::fromCommand($addNewTodo);
$this->eventBus->dispatch($todoAdded);
}
}

45. $c[SendNewTodoToEmail::class] = function ($c) {
return new SendNewTodoToEmail();
};
$c['event_bus.handler_locator'] = function ($c) {
return new HandlersLocator([
TodoAdded::class => [SendNewTodoToEmail::class =>
$c[SendNewTodoToEmail::class]]
]);
};
$c['event_bus'] = function ($c) {
return new MessageBus(
[
new HandleMessageMiddleware($c['event_bus.handler_locator'], true),
]
);
}; Allow no handler

46. Even easier with Symfony Framework

47. class DefaultController extends AbstractController
{
public function index(MessageBusInterface $bus)
{
$bus->dispatch(new SmsNotification('A string to be sent...'));
}
}

48. class SmsNotificationHandler implements MessageHandlerInterface
{
public function __invoke(SmsNotification $message)
{
// do something with it.
}
}
No extra DI config needed, even tagging!

49. Easier routing

50. Debugging

51. https://symfony.com/doc/current/messenger.html
And more

52. Michał Kurzeja
@michalkurzeja
michal@accesto.com
Questions?