redis rs

redis-rs

Redis-rs é uma biblioteca redis de alto nível para Rust. Ele fornece acesso conveniente a todas as funcionalidades do Redis por meio de uma API muito flexível, mas de baixo nível. Ele usa uma característica de conversão de tipo personalizável para que qualquer operação possa retornar resultados exatamente no tipo que você espera. Isso proporciona uma experiência de desenvolvimento muito agradável.

A caixa é chamada redis e você pode depender dela via cargo:

 [dependencies]
redis = " 0.27.5 "

A documentação da biblioteca pode ser encontrada em docs.rs/redis.

Operação Básica

Para abrir uma conexão você precisa criar um cliente e então buscar uma conexão dele. No futuro haverá um pool de conexões para eles, atualmente cada conexão é separada e não em pool.

Muitos comandos são implementados através do traço Commands , mas a criação manual de comandos também é possível.

 use redis :: Commands ;

fn fetch_an_integer ( ) -> redis :: RedisResult < isize > {
    // connect to redis
    let client = redis :: Client :: open ( "redis://127.0.0.1/" ) ? ;
    let mut con = client . get_connection ( ) ? ;
    // throw away the result, just make sure it does not fail
    let _ : ( ) = con . set ( "my_key" , 42 ) ? ;
    // read back the key and return it.  Because the return value
    // from the function is a result for integer this will automatically
    // convert into one.
    con . get ( "my_key" )
}

As variáveis ​​são convertidas de e para o formato Redis para uma ampla variedade de tipos ( String , num types, tuples, Vec ). Se quiser usá-lo com seus próprios tipos, você pode implementar as características FromRedisValue e ToRedisArgs ou derivá-las com a caixa redis-macros.

Suporte assíncrono

Para habilitar clientes assíncronos, habilite o recurso relevante em seu Cargo.toml, tokio-comp para usuários tokio ou async-std-comp para usuários async-std.

 # if you use tokio
redis = { version = "0.27.5", features = ["tokio-comp"] }

# if you use async-std
redis = { version = "0.27.5", features = ["async-std-comp"] }

Suporte TLS

Para ativar o suporte TLS, você precisa usar a entrada de recurso relevante em seu Cargo.toml. Atualmente, native-tls e rustls são suportados.

Para usar native-tls :

 redis = { version = "0.27.5", features = ["tls-native-tls"] }

# if you use tokio
redis = { version = "0.27.5", features = ["tokio-native-tls-comp"] }

# if you use async-std
redis = { version = "0.27.5", features = ["async-std-native-tls-comp"] }

Para usar rustls :

 redis = { version = "0.27.5", features = ["tls-rustls"] }

# if you use tokio
redis = { version = "0.27.5", features = ["tokio-rustls-comp"] }

# if you use async-std
redis = { version = "0.27.5", features = ["async-std-rustls-comp"] }

Com rustls , você pode adicionar os seguintes sinalizadores de recursos sobre outros sinalizadores de recursos para ativar recursos adicionais:

• tls-rustls-insecure : permite conexões TLS inseguras
• tls-rustls-webpki-roots : Use webpki-roots (certificados raiz do Mozilla) em vez de certificados raiz nativos

então você poderá se conectar a uma instância redis usando o esquema de URL rediss:// :

 let client = redis :: Client :: open ( "rediss://127.0.0.1/" ) ? ;

Para ativar o modo inseguro, acrescente #insecure no final da URL:

 let client = redis :: Client :: open ( "rediss://127.0.0.1/#insecure" ) ? ;

Aviso de descontinuação: se você estava usando os recursos tls ou async-std-tls-comp , use os recursos tls-native-tls ou async-std-native-tls-comp respectivamente.

Suporte a clusters

O suporte para Redis Cluster pode ser habilitado habilitando o recurso cluster em seu Cargo.toml:

redis = { version = "0.27.5", features = [ "cluster"] }

Então você pode simplesmente usar ClusterClient , que aceita uma lista de nós disponíveis. Observe que apenas um nó no cluster precisa ser especificado ao instanciar o cliente, embora você possa especificar vários.

 use redis :: cluster :: ClusterClient ;
