redis rs

redis-rs

Redis-rs es una biblioteca de Redis de alto nivel para Rust. Proporciona acceso conveniente a todas las funciones de Redis a través de una API muy flexible pero de bajo nivel. Utiliza un rasgo de conversión de tipo personalizable para que cualquier operación pueda devolver resultados exactamente del tipo que espera. Esto lo convierte en una experiencia de desarrollo muy agradable.

La caja se llama redis y puedes depender de ella a través de carga:

 [dependencies]
redis = " 0.27.5 "

La documentación sobre la biblioteca se puede encontrar en docs.rs/redis.

Operación básica

Para abrir una conexión, necesita crear un cliente y luego obtener una conexión de él. En el futuro habrá un grupo de conexiones para ellos; actualmente, cada conexión está separada y no agrupada.

Muchos comandos se implementan a través del rasgo Commands , pero también es posible la creación manual de comandos.

 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" )
}

Las variables se convierten hacia y desde el formato Redis para una amplia variedad de tipos ( String , num tipos, tuplas, Vec ). Si desea usarlo con sus propios tipos, puede implementar los rasgos FromRedisValue y ToRedisArgs , o derivarlo con la caja redis-macros.

Soporte asíncrono

Para habilitar clientes asincrónicos, habilite la función relevante en su Cargo.toml, tokio-comp para usuarios de tokio o async-std-comp para usuarios 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"] }

Soporte TLS

Para habilitar la compatibilidad con TLS, debe utilizar la entrada de función correspondiente en su Cargo.toml. Actualmente, se admiten native-tls y rustls .

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"] }

Con rustls , puede agregar los siguientes indicadores de funciones además de otros indicadores de funciones para habilitar funciones adicionales:

• tls-rustls-insecure : permite conexiones TLS inseguras
• tls-rustls-webpki-roots : utilice webpki-roots (certificados raíz de Mozilla) en lugar de certificados raíz nativos.

entonces deberías poder conectarte a una instancia de Redis usando el esquema de URL rediss:// :

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

Para habilitar el modo inseguro, agregue #insecure al final de la URL:

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

Aviso de obsolescencia: si estaba utilizando las funciones tls o async-std-tls-comp , utilice las funciones tls-native-tls o async-std-native-tls-comp respectivamente.

Soporte de clúster

La compatibilidad con Redis Cluster se puede habilitar habilitando la función cluster en su Cargo.toml:

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

Luego, simplemente puede usar ClusterClient , que acepta una lista de nodos disponibles. Tenga en cuenta que solo es necesario especificar un nodo en el clúster al crear una instancia del cliente, aunque puede especificar varios.

 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 ;
}

La compatibilidad con Async Redis Cluster se puede habilitar habilitando la función cluster-async , junto con su tiempo de ejecución asíncrono preferido, por ejemplo:

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 ;
} 

Soporte JSON

La compatibilidad con el módulo RedisJSON se puede habilitar especificando "json" como característica en su Cargo.toml.

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

Luego, simplemente puede importar el rasgo JsonCommands que agregará los comandos json a todas las conexiones de Redis (no debe confundirse solo con Commands , que solo agrega los comandos predeterminados)

 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 analizar los resultados, necesitará usar serde_json (o alguna otra biblioteca json) para deserializar los resultados de los bytes. Siempre será un Vec , si no se encontraron resultados en la ruta será un Vec vacío. Si desea manejar la deserialización y el desempaquetado Vec automáticamente, puede usar el contenedor Json de la caja redis-macros.

Desarrollo

Para probar redis , necesitará poder realizar pruebas con los módulos de Redis. Para ello, debe configurar la siguiente variable de entorno antes de ejecutar el script de prueba.

• REDIS_RS_REDIS_JSON_PATH = La ruta absoluta al módulo RedisJSON (ya sea librejson.so para Linux o librejson.dylib para MacOS).

• Consulte este enlace para acceder al módulo RedisJSON:

Si desea desarrollar en la biblioteca, el archivo MAKE proporciona algunos comandos:

Para construir:

 $ make

Para probar:

 $ make test

Para ejecutar puntos de referencia:

 $ make bench

Para compilar los documentos (requiere el compilador nocturno, consulte Rust-lang/rust#43781):

 $ make docs

Le recomendamos que ejecute clippy antes de buscar una combinación para su trabajo. Las pelusas pueden ser bastante estrictas. Ejecutar esto en su propia estación de trabajo puede ahorrarle tiempo, ya que Travis CI fallará en cualquier compilación que no cumpla con clippy :

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

Para ejecutar pruebas fuzz con afl, primero instale cargo-afl ( cargo install -f afl ), luego ejecute:

 $ make fuzz

Si el fuzzer encuentra un fallo, para reproducirlo ejecuta:

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