[feat] Support redis call with wasm-rust

[007gzs]

Ⅰ. Describe what this PR did

Support redis call with wasm-rust

Ⅱ. Does this pull request fix one issue?

#1297
fixes #908

Ⅲ. Why don't you add test cases (unit test/integration test)?

Ⅳ. Describe how to verify it

Ⅴ. Special notes for reviews

依赖 higress-group/proxy-wasm-rust-sdk#4

[codecov-commenter]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 43.52%. Comparing base (ef31e09) to head (85129c2).
Report is 174 commits behind head on main.

Additional details and impacted files

@@            Coverage Diff             @@
##             main    #1417      +/-   ##
==========================================
+ Coverage   35.91%   43.52%   +7.61%     
==========================================
  Files          69       76       +7     
  Lines       11576    12320     +744     
==========================================
+ Hits         4157     5362    +1205     
+ Misses       7104     6622     -482     
- Partials      315      336      +21     

see 69 files with indirect coverage changes

[johnlanni]

cc @jizhuozhi @Lynskylate

[jizhuozhi]

How about use config and Function Options pattern to reduce constructors?

[007gzs]

Any suggestions on which of the following solutions should I choose?

build1:

pub struct RedisClientBuilder{
    upstream: String,
    username: Option<String>,
    password: Option<String>,
    timeout: Duration,
}
impl RedisClientBuilder {
    pub fn new(cluster: &dyn Cluster, timeout: Duration) -> Self{
        RedisClientBuilder {
            upstream: cluster.cluster_name(),
            username: None,
            password: None,
            timeout,
        }
    }
    pub fn username<T: AsRef<str>>(mut self, username: Option<T>) -> Self{
        self.username = username.map(|u| u.as_ref().to_string());
        self
    }
    pub fn password<T: AsRef<str>>(mut self, password: Option<T>) -> Self{
        self.password = password.map(|p| p.as_ref().to_string());
        self
    }
    pub fn build(self) -> RedisClient{
        RedisClient {
            upstream: self.upstream,
            username: self.username,
            password: self.password,
            timeout: self.timeout,
        }
    }
}
// use 1
let mut builder = RedisClientBuilder::new(
    &StaticIpCluster::new("redis", 80, ""),
    Duration::from_secs(5)
);
builder = builder.password(config.password.as_ref());
let c = builder.build();
// use 2
let c = RedisClientBuilder::new(
    &StaticIpCluster::new("redis", 80, ""),
    Duration::from_secs(5)
).password(config.password.as_ref()).build();

build2:

pub struct RedisClientBuilder{
    upstream: String,
    username: Option<String>,
    password: Option<String>,
    timeout: Duration,
}
impl RedisClientBuilder {
    pub fn new(cluster: &dyn Cluster, timeout: Duration) -> Self{
        RedisClientBuilder {
            upstream: cluster.cluster_name(),
            username: None,
            password: None,
            timeout,
        }
    }
    pub fn username<T: AsRef<str>>(&mut self, username: Option<T>) -> &Self{
        self.username = username.map(|u| u.as_ref().to_string());
        self
    }
    pub fn password<T: AsRef<str>>(&mut self, password: Option<T>) -> &Self{
        self.password = password.map(|p| p.as_ref().to_string());
        self
    }
    pub fn build(&self) -> RedisClient{
        RedisClient {
            upstream: self.upstream.clone(),
            username: self.username.clone(),
            password: self.password.clone(),
            timeout: self.timeout.clone(),
        }
    }
}
// use 1
let mut builder = RedisClientBuilder::new(
    &StaticIpCluster::new("redis", 80, ""),
    Duration::from_secs(5)
);
builder.password(config.password.as_ref());
let c = builder.build();
let c2 = builder.build();
// use 2
let c = RedisClientBuilder::new(
    &StaticIpCluster::new("redis", 80, ""),
    Duration::from_secs(5)
).password(config.password.as_ref()).build();

config:

pub struct RedisClientConfig{
    upstream: String,
    username: Option<String>,
    password: Option<String>,
    timeout: Duration,
}
impl RedisClientConfig {
    pub fn new(cluster: &dyn Cluster, timeout: Duration) -> Self{
        RedisClientConfig {
            upstream: cluster.cluster_name(),
            username: None,
            password: None,
            timeout,
        }
    }
    pub fn username<T: AsRef<str>>(&mut self, username: Option<T>) -> &Self{
        self.username = username.map(|u| u.as_ref().to_string());
        self
    }
    pub fn password<T: AsRef<str>>(&mut self, password: Option<T>) -> &Self{
        self.password = password.map(|p| p.as_ref().to_string());
        self
    }
}
// use
let mut builder = RedisClientConfig::new(
    &StaticIpCluster::new("redis", 80, ""),
    Duration::from_secs(5)
);
builder.password(config.password.as_ref());
let c = RedisClient::new(&builder);
let c2 = RedisClient::new(&builder);

[007gzs]

done

[jizhuozhi]

raw call could be public for some custom commends

[007gzs]

custom commends can call command function
pub fn command(&self, cmd: &Cmd, call_fn: Box<RedisValueCallbackFn>) -> Result<u32, Status>

[jizhuozhi]

As a well formated code, there should have a newline bewteen two blocks

[007gzs]

done in wasm-rust/src * rust-lang/rustfmt#4866

[jizhuozhi]

There is no need to keep new but just use default to construct, and I don't think it's a good habit that mixing different things in single PR

[007gzs]

done, I made modifications only after discovering an error with clippy during local testing

[jizhuozhi]

well, maybe we need a log level guard because format is not zero cost, and in some condition you will build a very large string but you are not consume it

[007gzs]

This may need to be implemented using macros. You can create a new issue to record it

[007gzs]

done

[jizhuozhi]

as above, well formated should keep newlines between different blocks

[007gzs]

done

[jizhuozhi]

LGTM