Eventsourcing Xplained

Event Sourcing
Explained
{ if at first you don't succeed }
2 / 175

About me
EventSourcing Xplained - © BitTacklr 2019 - @yreynhout - yves.reynhout@bittacklr.be 3 / 175

About me
A journeylist with a passion for well-designed, properly decomposed, working
software.
Professional experience:
25 years,
Mainly building products,
In domains such as patient logistics, real estate, manufacturing, construction,
transportation, oil & gas, content & collaboration, government, finance
Contractor | Consultant | Trainer | Analyst | Designer @ BitTacklr
Community experience:
DDD community member,
Occasional speaker, blogger on the topic of Domain Driven Design, Command
and Query Responsibility Segregation, Event Sourcing and Messaging and
related topics.
Author of AggregateSource / Projac | Contributor to SqlStreamStore (OSS).

Half stack developer

Half stack developer
Guess which part

Agenda
Primer
Principles & Patterns
Common Problems & Solutions

Primer
Messages
Event Store

Primer - Messages
A message is a record of information ...

Primer - Messages
A message is a record of information ...
that captures meaning and data
that can be transmitted
that can be stored
that typically has a header and a body (i.e. an envelope)

Primer - Messages
A schema describes the shape or structure of messages in a formal language ...

Primer - Messages
A schema describes the shape or structure of messages in a formal language ...
such as XML or JSON schema, Protocol Buffers' Language, etc.
that can be shared between parties
for which code can be generated
that can be interpreted
that optionally contains constraints, requirements and/or metadata

Primer - Messages
Encoding is the conversion of messages into a specific form ...

Primer - Messages
Encoding is the conversion of messages into a specific form ...
such that it can form a protocol with other parties
such as XML, JSON, BSON, Protocol Buffers, UTF-8|16|32,
which is often classified as either binary or character
which is a more general form of serialization
https://en.wikipedia.org/wiki/Comparison_of_data_serialization_formats

Primer - Messages
Why use a schema and encoding to define your messages?

Primer - Messages
Why use a schema and encoding to define your messages?
Your programming language supports things your encoding format does not
Your encoding format supports things your programming language does not
Your encoding format is dictating your message type system, not your programming
language
Your code is simply too refactor friendly
Generally, people suck at versioning - schema helps you get serious about that
Schema allows for up-front design and is a collaboration medium

Primer - Types of Messages
Commands
Events
Documents
Queries | Requests & Responses

Primer - Commands

Primer - Commands
A command is a request to change state or to invoke behavior ...

Primer - Commands
A command is a request to change state or to invoke behavior ...
that can be classified as a type of message,
that can denote the body of a message,
that captures meaning and data of something that should happen,
that can capture business or domain relevant change requests,
uses imperative (think German),
uses domain specific language,
expressed using verbs, preferably sentences.

Primer - Events

Primer - Events
An event is an immutable record of historical information ...

Primer - Events
An event is an immutable record of historical information ...
that can be classified as a type of message
that can denote the body of a message
that captures meaning and data of something that has happened
that - to the best of our knowledge - happened at a certain instant
that can capture business or domain relevant changes
uses past tense (think French - passé composé)
uses domain specific language,
expressed using verbs, preferably sentences.

Primer - Documents

Primer - Documents
A document message acts as a data container and lets the receiver decide what to do
with it ...

Primer - Documents
A document message acts as a data container and lets the receiver decide what to do
with it ...
is used to integrate / exchange information between systems,
is often associated with canonical or stable data models,
is also the shape used to communicate the result of a query,
the timing of when it's sent or received and the intent is less important, thus
differentiating itself from commands and events

Primer - Queries

Primer - Queries
A query is a request to retrieve information ...

Primer - Queries
A query is a request to retrieve information ...
usually represented as the combination of a request and response message
that can capture business or domain relevant requests,
where the request message often contains criteria to select, filter and page results
where the response message often contains the result that meets the request criteria
often aligns with the needs of consumers, e.g. the data on a screen or the shape of
an API

Primer - Commands
Example: Reserve a table at a restaurant

Primer - Commands
Analysis

Primer - Commands
Analysis
Who wants to make the reservation?
How many guests are you?
When are you coming?
Which restaurant?
What's the occasion? (optional)
Any special request? (optional)

Primer - Commands
Example: Reserving a table at a restaurant
PROTO

Primer - Commands
PROTO
message ReserveTable = {
string MemberId = 1;
int32 Guests = 2;
string Date = 3
string Time = 4;
string RestaurantId = 5;
string Occasion = 6;
string SpecialRequest = 7;
}

Primer - Commands
CSHARP

Primer - Commands
CSHARP
public class ReserveTable
{
public Guid MemberId { get; set; }
public Int32 Guests { get; set; }
public DateTime Date { get; set; }
public TimeSpan Time { get; set; }
public Guid RestaurantId { get; set; }
public String Occasion { get; set; }
public String SpecialRequest { get; set; }
}

Primer - Commands
SERIALIZATION

Primer - Commands
SERIALIZATION
var message = new ReserveTable { MemberId = Guid.NewGuid(), /* ... */ };
Console.WriteLine(JsonConvert.SerializeObject(message));

Primer - Commands
SERIALIZATION
DESERIALIZATION

Primer - Commands
SERIALIZATION
DESERIALIZATION
var serialized =
@"{""MemberId"": ""6e98e539-eb01-47e9-8961-efd9728a14df"", /*...*/ }";
var message = JsonConvert.DeserializeObject<ReserveTable>(serialized);

Primer - Commands
JSON

Primer - Commands
JSON
{
"MemberId": "6e98e539-eb01-47e9-8961-efd9728a14df",
"Guests": 2,
"Date": "2018-01-27", "Time": "19:00:00",
"RestaurantId": "200edce7-263e-4799-81fe-834f84fff17a",
"Occasion": "Birthday",
"SpecialRequest": "Please don't play any birthday music."
}

Primer - Commands
HTTP

Primer - Commands
HTTP
HTTP/1.1 200 OK
Content-Type: application/vnd.tableau.reservetableatrestaurant+json
Content-Length: 319
{
"Guests": 2,
"Date": "2018-01-27", "Time": "19:00:00",
"Occasion": "Birthday",
"SpecialRequest": "Please don't play any birthday music."
}

Primer - Events
Example: A table was reserved at a restaurant

Primer - Events
Analysis

Primer - Events
Analysis
Who made the reservation?
When was it made?
How many guests are you?
When are you coming?
Which restaurant?
Which table was reserved?
What's the occasion? (optional)
Any special request? (optional)

Primer - Events
JSON

Primer - Events
JSON
{
"Guests": 2,
"Date": "2018-01-27", "Time": "19:00:00",
"TableReference": "C2", "Occasion": "Birthday",
"SpecialRequest": "Please don't play any birthday music.",
"When": "2018-01-07T20:47:00"
}

Primer - Events
HTTP

Primer - Events
HTTP
HTTP/1.1 200 OK
Content-Type: application/vnd.tableau.tablereservedatrestaurant+json
Content-Length: 319
{
"Guests": 2,
"Date": "2018-01-27", "Time": "19:00:00",
"TableReference": "C2", "Occasion": "Birthday",
"SpecialRequest": "Please don't play any birthday music.",
"When": "2018-01-07T20:47:00"
}

Primer - Documents
Example: List of cuisines
HTTP

Primer - Documents
Example: List of cuisines
HTTP
POST /api/lists HTTP/1.1
Host: tableau.fr
Content-Type: application/vnd.tableau.list-of-cuisines+json
Content-Length: 483
{ "Options": [
"American", "Italian", "Steakhouse", "French", "Pacific Rim",
"Indian", "Mexican", "Japanese", "British", "Wine Bar",
"Chinese", "Spanish", "Pizzeria", "Greek", "Thai", "South American",
"Tapas / Small Plates", "Grill", "Comfort Food", "Turkish",
"Argentinean", "Afternoon Tea", "Burgers", "Nepalese", "Wild Game",
"Halal", "Café", "Contemporary European", "Southeast Asian"
"Dim Sum", "European", "Gastro Pub", "Modern European" ] }

Primer - Queries
Example: Search for a table to reserve
Request Analysis

Primer - Queries
Request Analysis
What date do you want to reserve on?
At what time?
What type of food / cooking do you want to have?
How many guests will you be?
Where will you / do you want to be?

Primer - Queries
Response Analysis

Primer - Queries
Response Analysis
For each restaurant with sufficient capacity
indicate whether it's verified or not
state its name, type of food served, address, location, relative distance if
applicable
give an indication of the price range, the rating by other members, its performance
statistics
offer the available time slots

Primer - Queries
HTTP - Request

Primer - Queries
HTTP - Request
POST /api/search HTTP/1.1
Host: tableau.fr
Authorization: Bearer
Content-Type: application/vnd.tableau.searchrequest+json
Content-Length: 108
{
"Date": "2020-01-27",
"Time": "19:00",
"Guests": 5,
"Location": "Nearby(50.844795,4.356717)",
"Cuisine": "Italian"
}

HTTP - Response
HTTP/1.1 200 OK
Content-Type: application/vnd.tableau.searchresponse+json
Content-Length: 634
[ { "Restaurant": {
"Id": "d937eeb1-9ebc-4d0c-a53e-c7ac349adcbd", "Verified": false,
"Name": "La Cucina Della Nonna", "Cuisine": "Italian Food",
"PriceRange": "€€", "Rating":"***", "TotalReviews": 12,
"ReservationStatistics" : {
"Total": 3000, "TotalToday": 0, "TotalByMembers": 300
},
"Address": [ "Rue des Bouchers 5", "1000 Brussels", "Belgium" ],
"Distance": "500m", "Coordinates": "50.847821,4.354781" },
"AvailableTimeSlots": {
"18:30" : [ "A", "B" ], "18:45" : [ "A" ],
"19:00" : [ "E" ], "19:15" : [ "B", "D" ],
"19:30" : [ "A", "D" ] } } ]

Primer - Message Identity

A message identifier uniquely identifies a message ...

A message identifier uniquely identifies a message ...
and is usually transmitted as a header,
and is useful for traceability purposes (causation & correlation),
and is useful for message deduplication and idempotent processing,
the use of global unique identifiers is fairly common (uuid | guid).

Primer - Messaging
If you want to learn more about messaging I can highly recommend ...

Primer - Event Store

Overview
Examples

An event source is where events come from or took place ...

An event source is where events come from or took place ...
and could be either hardware or software
and there could be one or more
and is brought to our attention by a producer or publisher or emitter

An event destination is where events go to and are interpreted or handled ...

An event destination is where events go to and are interpreted or handled ...
and there could be none, one or more than one
and is facilitated by a consumer or receiver or sink

An event middleware decouples sources from destinations ...

An event middleware decouples sources from destinations ...
or said differently, decouples producers from consumers
of which Apache Kafka, Event Store, Azure Event Grid, Amazon SNS are examples

An event stream is a sequence of events partitioned by a name or key

Each event appears at a certain version within an event stream

An event store is a collection of streams

Each event appears at a certain position within an event store

Example: Online shopping

Events

John's shopping cart stream

John's shopping cart stream
> Guest started shopping

Jane's shopping cart stream

All stream

All stream
john: Guest started shopping
jane:

A subscription is an agreement to be notified when new events are written to a stream
...

A subscription is an agreement to be notified when new events are written to a stream
...
and is typically set up by a consumer
and is typically facilitated by an event store's client API
and is one of many ways to feed events to projections
and starts off at a known position in the all stream
or starts off at a known version in a stream

All stream subscription from the beginning

All stream subscription from the beginning
john: Guest started shopping
0 2 4 5 7
jane:
1 3 6 8

All stream subscription from a known position

All stream subscription from a known position
john: Item was removed from cart
0 2 4 5 7
jane:
1 3 6 8

Common Operations

Common Operations
Write Behavior

Common Operations
Write Behavior
AppendToStreamAtVersion: append one or more events to a stream, expecting
the stream to be at a certain version (OCC), as an atomic operation (ACID)
AppendToStreamAtAnyVersion: append one or more events to a stream,
regardless of which version the stream is at, as an atomic operation (ACID)
AppendToStreamAtNoVersion: append one or more events to a stream,
expecting there to be no stream (OCC), as an atomic operation (ACID)

Common Operations

Common Operations
Read Behavior
ReadStreamForwards: read a slice of events from a stream, as of a certain
version, progressing towards the end of the stream
ReadStreamBackwards: read a slice of events from a stream, as of a certain
version, progressing towards the beginning of the stream
ReadAllStreamForwards: read a slice of events from the all stream, as of a
certain position, progressing towards the end of the all stream
ReadAllStreamBackwards: read a slice of events from the all stream, as of a
certain position, progressing towards the beginning of the all stream

Common Operations

Common Operations
Observation Behavior
SubscribeToStream: observe events in a stream, as of a certain version
SubscribeToAllStream: observe events in a stream, as of a certain position

Implementations

Implementations
EventStore - https://eventstore.org/ [.NET HTTP]
SqlStreamStore - https://sqlstreamstore.io/ [.NET C#]
Marten - https://jasperfx.github.io/marten/ [.NET C#]
Equinox - https://github.com/jet/equinox [.NET F#]
AxonIQ - https://axoniq.io/ [JAVA]
PROOPH - http://getprooph.org/ [PHP]
Broadway - https://github.com/broadway [PHP]
Commanded - https://github.com/commanded/eventstore [ELIXIR]
Eventide - https://eventide-project.org/ [RUBY]
...

Primer
Questions?

Event Sourcing (ES)
... meets Command & Query Responsibility Segregation (CQRS)
... meets Domain Driven Design (DDD)

Event Sourcing
To capture all state changes as a sequence of events.

Event Sourcing
To capture all state changes as a sequence of events.
captures and carries intent forward,
captures semantics and data together,
better fit for behavior centric problems,
not so much for data centric problems,
captures domain specific language,
emphasis is on intent, rather than on the data that goes with that intent

Event Sourcing
Example - Online Shopping

Event Sourcing
Example - Online Shopping
Cart
Item
Customer

Event Sourcing
Data Centric State Changes

Event Sourcing
V1

Event Sourcing
V1 V2

Event Sourcing
V2

Event Sourcing
V2 V3

Event Sourcing
V3

Event Sourcing
V3 V4

Event Sourcing
V4

Event Sourcing
V4 V5

Event Sourcing
V5

Event Sourcing
Event Centric State Changes

Event Sourcing
V1
GSS
- GSS = Guest Started Shopping

Event Sourcing
V1
GSS
V2
IA
- IA = Guest Added Item To Shopping Cart

Event Sourcing
V1
GSS
V2
IA
V3
IA

Event Sourcing
V1
GSS
V2
IA
V3
IA
V4
IR
- IR = Guest Removed Item From Shopping Cart

Event Sourcing
V1
GSS
V2
IA
V3
IA
V4
IR
V5
IA

Event Sourcing

Event Sourcing
Focus of Data Centric State Changes
V1 V2 V3 V4 V5

Event Sourcing
Focus of Data Centric State Changes
V1 V2 V3 V4 V5
Focus of Event Centric State Changes
V1
GSS
V2
IA
V3
IA
V4
IR
V5
IA

Event Sourcing
Event Centric Story Telling

Event Sourcing
Event Centric Story Telling
Customer started shopping
Item added to cart
Item added to cart
Item removed from cart
Customer checked out cart t

Primer - Event Sourcing
Motivation

Primer - Event Sourcing
Motivation
the software is acting as the book of record,
the history needs to be kept, i.e. audit heavy,
the history itself brings value,
there's a need for pro- and retroactive behavior,
there's a need for temporal queries,
how we got here is as important as where we are now (intent carried forward),
the (sub-)domain itself highly collaborative,
driven by behavior rather than data,
multiple representation of the same data is required,
other pieces of software are interested in our state changes,
history of disconnected clients needs to be reconciled.

CQRS

CQRS
To split reading from writing, to create two objects where there used to be one

CQRS
To split reading from writing, to create two objects where there used to be one
at the object level better known as CQS (by Bertrand Meyer, Eiffel | Design by
Contract),
usually applied at the application or service boundary,
rather localized, definitely not system wide,
does not require but can benefit from
a task based UI
event sourcing
messaging
eventual consistency

CQRS - Example
Imagine a service to maintain customers ...

CQRS - Example
Before
public interface CustomerService
{
void MakeCustomerPreferred(CustomerId id);
Customer GetCustomer(CustomerId id);
CustomerSet GetCustomersWithName(Name name);
CustomerSet GetPreferredCustomers();
void ChangeCustomerLocale(CustomerId id, Locale locale);
void CreateCustomer(Customer customer);
void EditCustomerDetails(CustomerDetails details);
}

CQRS - Example
After
public interface CustomerWriteService
{
void MakeCustomerPreferred(CustomerId id);
void ChangeCustomerLocale(CustomerId id, Locale locale);
void CreateCustomer(Customer customer);
void EditCustomerDetails(CustomerDetails details);
}

CQRS - Example
After
public interface CustomerReadService
{
Customer GetCustomer(CustomerId id);
CustomerSet GetCustomersWithName(Name name);
CustomerSet GetPreferredCustomers();
}

CQRS - Origins
Traditional Architecture

CQRS - Origins
Data
Store
Model
Application Services
Service Boundary
Client
Legend
Data

CQRS - Origins

CQRS - Origins
Advantages
Simple
Repeatable

CQRS - Origins
Advantages
Simple
Repeatable
Disadvantages
Noun centric
Read & write mismatch resulting in lots of mapping
Anemic & structural (*)
Little logic / mostly transaction script (*)
Loss of intent / decision

CQRS - Origins
Capture intent

CQRS - Origins
Capture intent
Data
Store
Model
Application Services
Service Boundary
Client
Legend
Data
Command

CQRS - Origins
Split writing and reading

CQRS - Origins
Split writing and reading
Data
Store
Model
Command Handling Query Handling
Service Boundary
Client
Legend
Data
Command

CQRS - Origins
Split at the service boundary

CQRS - Origins
Split at the service boundary
Data
Store
Model
Command Handling
Service Boundary
Query Handling
Service Boundary
Client
Legend
Data
Command

CQRS - Origins
Split at the data boundary

CQRS - Origins
Split at the data boundary
Data
Store
Data
Store
Model
Command Handling Query Handling
Service Boundary
Client
Legend
Data
Command

Event Sourcing meets CQRS

Split writing and reading using events

Split writing and reading using events
Event
Store
Data
Store
Model
Command Handling
Projections
Query Handling
Service Boundary
Client
Legend
Data
Command
Event

Event Sourcing meets DDD
What changes?

What changes?
Entities become event sourced,
Events become part of the model,
Repositories deal with streams, events and event stores.

What changes?
What remains?

What changes?
What remains?
the importance of language,
the focus on the domain one is active in,
models to tackle problems,
strategic design there of,
other tactical patterns (e.g. Value Objects, Services, Factories, etc.)

Common Problems & Solutions

How do I perform analysis and design for event
sourcing?

Solution
Apply event storming to uncover the events, commands, entities, boundaries,
processes at play in your domain - https://www.eventstorming.com/
Apply event modeling if you have a good grasp of the personas, ux and/or ui,
integrations, processes at play in your domain - https://eventmodeling.org/
Apply domain story telling if you want to uncover actors, work objects, actions but
above all scenarios at play in your domain - https://domainstorytelling.org/
Learn about state machines to model the life cycle of entities - use visual methods to
uncover invariants and when each behavior is possible - unravel and challenge
accidental complexity
Pay attention to the language and temporal aspects in your domain
Note: though event sourcing may warrant different analysis and design techniques,
that doesn't mean existing methods are obsolete.

So ... how do I write event sourced entities?

Solution
Conceptual Model

Solution
Conceptual Model
CH E
ES RS
CH = Command Handler (Controller / Actor)
E = Entity
ES = Event Store (Client / Repository)

Solution
Flow for a new entity

Solution
Flow for a new entity
CH E
ES

Solution
Flow for an existing entity

Solution
Flow for an existing entity
CH E
ES

Solution
Stream

Solution
Stream
stream-x

Solution
Stream
stream-x
E1
T1

Solution
Stream
stream-x
E1 E2
T1 T2

Solution
Stream
stream-x
E1 E2 E3 E4
T1 T2 T3

Solution
Stream
stream-x
E1 E2 E3 E4 ...
T1 T2 T3

Great ... but I meant in code ;-)

