redis rs
Unknown
Redis-rs est une bibliothèque Redis de haut niveau pour Rust. Il offre un accès pratique à toutes les fonctionnalités de Redis via une API très flexible mais de bas niveau. Il utilise un trait de conversion de type personnalisable afin que toute opération puisse renvoyer des résultats uniquement dans le type que vous attendez. Cela en fait une expérience de développement très agréable.
La caisse s'appelle redis et vous pouvez en dépendre via cargo :
[dependencies]
redis = " 0.27.5 "La documentation sur la bibliothèque est disponible sur docs.rs/redis.
Pour ouvrir une connexion, vous devez créer un client puis récupérer une connexion à partir de celui-ci. À l'avenir, il y aura un pool de connexions pour ceux-ci. Actuellement, chaque connexion est séparée et non regroupée.
De nombreuses commandes sont implémentées via le trait Commands , mais la création manuelle de commandes est également possible.
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" )
} Les variables sont converties vers et depuis le format Redis pour une grande variété de types ( String , types num, tuples, Vec ). Si vous souhaitez l'utiliser avec vos propres types, vous pouvez implémenter les traits FromRedisValue et ToRedisArgs , ou le dériver avec la caisse redis-macros.
Pour activer les clients asynchrones, activez la fonctionnalité appropriée dans votre Cargo.toml, tokio-comp pour les utilisateurs de tokio ou async-std-comp pour les utilisateurs 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"] }
Pour activer la prise en charge de TLS, vous devez utiliser l'entrée de fonctionnalité appropriée dans votre Cargo.toml. Actuellement, native-tls et rustls sont pris en charge.
Pour utiliser 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"] }
Pour utiliser 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"] }
Avec rustls , vous pouvez ajouter les indicateurs de fonctionnalité suivants au-dessus d'autres indicateurs de fonctionnalité pour activer des fonctionnalités supplémentaires :
tls-rustls-insecure : Autoriser les connexions TLS non sécuriséestls-rustls-webpki-roots : Utilisez webpki-roots (les certificats racine de Mozilla) au lieu des certificats racine natifs alors vous devriez pouvoir vous connecter à une instance Redis en utilisant le schéma d'URL rediss:// :
let client = redis :: Client :: open ( "rediss://127.0.0.1/" ) ? ; Pour activer le mode non sécurisé, ajoutez #insecure à la fin de l'URL :
let client = redis :: Client :: open ( "rediss://127.0.0.1/#insecure" ) ? ; Avis de dépréciation : si vous utilisiez les fonctionnalités tls ou async-std-tls-comp , veuillez utiliser respectivement les fonctionnalités tls-native-tls ou async-std-native-tls-comp .
La prise en charge de Redis Cluster peut être activée en activant la fonctionnalité cluster dans votre Cargo.toml :
redis = { version = "0.27.5", features = [ "cluster"] }
Ensuite, vous pouvez simplement utiliser le ClusterClient , qui accepte une liste de nœuds disponibles. Notez qu'un seul nœud du cluster doit être spécifié lors de l'instanciation du client, bien que vous puissiez en spécifier plusieurs.
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 prise en charge du cluster Redis asynchrone peut être activée en activant la fonctionnalité cluster-async , ainsi que votre environnement d'exécution asynchrone préféré, par exemple :
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 ;
} La prise en charge du module RedisJSON peut être activée en spécifiant « json » comme fonctionnalité dans votre Cargo.toml.
redis = { version = "0.27.5", features = ["json"] }
Ensuite, vous pouvez simplement importer le trait JsonCommands qui ajoutera les commandes json à toutes les connexions Redis (à ne pas confondre avec uniquement Commands qui ajoutent uniquement les commandes par défaut)
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 ) ?
} Pour analyser les résultats, vous devrez utiliser serde_json (ou une autre bibliothèque json) pour désérialiser les résultats des octets. Ce sera toujours un Vec , si aucun résultat n'est trouvé sur le chemin, ce sera un Vec vide. Si vous souhaitez gérer automatiquement la désérialisation et le déballage Vec , vous pouvez utiliser le wrapper Json de la caisse redis-macros.
Pour tester redis vous devrez pouvoir tester avec les modules Redis, pour ce faire, vous devez définir la variable d'environnement suivante avant d'exécuter le script de test
REDIS_RS_REDIS_JSON_PATH = Le chemin absolu vers le module RedisJSON (soit librejson.so pour Linux, soit librejson.dylib pour MacOS).
Veuillez vous référer à ce lien pour accéder au module RedisJSON :
Si vous souhaitez développer sur la bibliothèque, quelques commandes sont fournies par le makefile :
Pour construire :
$ make
Pour tester :
$ make test
Pour exécuter des tests de performances :
$ make bench
Pour créer la documentation (nécessite un compilateur nocturne, voir rust-lang/rust#43781) :
$ make docs
Nous vous encourageons à exécuter clippy avant de rechercher une fusion pour votre travail. Les peluches peuvent être assez strictes. L'exécuter sur votre propre poste de travail peut vous faire gagner du temps, car Travis CI fera échouer toute build qui ne satisfait pas clippy :
$ cargo clippy --all-features --all --tests --examples -- -D clippy::all -D warnings
Pour exécuter des tests fuzz avec afl, installez d'abord cargo-afl ( cargo install -f afl ), puis exécutez :
$ make fuzz
Si le fuzzer détecte un crash, pour le reproduire, exécutez :
$ cd afl//
$ cargo run --bin reproduce -- out/crashes/
