#About

Zebus is a lightweight peer to peer service bus, built with CQRS principles in mind. It allows applications to communicate with each other in a fast and easy manner. Most of the complexity is hidden in the library and you can focus on writing code that matters to you, not debugging messaging code.

Zebus is peer to peer, so it does not depend on a broker to dispatch messages between the peers. This allows it to reach a throughput of 140k msg/s and a roundtrip latency under 500µs (have a look at the Performance page for details).

It is resilient thanks to the absence of a broker and an optional persistence feature that ensures that messages are not lost if a peer is down or disconnected.

It is stable, since we have been using it on a production environment at Abc Arbitrage for more than two years. Although we did not release all the necessary bricks yet so you will have to wait a few minor versions to have a fully resilient prodable product.

We call a peer any program that is connected to the bus, a peer is identified by a unique identifier called a PeerId that looks like this: MyAmazingPeer.0 (we use this convention to identify different instances of the same service).

An event is sent by a peer to notify everyone who is interested that something happened (ex: MyBusinessObjectWasSaved, AlertTriggered...).

A command is sent to a peer asking for an action to be performed (ex: SaveMyBusinessObjectCommand).

A class deriving from IMessageHandler<T> will be scanned by the bus and will be used to handle messages of the T kind on reception.

The piece of code that is the point of entry to use Zebus, the methods that you will use the most are Publish(IEvent) and Send(ICommand).

On startup, the bus will scan your assemblies for message handlers and notify the other peers that you are interested by those messages. When a peer publishes a message, it will use the Directory to know who handles it and send the message directly to the correct recipients.

public class MyHandler : IMessageHandler<MyEvent>
{
    public void Handle(MyEvent myEvent)
    {
        Console.WriteLine(myEvent.Value);
    }
}

public void MethodThatSends(IBus bus)
{
    bus.Publish(new MyEvent { Value = 42 });
}

[ProtoContract]
public class MyEvent : IEvent
{
    [ProtoMember(1)]
    public int Value { get; set; }
}

And you're set ! This is all the code you need to send an event from one machine to the other. If you want to read more about how the magic happens, have a look at the wiki. Or if you want a more detailed walkthrough (what to reference, how to start the Bus...) visit the Quick start page.

We try to stick to the semantic versioning principles and keep the release notes up to date.

Copyright © 2015 Abc Arbitrage Asset Management

Zebus is licensed under MIT, refer to LICENSE.md for more information.