The PR add support for blocking RM_Call.

[MeirShpilraien]

The blocking RM_Call was introduce on Redis 7.2. The idea is to give a module writer the ability to perform blocking commands like BLPOP using RM_Call. This PR adds this functionality to redismodule-rs.

In order to be able to invoke blocking commands, the user need to use call_blocking instead of call or call_ext. call_blocking will return an enum that can either be a regular reply (like call_ext returns) or it can be a FutureCallReply.

The FutureCallReply can be used to set on_done_handler that will be called when the command gets unblock. The on_done_handler gets the command reply as an input. The FutureCallReply not outlive the Context that was used to invoke the blocking command. This is because the on_done_handler must be set before the Redis GIL is released. This restriction forces it.

After setting the unblock handler, the user will get a FutureHandler object that can be use to abort the command invocation. The abort is done base on a best effort approach. And important details is that the FutureHandler must be freed when Redis GIL is held, this is why we introduce a dispose function (that gets a lock indicator) and not counting on Drop implementation.

A simple usage example:

fn call_blocking(ctx: &Context, _: Vec<RedisString>) -> RedisResult {
    // create blocking call options
    let call_options = CallOptionsBuilder::new().build_blocking();

    // call the blocking command
    let res = ctx.call_blocking("blpop", &call_options, &["list", "1"]);

    // check the reply, if its a future, block the client until the
    // future is resolved.
    match res {
        PromiseCallReply::Resolved(r) => r.map_or_else(|e| Err(e.into()), |v| Ok((&v).into())),
        PromiseCallReply::Future(f) => {
            let blocked_client = ctx.block_client();
            f.set_unblock_handler(move |_ctx, reply| {
                let thread_ctx = ThreadSafeContext::with_blocked_client(blocked_client);
                thread_ctx.reply(reply.map_or_else(|e| Err(e.into()), |v| Ok((&v).into())));
            });
            Ok(RedisValue::NoReply)
        }
    }
}

Notice a nice possible improvement would be to integrate this feature with rust async await. We leave this for future PR.

Notice The PR also updates the redismodule.h file.