14. Event capability
trait EventsCapability
{
private $events = [];
protected function raise(DeploymentEvent $event)
{
$this->events[] = $event;
}
public function eraseEvents() : void
{
$this->events = [];
}
public function raisedEvents() : array
{
return $this->events;
}
}
15. Creating the object from events
final class Deployment
{
use RaiseEventsCapability;
private function __construct()
{
}
public static function fromEvents(array $events)
{
$deployment = new self();
foreach ($events as $event) {
$deployment->apply($event);
}
return $deployment;
}
}
16. Building the object state
final class Deployment
{
private $uuid;
// ...
private function apply(DeploymentEvent $event)
{
if ($event instanceof DeploymentCreated) {
$this->uuid = $event->getUuid();
}
}
}
19. You know... testing!
Scenario: A deployment need to have at least one image
When I create a deployment with 0 image
Then the deployment should not be valid
Scenario: Deployment with 1 image
When I create a deployment with 1 image
Then a deployment should be created
20. @When I create a deployment with :number image
public function iCreateADeploymentWithImage($count)
{
try {
$this->deployment = Deployment::create(
Uuid::uuid4(),
array_fill(0, $count, 'image')
);
} catch (Throwable $e) {
$this->exception = $e;
}
}
21. @Then the deployment should not be valid
public function theDeploymentShouldNotBeValid()
{
if (!$this->exception instanceof InvalidArgumentException) {
throw new RuntimeException(
'The exception found, if any, is not matching'
);
}
}
22. @Then a deployment should be created
public function aDeploymentShouldBeCreated()
{
$events = $this->deployment->raisedEvents();
$matchingEvents = array_filter($events, function(DeploymentEvent $event) {
return $event instanceof DeploymentCreated;
});
if (count($matchingEvents) === 0) {
throw new RuntimeException('No deployment created found');
}
}
23. Create... from the beginning!
final class Deployment
{
// ...
public static function create(Uuid $uuid, array $images)
{
if (count($images) == 0) {
throw new InvalidArgumentException('What do you deploy then?');
}
$createdEvent = new DeploymentCreated($uuid, $images);
$deployment = self::fromEvents([$createdEvent]);
$deployment->raise($createdEvent);
return $deployment;
}
}
24. DeploymentCreated event
final class DeploymentCreated implements DeploymentEvent
{
public function __construct(UuidInterface $uuid, array $images)
{ /* .. */ }
public function getDeploymentUuid()
{
return $this->uuid;
}
public function getImages()
{
return $this->images;
}
}
26. Starting a deployment?
Scenario: A successfully created deployment can be started
Given a deployment was created
When I start the deployment
Then the deployment should be started
Scenario: A deployment can be started only once
Given a deployment was created and started
When I start the deployment
Then the deployment should be invalid
27. @Given a deployment was created and started
public function aDeploymentWasCreatedAndStarted()
{
try {
$uuid = Uuid::uuid4();
$this->deployment = Deployment::fromEvents([
new DeploymentCreated($uuid, ['image']),
new DeploymentStarted($uuid),
]);
} catch (Throwable $e) {
$this->exception = $e;
}
}
28. @When I start the deployment
public function iStartTheDeployment()
{
try {
$this->deployment->start();
} catch (Throwable $e) {
$this->exception = $e;
}
}
29. starting a deployment
final class Deployment
{
private $uuid;
private $started = false;
// ...
public function start()
{
if ($this->started) {
throw new InvalidArgumentException('Deployment already started');
}
$this->raise(new DeploymentStarted($this->uuid));
}
public function apply(DeploymentEvent $event)
{
// ...
if ($event instanceof DeploymentStarted) {
$this->started = true;
}
}
}
35. The event-based implementation
final class EventBasedDeploymentRepository implements DeploymentRepository
{
public function __construct(EventStore $eventStore)
{ /** .. **/ }
public function find(UuidInterface $uuid) : Deployment
{
return Deployment::fromEvents(
$this->eventStore->findByDeploymentUuid($uuid)
);
}
}
42. What do we have right now?
1. Send a command from an HTTP API
2. The command handler talks to our domain
3. Domain raise an event
4. The event is dispatched to the event bus
43. Storing our events
final class DeploymentEventStoreMiddleware implements MessageBusMiddleware
{
private $eventStore;
public function __construct(EventStore $eventStore)
{
$this->eventStore = $eventStore;
}
public function handle($message, callable $next)
{
if ($message instanceof DeploymentEvent) {
$this->eventStore->add($message);
}
$next($message);
}
}
44. We <3 XML
<service id="app.event_bus.middleware.store_events"
class="AppEventBusMiddlewareStoreEvents">
<argument type="service" id="event_store" />
<tag name="event_bus_middleware" />
</service>
45. Our events are stored!
...so we can get our Deployment from
the repository
46. Let's start our deployment!
final class StartDeploymentWhenCreated
{
private $commandBus;
public function __construct(MessageBus $commandBus)
{ /* ... */ }
public function notify(DeploymentCreated $event)
{
// There will be conditions here...
$this->commandBus->handle(new StartDeployment(
$event->getDeploymentUuid()
));
}
}
47. The handler
final class StartDeploymentHandler
{
public function __construct(DeploymentRepository $repository, MessageBus $eventBus)
{ /* ... */ }
public function handle(StartDeployment $command)
{
$deployment = $this->repository->find($command->getDeploymentUuid());
$deployment->start();
foreach ($deployment->raisedEvents() as $event) {
$this->eventBus->handle($event);
}
}
}
49. What happened?
[...]
4. A dispatched DeploymentCreated event
5. A listener created a StartDeployment command
6. The command handler called the start method on the
Deployment
7. The domain validated and raised a DeploymentStarted
event
8. The DeploymentStarted was dispatched on the event-
51. final class Deployment
{
// ...
public function finishedBuild(Build $build)
{
if ($build->isFailure()) {
return $this->raise(new DeploymentFailed($this->uuid));
}
$this->builtImages[] = $build->getImage();
if (count($this->builtImages) == count($this->images)) {
$this->raise(new DeploymentSuccessful($this->uuid));
}
}
}
52. Dependencies... the wrong way
final class Deployment
{
private $notifier;
public function __construct(NotifierInterface $notifier)
{ /* .. */ }
public function notify()
{
$this->notifier->notify($this);
}
}
53. Dependencies... the right way
final class Deployment
{
public function notify(NotifierInterface $notifier)
{
$notifier->notify($this);
}
}
55. final class DeploymentStatusProjector
{
public function __construct(
DeploymentRepository $repository,
DeploymentStatusProjectionStorage $storage
) { /* ... */ }
public function notify(DeploymentEvent $event)
{
$uuid = $event->getDeploymentUuid();
$deployment = $this->repository->find($uuid);
$percentage = count($deployment->getBuiltImages())
/ count($deployment->getImages());
$this->storage->store($uuid, [
'started' => $deployment->isStarted(),
'percentage' => $percentage,
]);
}
}
56. You can have many
projections and storage
backends for just one
aggregate.
57. Testing! (layers)
1. Use your domain objects
2. Create commands and read your event store
3. Uses your API and projections
58. What we just achieved
1. Incoming HTTP requests
2. Commands to the command bus
3. Handlers talk to your domain
4. Domain produces events
5. Events are stored and dispatched
6. Projections built for fast query