eventsourcing | A library for event sourcing in Python | Microservice library

I see 2 problems in the configuration:

1. You just "build" the configuration, but don't start it. After buildConfiguration(), make sure to call 'start()' on the returned Configuration instance. Alternatively, directly call start() on the Configurer. It returns a started configuration instance.

   That should resolve the registrations not coming through. But it will probably trigger an exception related to the next issue....

2. Your MongoTokenStore configuration is incomplete. The TokenStore needs at least a serializer and a MongoTemplate instance. The latter tells the Axon which collections you want to certain types of information in. In your case, only the TrackingTokenCollection would be relant.

Axon Farmework provide something called Configuration API. You can have a look at the Configuration class but for making use of it, you need a Configurer, which will provide you all means of configuring your components!

On the ref-guide, you also have several examples of how to do the configuration using the API or Srring Boot. Example for Commands can be found here.

To help a bit more, I can also share a small project I made using Dropwizard and Axon Framework, meaning no Spring was used and all the Configuration was done through the API. You can find it here https://github.com/lfgcampos/axon-playground/tree/master/chat-getting-started-dropwizard

(Disclaimer: this answer is informed only by a quick skim of the Eventbridge docs)

Event sourcing is a bit of an overloaded term: it's been used to mean everything from an architecture built on exchanging events to using persisted events as the source of truth.

In the latter usage of the term (which might be called "going full event sourcing"), strictly speaking, all reads are replays of an event stream, with there being multiple event streams and the same event often being written to multiple event streams (e.g. a "cart checked out" event may well be written to an event stream for that particular cart and to an event stream consisting only of "cart checked out" events).

EventBridge and EventBridge Archive would appear to be sufficient to "go full event sourcing": each one of these event streams becomes an event bus. It might not be ergonomic to create new buses on the fly and the mechanism for publishing the same event to multiple streams may be complex (e.g. a service getting fed base events and continuously projecting them to other streams), assuming that you will have somewhat less than 100 entities (as AWS accounts are limited to 100 event buses). If you have more than 100 entities, then EventBridge isn't a fit for event sourcing.

That said, in event sourced systems it's almost universally common to have some read functionality which doesn't map well to replaying a stream (e.g. adhoc queries/aggregations over the events). This is where Command Query Responsibility Segregation comes in: it's OK if adopting CQRS to

• have multiple data models in the application
• have workloads use the data model which is the most appropriate for that workload

The command-processing/write side of an application often benefits from event sourcing (especially if there's infrastructure to help with some combination of concurrency control/caching/maintaining single-writer). You then project event streams into other data models (e.g. databases or search systems or alerting infrastructure) which can be tuned for the queries that will be performed against them.

So your question is perhaps better expressed as "how do I do CQRS in an event sourced system", and thankfully, there's a well-established body of technique for that. In your case, sending all the events in (at least some of) the streams to a Lambda which writes them to a database is likely to be a reasonable way to support CQRS.

Event-sourced systems by definition have a time lag between an event being stored in an event store, and it is projected to a read model. The lag is always there unless you apply the event synchronously to an in-memory read model when you commit the event to the store. But that approach would limit you to run your service as a single instance, otherwise, you cannot be sure that the in-memory state is synchronized. There are techniques to solve that, but they are rather complex.

As you don't describe the need for you to get the read model data immediately, it's hard to give specific advice, but I have some tips.

1. If you need it for the UI, and the UI needs the new entity state, you can return the entity state as the command handling result, as you already have it. Then, the UI can show the state immediately without executing any queries.

2. Same scenario, but you return a collection of new events to the UI. If the UI bit is built with something like React and Flux, they most probably already have "event sourcing" there (that's what Flux essentially is), and applying those events via their reducers they can update the UI without querying the read model.

3. If you know what read model needs to be in sync (I can't say how many you have), you can propagate the event commit position to the read model as a metadata property, or just as a document property. Then, you can hold the API call (basically wait) until the read model update position property gets equal to or more than the commit position. The drawback is that you can do it for a specific read model only, so your command handler needs to know too much about the read side.

4. Similar to (3) but you check the checkpoint store position. If the checkpoint store is not optimized with batching, it will soon pass over the last event commit position, then you return 200 OK to the caller. It's a bit easier than (3) as it only cares about the subscription checkpoint, not the single read model, but you need access to the checkpoint store.

5. The UI can do the same after they get the command handled, you need to return the commit position of the last event, and they query and wait.

I've seen all of the above working in production, but my preferred solutions are (1) and (2).

To make any of those work, your command service needs to return a sophisticated result to the caller (API, or beyond) as I've done in Eventuous.

The initializing command handler that receives command1 to create the aggregate might return the aggregateId, so you can fetch the returned result and use the id for future reference.

The error says that it cannot construct a Format for AddUserCommand because there's no Format for ActorRef[Confirmation].

When using Json.format[X], all the members of the case class X must have a Format defined.

In your case, you probably don't want to define a formatter for this case class (serializing an ActorRef doesn't make much sense) but rather build another case class with data only.

Edit: See Levi's answer on how to provide a formatter for ActorRef if you really want to send out there the actor reference.

I got this to work using a bit of a creative version of key remapping:

The com.mongodb.client.MongoClient class is the new API and probably is not compatible with the version of Axon Framework that you are using.

To make it work you may need to downgrade your Mongo dependency (spring-boot-starter-data-mongodb) and use the legacy API import com.mongodb.MongoClient.

yes, it looks like you are using the command gateway correctly, and the aggregates have the right methods annotated with the right stuff! You are using the Saga design pattern for Distributed Transactions which is much better than a 2PC (Two-phase commit), so each step calling the next step is the right way of doing it.

As long as the starting saga method is annotated with @StartSaga, and the end one is annotated with @EndSaga, then the steps will work in order, as well as rollback should work properly

The saveAndWait function actually returns a CompletableFuture, so if you wanted to, you can step through the threads in debug mode and pause the thread until the whole saga is complete if that's what you'd like to do.

My only concern with is is - are you using the Axon Server as the Event Sourcer, or another Event Bus or sourcer that Axon Supports? The only problem with the Standard Axon Server is that it's a Free Tier product, and they are offering a better, more supported version like Axon Server Enterprise (which offers more features - better for infrastructure) - so if you are doing this for a company, then they might be willing to pay for the extra support in higher tier...

Axon Framework does actually support Spring AMQP, which is useful because then, you can have better control over your own infrastructure rather than being tied down to a paid-for Axon Server - which I don't is actually good or not.

If you can get it to work with a custom Event Bus/Sourcer, then your system will be very good - in combination with the ease of developing on Axon.

As long as the Aggregates have the right annotations on them, and you command gateway is autowired correctly, then everything should work fine. My only worry is that there isn't yet enough support for Axon Framework yet...