Authoring Abstractions

Event Source
public interface IEventSource
{
void RestoreFromEvents(object[] events);
object[] TakeEvents();
}

Event Recorder
public class EventRecorder {
private readonly List<object> _recorded = new List<object>();
public bool HasRecordedEvents => _recorded.Count != 0;
public object[] RecordedEvents => _recorded.ToArray();
public void Record(object @event) {
if (@event == null)
throw new ArgumentNullException(nameof(@event));
_recorded.Add(@event);
}
public void Reset() => _recorded.Clear();
}

Event Player
public class EventPlayer {
private readonly Dictionary<Type, Action<object>> _handlers
= new Dictionary<Type, Action<object>>();
public void Register<TEvent>(Action<TEvent> handler) {
if (handler == null)
throw new ArgumentNullException(nameof(handler));
var typeOfEvent = typeof(TEvent);
if (_handlers.ContainsKey(typeOfEvent))
throw new InvalidOperationException(
"There's already a handler registered for the event of type " +
$"'{typeOfEvent.Name}'");
_handlers.Add(typeOfEvent, @event => handler((TEvent)@event));
} // to be continued ...

Event Player
public void Play(object @event) {
if (@event == null)
throw new ArgumentNullException(nameof(@event));
if (_handlers.TryGetValue(@event.GetType(),
out Action<object> handler)) {
handler(@event);
}
}
}

