KeyDB VS mini-redis

- KeyDB: https://github.com/snapchat/keydb

KeyDB is a fork of (everyone's favourite cache store) Redis, and it's messaging protocol and API is 100% compatible with Redis. What that means is you can just point any Redis client (like Hiredis or redis-rb) at a KeyDB instance, and it'll Just Work™️, with no changes required. The KeyDB selling points are: 1) multi-threading by default, and a lot of work was ploughed in to high performance around multi-threading in KeyDB, 2) compatible with all the features of regular Redis, 3) some advanced features which Redis only offers in it's paid/enterprise version are included for free in KeyDB, and the big one for me is multi-active replication, which is what I'm playing with here.

KeyDB is a multithreading, drop-in alternative to Redis. Keydb-operator easily creates a standalone (1 replica) or a multimaster (3 replicas) KeyDB in-memory database. When KeyDB is in multimaster mode, it is possible to have more than one master, allowing read/write operations to all them. That helps for high availability and fault tolerance.

Have you checked https://keydb.dev/

p.s. another share-worthy Redis alternative is KeyDB https://github.com/EQ-Alpha/KeyDB

I went through the wiki, certainly it was interesting. I believe the implementation is at fastlock.cpp [0], I will go through it. You said earlier:

> If we spin too long the thread will sleep although we wait much longer than any other lock you’ll find.

Did you do any tweaks to mitigate this?

> Generally speaking you don't want to be dealing with this stuff unless you really have to.

Ofcourse. I am just way too curious and excited to learn about these!

[0] - https://github.com/EQ-Alpha/KeyDB/blob/v6.0.16/src/fastlock....

One project I found extremely easy to read and understand was mini-redis. Anything similar to that?

For learning async Rust, mini-redis repo is hard to surpass: https://github.com/tokio-rs/mini-redis

The code is simple enough for beginners to follow, but also complex enough to demonstrate Rust async in the wild. And best of all, the code is heavily commented!

You can follow the official Tokio tutorial to implement mini-redis incrementally: https://tokio.rs/tokio/tutorial/setup

for backend async service: https://github.com/tokio-rs/mini-redis

Have a look at https://github.com/tokio-rs/mini-redis, written as an example of a modern rust application.

I sure learned a ton from looking at the mini-redis implementation from the tokio team https://github.com/tokio-rs/mini-redis -- especially when you want to work with tokio! I think it's remarkably well structured and documented.

If https://github.com/tokio-rs/mini-redis does not help answer your question, could you elaborate a bit more on your struggle and we can see if we can fit it into our docs.

Tokio async runtime for Rust has a tutorial in its user guide https://tokio.rs/tokio/tutorial on writing a mini-redis (https://github.com/tokio-rs/mini-redis).

You may be able to take inspiration from mini-redis, which is a learning resource created by the Tokio project. Its purpose is to show off many common patterns in async Rust, and a shared hashmap is one of them.

Serializing messages is a large part of mini-redis, and its source is pretty easy to read. You can also try to implement it using tokio_util::codec, which is a library that helps with implementing this kind of stuff. It has some decent examples on the link as well.

This is specifically for async Rust, but the Tokio project has written mini-redis explicitly for the purpose of being a good example of how to write idiomatic async Rust code.