use redis :: Commands ;

fn fetch_an_integer ( ) -> String {
    let nodes = vec ! [ "redis://127.0.0.1/" ] ;
    let client = ClusterClient :: new ( nodes ) . unwrap ( ) ;
    let mut connection = client . get_connection ( ) . unwrap ( ) ;
    let _ : ( ) = connection . set ( "test" , "test_data" ) . unwrap ( ) ;
    let rv : String = connection . get ( "test" ) . unwrap ( ) ;
    return rv ;
}

O suporte ao cluster Async Redis pode ser habilitado habilitando o recurso cluster-async , junto com seu tempo de execução assíncrono preferido, por exemplo:

redis = { version = "0.27.5", features = [ "cluster-async", "tokio-std-comp" ] }

 use redis :: cluster :: ClusterClient ;
use redis :: AsyncCommands ;

async fn fetch_an_integer ( ) -> String {
    let nodes = vec ! [ "redis://127.0.0.1/" ] ;
    let client = ClusterClient :: new ( nodes ) . unwrap ( ) ;
    let mut connection = client . get_async_connection ( ) . await . unwrap ( ) ;
    let _ : ( ) = connection . set ( "test" , "test_data" ) . await . unwrap ( ) ;
    let rv : String = connection . get ( "test" ) . await . unwrap ( ) ;
    return rv ;
} 

Suporte JSON

O suporte para o módulo RedisJSON pode ser habilitado especificando "json" como um recurso em seu Cargo.toml.

redis = { version = "0.27.5", features = ["json"] }

Então você pode simplesmente importar o traço JsonCommands que adicionará os comandos json a todas as conexões Redis (não deve ser confundido apenas com Commands que adiciona apenas os comandos padrão)

 use redis :: Client ;
use redis :: JsonCommands ;
use redis :: RedisResult ;
use redis :: ToRedisArgs ;

// Result returns Ok(true) if the value was set
// Result returns Err(e) if there was an error with the server itself OR serde_json was unable to serialize the boolean
fn set_json_bool < P : ToRedisArgs > ( key : P , path : P , b : bool ) -> RedisResult < bool > {
    let client = Client :: open ( "redis://127.0.0.1" ) . unwrap ( ) ;
    let connection = client . get_connection ( ) . unwrap ( ) ;

    // runs `JSON.SET {key} {path} {b}`
    connection . json_set ( key , path , b ) ?
}

Para analisar os resultados, você precisará usar serde_json (ou alguma outra biblioteca json) para desserializar os resultados dos bytes. Sempre será um Vec , se nenhum resultado for encontrado no caminho será um Vec vazio. Se quiser lidar com a desserialização e o desempacotamento Vec automaticamente, você pode usar o wrapper Json da caixa redis-macros.

Desenvolvimento

Para testar redis você precisará testar com os Módulos Redis, para fazer isso você deve definir a seguinte variável de ambiente antes de executar o script de teste

• REDIS_RS_REDIS_JSON_PATH = O caminho absoluto para o módulo RedisJSON ( librejson.so para Linux ou librejson.dylib para MacOS).

• Consulte este link para acessar o módulo RedisJSON:

Se você deseja desenvolver na biblioteca, existem alguns comandos fornecidos pelo makefile:

Para construir:

 $ make

Para testar:

 $ make test

Para executar benchmarks:

 $ make bench

Para construir os documentos (requer compilador noturno, consulte ferrugem-lang/rust#43781):

 $ make docs

Recomendamos que você execute clippy antes de buscar uma mesclagem para o seu trabalho. Os fiapos podem ser bastante rígidos. Executar isso em sua própria estação de trabalho pode economizar tempo, já que o Travis CI falhará em qualquer compilação que não satisfaça clippy :

 $ cargo clippy --all-features --all --tests --examples -- -D clippy::all -D warnings

Para executar testes fuzz com afl, primeiro instale cargo-afl ( cargo install -f afl ) e depois execute:

 $ make fuzz

Se o fuzzer encontrar uma falha, para reproduzi-la, execute:

 $ cd afl//
$ cargo run --bin reproduce -- out/crashes/