Event Source - Explicit Player / Recorder
public abstract class EventSource : IEventSource {
private readonly EventPlayer Player
= new EventPlayer();
private readonly EventRecorder Recorder
= new EventRecorder();
protected void On<TEvent>(Action<TEvent> handler) {
Player.Register<TEvent>(handler);
}
protected void Apply(object @event) {
Player.Play(@event);
Recorder.Record(@event);

// continued ...
void IEventSource.RestoreFromEvents(object[] events) {
if(events == null)
throw new ArgumentNullException(nameof(events));
if(Recorder.HasRecordedEvents)
throw new InvalidOperationException(
"Restoring from events is not possible when an instance " +
"has recorded events.");
foreach(var @event in events)
Player.Play(@event);

// continued ...
object[] IEventSource.TakeEvents() {
if(!Recorder.HasRecordedEvents)
return Array.Empty<object>();
var recorded = Recorder.RecordedEvents;
Recorder.Reset();
return recorded;
}
}

Event Source - Explicit Player / Recorder - Usage
public class RestaurantService : EventSource {
public void ReserveTable(MemberId member, GuestCount guests,
TimeSlot timeSlot, Text occasion, Text specialRequest) {
// .. guards, conditional and computational logic here
Apply(new TableReserved {
RestaurantId = this.restaurantId, Date = this.date,
Time = timeSlot, TableReference = availableTable,
MemberId = member, Guests = guests,
Occasion = occasion, SpecialRequest = specialRequest
});
}
} //continued

Event Source - Explicit Player / Recorder - Usage
private readonly HashSet<TableReference> tablesTaken =
new HashSet<TableReference>();
private RestaurantService() {
On<RestaurantTableWasReserved>(@event => {
this.tablesTaken.Add(new TableReference(@event.Table));
});
On<RestaurantServiceScheduled>(@event => {
this.restaurantId = new RestaurantId(@event.RestaurantId);
this.date = @event.Date;
this.serviceHours = TimeRange.From(@event.ServiceHours);
})
}
}

Recommendations

Recommendations
Don't do stream version management in a base / entity class.
Do put the expected version on a base / entity class if that's how you go from the
read path to the write path.
Don't mix command handling and entities.
Don't overdo it with too much framework - kills creativity.
Be idiomatic with regard to your programming language - e.g. it looks very different in
a functional programming language.

How come my events look like property sourcing?

Pattern
Property sourcing is an event sourcing anti-pattern where each change to a field /
property causes an event.

Pattern
Property sourcing is an event sourcing anti-pattern where each change to a field /
property causes an event.
Forces
Any products that require arbitrary or a high degree of customization at the field level
(e.g. ERP systems).
Solutions
If accidental, stop and align your commands / events with the actual use cases
instead of this.
If on purpose, expect your streams to become very chatty and have low domain
relevance - even to the point where you'll have to infer what happened - which kinda
defeats the purpose of event sourcing.

How come my events only have verbs that sound
like I'm building an expensive database?

Pattern
Event names in event sourcing that have a lot of Create, Update, Delete in them are
an anti pattern.

Pattern
Event names in event sourcing that have a lot of Create, Update, Delete in them are
an anti pattern.
Solutions
Focus on building task based user interfaces that capture use cases an end-user /
automated part of the system is trying to achieve.
If you focus on UX and domain first, language will follow.
Accept that sometimes the domain is not interesting or there's nobody there that can
really explain it - maybe you shouldn't be trying to apply event sourcing here.

How do I enforce set constraints?

Use Case - Email addresses uniqueness

Solution

Use Case - Monotonic invoice numbers

Solution

How do I handle failure?

Unexpected Failure

Unexpected Failure
Solution

Expected Failure

Expected Failure
Solution

How do I deal with validation and authorization?

Solution

How do I deal with large payloads?

Pattern - Claim Check
Store message data in another store and pass a Claim Check to subsequent
components via commands and/or events. These components can use the Claim
Check on the command and/or event to retrieve the stored information.

Pattern - Claim Check - Solution 1

Pattern - Claim Check - Solution 2a

Pattern - Claim Check - Solution 2b

How do I integrate with other systems?

Solution

How do I cope with time and scheduling?

Pattern
Time can be represented as a series of events that mimick the ticking of the clock

Pattern
Time can be represented as a series of events that mimick the ticking of the clock
when the granularity is coarse grained (days, months, years, dates)
when the observation of the clock ticking at the right time is less important than
knowing the clock ticked, i.e. reduced precision
you'll have to think about the timezone the clock is ticking in and whether or not that
is important for your observers

Solution
Time as a stream of events - V1
T1

Solution
T1 T2

Solution
T1 T2 T3

Solution
T1 T2 T3 T4

Solution
T1 T2 T3 T4 T5

Solution
T1

Solution
T1 T2

Solution
T2

Solution
T2 T3

Solution
T3

Solution
T3 T4

Solution
T4

Solution
T4 T5

Solution
T5

Help! My stream is too long!

Pattern
Snapshotting is the act of taking a copy of the state of an entity at a certain version in
the stream

Pattern
Snapshotting is the act of taking a copy of the state of an entity at a certain version in
the stream
typically implemented as a memento on the entity,
can be stored inside the stream or elsewhere,
it needs to know what it is a snapshot of,
can be negotiated (e.g. different snapshots for different versions of the software),
can be performed while appending to the stream or as a separate process,
beware that if your entity's state changes, your snapshot might become invalidated.

Snapshotting

Pattern
Superseding is the act of starting off a new stream that only copies the relevant state
as its initial event and makes the old stream point to the new stream.

Pattern
Superseding is the act of starting off a new stream that only copies the relevant state
as its initial event and makes the old stream point to the new stream.
could be based on last event time, stream age, stream depth, something else ...
useful pattern to break up large streams which seem to be never ending
only useful if not the entire history is needed to make the next decision

Superseding

How does testing work with event sourcing?

Testing
Definition
Scenario
Scenario Builder
Example

Testing
The act of verifying that a command handler and the event source affected behave as
expected ...

Testing
The act of verifying that a command handler and the event source affected behave as
expected ...
written as a specification,
preferably executed as an integration test with the event store (*),
usually integrated with a unit testing framework

Testing
Anatomy of scenario
CommandHandler
Givens
When
Thens / Throws

Testing
Anatomy of scenario builder

Testing Example
public class RestaurantReservationScenarios {
[Fact] public Task when_reserving_a_table() {
return new Scenario()
.Given(EmptyRestaurantService.SetupFor(Today))
.When(new ReserveTable {
RestaurantId = Restaurants.Default, Date = Today,
Time = "19:00", MemberId = Members.Default, Guests = 2,
Occasion = Text.None, SpecialRequest = Text.None
})
.Then(RestaurantService.Today, new TableReserved {
Time = "19:00", TableReference = Tables.DefaultFor(2),
MemberId = Members.Default, Guests = 2,
}).AssertAsync(); }
}

Testing Example
public class RestaurantReservationScenarios {
[Fact] public Task when_reserving_a_table_while_fully_booked() {
return new Scenario()
.Given(FullyBookedRestaurantService.SetupFor(Today))
.When(new ReserveTable {
Time = "19:00", MemberId = Members.Default, Guests = 2,
})
.Throws(new AllTablesTakenAtTimeException(
RestaurantService.Today, Today, "19:00"
).AssertAsync(); }
}

Testing
Recommendations
Try to find the right level of abstraction to write tests at,
For scenario driven tests that means being able to change your implementation
without having to touch your tests,
Try to assert that only what you expected occurred and nothing else,
Keep the boilerplate / distraction out of your tests,
Value objects and test data generation help anonymize / randomize valid values.

What should I be looking for while applying event
sourcing?

Stream Patterns
Long vs Short Lived

Stream Patterns
Slow vs Fast Changing

Stream Patterns
Low vs High Volume

Stream Patterns
Beginning vs Ending

Stream Patterns
Cyclic Behavior

Common Problems and Solutions
Questions?

The End
Join the DDD-ES-CQRS community
http://j.mp/ddd-es-cqrs
Reading Material
Versioning in an Event Sourced System https://leanpub.com/esversioning

Eventsourcing Xplained

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Empfohlen

Empfohlen (20)

Eventsourcing Xplained