messagebus | A simple message bus

You list the "working" command as:

There is support, you just have to configure it:

As soon as you have separate data models for reading and writing, you're following CQRS. Event sourcing is not strictly required.

Note that accomplishing 1 in an application in a way which preserves the expected eventual consistency of the read side with the write side is rather difficult. You'll need to ensure that you publish the event if and only if the update of the write DB succeeded (i.e. there's never a case where you publish and don't update nor is there ever a case where you update but don't publish: if either of those could happen, you cannot guarantee eventual consistency). For instance, if your application does the update and if that succeeds, publishes the event, what happens if the process crashes (or you get network partitioned from the DB, or your lambda exceeds its time limit...) between the update and publishing?

The 2 best ways to ensure eventual consistency are to

• update the write side DB by subscribing to the published event stream
• use change data capture on the write side DB to generate events to publish

The first is at least very close to event sourcing (one could argue either way: I'd say that it depends on the extent to which your design considers the published event stream the source of truth). In the second, remember that you've basically lost all the contextual domain knowledge around the what's happened around that event: you're only seeing what changed in the DB's representation of the model.

Event sourcing and CQRS mutually improve each other (you can event source without doing CQRS, too, though it's only in certain applications that ES without CQRS is practical); event sourcing tends to let you keep the domain front-and-center and since it's append-only, it's the most optimized write model you can have.

Yes, your understanding needs a bit of tweaking.

When you pass a derived object, you are indeed passing it, with all its fields and other data.

The receiving end however can expect the base class, but if the receiver "looks into it", for instance, casts message to BasketCheckOutMessage, it would be able to use all its members. The message.GetType() call would also produce the typeof(BasketCheckOutMessage) output.

Another matter is C#'s Reflection. The JsonConvert.SerializeObject method will investigate which properties on the input members are available to serializing, and it will find FirstName member, because it is there.

Serilog supports Filters that you can apply to selectively include or exclude events from being logged based on the properties of each log event.

In your case, a .Filter.ByExcluding to remove log entries on specific values of RequestPath would do the trick:

You can't send object or other types like that with MassTransit. Messages must be reference types.

Relevant Documentation

At first you must familiarize yourself with the theory of "cold" and "hot" observables. Here is the definition from the Introduction to RX.

1. Cold are sequences that are passive and start producing notifications on request (when subscribed to).
2. Hot are sequences that are active and produce notifications regardless of subscriptions.

What you want is a hot observable, and the problem is that the Observable.Create method creates cold observables. But you can make any observable hot by using the Publish operator. This operator provides a way to have a single underlying subscription shared by multiple independent observers. Example:

Usually anything uid related is configured by SCC in openshift, you can always use oc describe scc to see if any SCC is affecting your user.

EDIT by OP: more details on the solution of a problem can be found in the question itself.

From looking at this, looks like you're using a global variable which connects to something. Persistent connections are bound to an event loop. So if you want to continue using a global variable, the scope of the event loop fixture needs to match the scope of this variable.

I would redefine the event loop fixture to be session scoped, and create a session scoped fixture, depending on the event loop fixture, to initialize this global variable (by just calling get_bus, I suppose). The second fixture is required to ensure proper initialization ordering - i.e. that the event loop is set up properly first.

Edit: The documentation of pytest-asyncio says that event loops by default are test function scoped. Thus, they are being recreated in for each test. This default behavior can be simply overridden: