redis rs
Unknown
Redis-rs ist eine High-Level-Redis-Bibliothek für Rust. Es bietet bequemen Zugriff auf alle Redis-Funktionen über eine sehr flexible, aber Low-Level-API. Es verwendet ein anpassbares Typkonvertierungsmerkmal, sodass jede Operation Ergebnisse in genau dem Typ zurückgeben kann, den Sie erwarten. Dies sorgt für ein sehr angenehmes Entwicklungserlebnis.
Die Kiste heißt redis und Sie können sich per Fracht darauf verlassen:
[dependencies]
redis = " 0.27.5 "Dokumentation zur Bibliothek finden Sie unter docs.rs/redis.
Um eine Verbindung zu öffnen, müssen Sie einen Client erstellen und dann eine Verbindung von diesem abrufen. Zukünftig wird es dafür einen Verbindungspool geben, derzeit ist jede Verbindung separat und nicht gepoolt.
Viele Befehle werden über die Eigenschaft Commands implementiert, es ist jedoch auch eine manuelle Befehlserstellung möglich.
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" )
} Variablen werden für eine Vielzahl von Typen ( String , Num-Typen, Tupel, Vec<u8> ) in das und aus dem Redis-Format konvertiert. Wenn Sie es mit Ihren eigenen Typen verwenden möchten, können Sie die Merkmale FromRedisValue und ToRedisArgs implementieren oder es mit der Redis-Macros-Kiste ableiten.
Um asynchrone Clients zu aktivieren, aktivieren Sie die entsprechende Funktion in Ihrer Cargo.toml, tokio-comp für tokio-Benutzer oder async-std-comp für async-std-Benutzer.
# 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"] }
Um die TLS-Unterstützung zu aktivieren, müssen Sie den entsprechenden Feature-Eintrag in Ihrer Cargo.toml verwenden. Derzeit werden native-tls und rustls unterstützt.
So verwenden Sie 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"] }
So verwenden Sie 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"] }
Mit rustls können Sie die folgenden Feature-Flags zusätzlich zu anderen Feature-Flags hinzufügen, um zusätzliche Funktionen zu aktivieren:
tls-rustls-insecure : Unsichere TLS-Verbindungen zulassentls-rustls-webpki-roots : Verwenden Sie webpki-roots (Mozillas Stammzertifikate) anstelle von nativen Stammzertifikaten Dann sollten Sie in der Lage sein, mithilfe des URL-Schemas rediss:// eine Verbindung zu einer Redis-Instanz herzustellen:
let client = redis :: Client :: open ( "rediss://127.0.0.1/" ) ? ; Um den unsicheren Modus zu aktivieren, hängen Sie #insecure am Ende der URL an:
let client = redis :: Client :: open ( "rediss://127.0.0.1/#insecure" ) ? ; Hinweis zur veralteten Version: Wenn Sie die Funktionen tls oder async-std-tls-comp verwendet haben, verwenden Sie bitte die Funktionen tls-native-tls bzw. async-std-native-tls-comp .
Die Unterstützung für Redis-Cluster kann durch Aktivieren der cluster -Funktion in Ihrer Cargo.toml aktiviert werden:
redis = { version = "0.27.5", features = [ "cluster"] }
Dann können Sie einfach den ClusterClient verwenden, der eine Liste verfügbarer Knoten akzeptiert. Beachten Sie, dass beim Instanziieren des Clients nur ein Knoten im Cluster angegeben werden muss, Sie können jedoch auch mehrere angeben.
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 ;
} Die Unterstützung von Async Redis Cluster kann durch Aktivieren der cluster-async Funktion zusammen mit Ihrer bevorzugten Async-Laufzeit aktiviert werden, z. B.:
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 ;
} Die Unterstützung für das RedisJSON-Modul kann aktiviert werden, indem Sie „json“ als Funktion in Ihrer Cargo.toml angeben.
redis = { version = "0.27.5", features = ["json"] }
Dann können Sie einfach das JsonCommands Merkmal importieren, das die json -Befehle zu allen Redis-Verbindungen hinzufügt (nicht zu verwechseln mit „nur Commands , das nur die Standardbefehle hinzufügt).
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 ) ?
} Um die Ergebnisse zu analysieren, müssen Sie serde_json (oder eine andere JSON-Bibliothek) verwenden, um die Ergebnisse aus den Bytes zu deserialisieren. Es wird immer ein Vec sein. Wenn auf dem Pfad keine Ergebnisse gefunden wurden, ist es ein leeres Vec . Wenn Sie die Deserialisierung und Vec -Entpacken automatisch durchführen möchten, können Sie den Json Wrapper aus der Redis-Macros-Kiste verwenden.
Um redis zu testen, müssen Sie in der Lage sein, mit den Redis-Modulen zu testen. Dazu müssen Sie die folgende Umgebungsvariable festlegen, bevor Sie das Testskript ausführen
REDIS_RS_REDIS_JSON_PATH = Der absolute Pfad zum RedisJSON-Modul (entweder librejson.so für Linux oder librejson.dylib für MacOS).
Bitte klicken Sie auf diesen Link, um auf das RedisJSON-Modul zuzugreifen:
Wenn Sie auf der Bibliothek entwickeln möchten, stehen Ihnen im Makefile einige Befehle zur Verfügung:
Zu bauen:
$ make
Zum Testen:
$ make test
So führen Sie Benchmarks durch:
$ make bench
Um die Dokumente zu erstellen (nächtlicher Compiler erforderlich, siehe rust-lang/rust#43781):
$ make docs
Wir empfehlen Ihnen, clippy auszuführen, bevor Sie eine Zusammenführung für Ihre Arbeit anstreben. Die Flusen können recht streng sein. Wenn Sie dies auf Ihrer eigenen Workstation ausführen, können Sie Zeit sparen, da Travis CI bei jedem Build fehlschlägt, der clippy nicht erfüllt:
$ cargo clippy --all-features --all --tests --examples -- -D clippy::all -D warnings
Um Fuzz-Tests mit AFL auszuführen, installieren Sie zuerst Cargo-AFL ( cargo install -f afl ) und führen Sie dann Folgendes aus:
$ make fuzz
Wenn der Fuzzer einen Absturz feststellt, führen Sie Folgendes aus, um ihn zu reproduzieren:
$ cd afl/<target>/
$ cargo run --bin reproduce -- out/crashes/<crashfile>
