Fin Christensen @fin_ger@mastodon.social

I created an example #helm (#kubernetes) deployment of a distributed key-value store based on my simple-raft-node #rust library. I finally got a first POC running!!! 😎

https://github.com/fin-ger/simple-raft-node/tree/master/examples/helm

#rustlang #CloudComputing #raft

After finishing my raft-node prototype I will move on scratching up a distributed #WAMP router based on that raft-node.

The router will support only publish/subscribe for now. The complete core profile will be eventually implemented when vertical prototyping is finished.

Also, the projects involved into this prototyping lack all kinds of documentation. Documenting and cleaning up the code base of all these projects will be number one priority after prototyping the WAMP-router.

#rustlang #rust

I continued development of my raft-node implementation in #rust and finally finished introducing TCP transports!

However, the implementation still contains some hacks and is definitely unstable.

A working TCP transport can be found under examples/tcp.rs on github:
https://github.com/fin-ger/simple-raft-node

I will create a more complex example now that will include a #helm chart for easy #kubernetes deployment!

#rustlang

You can follow development on github: https://github.com/fin-ger/simple-raft-node

The project runs on rust-nightly only.

The overall performance is now a lot better. However, writes are still quite slow, although I managed to track the problem down to the raft-rs implementation.

Additionally, the raft cluster is crashing and getting very slow when doing many state-change proposals at once.

I think it is now time to look again into properly implementing the ready state processing. Currently it is quite hacky and likely the source of all my raft related problems :D

#rustlang #rust #CloudComputing

I added async support for the machine implementation. I am using the new async/await syntax from nightly and it looks very good so far. The rustasync/runtime executor works like a charm!

I have also added #serde support for the machine trait to support building a machine from a storage snapshot and entries. However, I am not quite happy with the type constraints on my machine. It feels like a hack and will probably cause problems in the future!

#rustlang #rust #CloudComputing

However, the implementation is currently very slow. All operations on the machine are blocking for now and lead to the whole cluster processing only one state change per tick (100ms).

This can be changed by introducing an asynchronous API, which will be implemented later.

#rust #rustlang #CloudComputing

Today I worked on a new Machine trait for my raft Node. The new trait introduces the possibility to store and read state from the machine.

This was previously only possible through the node itself and very unhandy. The machine can now be accessed on the same thread where the node was created.

I was able to do this without using any locks (Mutex, etc.). All inter-thread communication is done with channels so far.

#rust #rustlang #CloudComputing

I'm currently trying to create a simple interface for the #raft consensus algorithm in #rust.

The plan is to provide traits for a Transport, Machine, and Storage which can be passed to a Node instance which then manages the state of the machine over the transport on the storage.

Further crates will later provide implementations for e.g. a TCPTransport or a HashMapMachine.

The project can be found on github:
https://github.com/fin-ger/simple-raft-node/

But don't expect too much yet, it's still WIP... 😉 🦀