redis rs
Unknown
Redis-rs adalah perpustakaan redis tingkat tinggi untuk Rust. Ini memberikan akses mudah ke semua fungsi Redis melalui API tingkat rendah yang sangat fleksibel. Ini menggunakan sifat konversi tipe yang dapat disesuaikan sehingga operasi apa pun dapat memberikan hasil sesuai tipe yang Anda harapkan. Hal ini memberikan pengalaman pengembangan yang sangat menyenangkan.
Peti tersebut disebut redis dan Anda dapat bergantung padanya melalui kargo:
[dependencies]
redis = " 0.27.5 "Dokumentasi perpustakaan dapat ditemukan di docs.rs/redis.
Untuk membuka koneksi, Anda perlu membuat klien dan kemudian mengambil koneksi darinya. Nantinya akan ada kumpulan koneksi untuk itu, saat ini setiap koneksi terpisah dan tidak dikumpulkan.
Banyak perintah yang diimplementasikan melalui sifat Commands tetapi pembuatan perintah manual juga dimungkinkan.
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" )
} Variabel dikonversi ke dan dari format Redis untuk berbagai tipe ( String , num tipe, tupel, Vec ). Jika Anda ingin menggunakannya dengan tipe Anda sendiri, Anda dapat mengimplementasikan sifat FromRedisValue dan ToRedisArgs , atau menurunkannya dengan peti redis-macros.
Untuk mengaktifkan klien asinkron, aktifkan fitur yang relevan di Cargo.toml Anda, tokio-comp untuk pengguna tokio atau async-std-comp untuk pengguna 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"] }
Untuk mengaktifkan dukungan TLS, Anda perlu menggunakan entri fitur yang relevan di Cargo.toml Anda. Saat ini, native-tls dan rustls didukung.
Untuk menggunakan 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"] }
Untuk menggunakan 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"] }
Dengan rustls , Anda dapat menambahkan tanda fitur berikut di atas tanda fitur lainnya untuk mengaktifkan fitur tambahan:
tls-rustls-insecure : Izinkan koneksi TLS yang tidak amantls-rustls-webpki-roots : Gunakan webpki-roots (sertifikat root Mozilla) alih-alih sertifikat root asli maka Anda seharusnya dapat terhubung ke instance redis menggunakan skema URL rediss:// :
let client = redis :: Client :: open ( "rediss://127.0.0.1/" ) ? ; Untuk mengaktifkan mode tidak aman, tambahkan #insecure di akhir URL:
let client = redis :: Client :: open ( "rediss://127.0.0.1/#insecure" ) ? ; Pemberitahuan Penghentian: Jika Anda menggunakan fitur tls atau async-std-tls-comp , silakan gunakan masing-masing fitur tls-native-tls atau async-std-native-tls-comp .
Dukungan untuk Redis Cluster dapat diaktifkan dengan mengaktifkan fitur cluster di Cargo.toml Anda:
redis = { version = "0.27.5", features = [ "cluster"] }
Kemudian Anda cukup menggunakan ClusterClient , yang menerima daftar node yang tersedia. Perhatikan bahwa hanya satu simpul dalam klaster yang perlu ditentukan saat membuat instance klien, meskipun Anda dapat menentukan beberapa simpul.
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 ;
} Dukungan Async Redis Cluster dapat diaktifkan dengan mengaktifkan fitur cluster-async , bersama dengan waktu proses async pilihan Anda, misalnya:
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 ;
} Dukungan untuk Modul RedisJSON dapat diaktifkan dengan menentukan "json" sebagai fitur di Cargo.toml Anda.
redis = { version = "0.27.5", features = ["json"] }
Kemudian Anda cukup mengimpor sifat JsonCommands yang akan menambahkan perintah json ke semua Koneksi Redis (jangan bingung dengan hanya Commands yang hanya menambahkan perintah default)
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 ) ?
} Untuk mengurai hasilnya, Anda harus menggunakan serde_json (atau lib json lainnya) untuk membatalkan serialisasi hasil dari byte. Itu akan selalu menjadi Vec , jika tidak ada hasil yang ditemukan di jalurnya, itu akan menjadi Vec kosong. Jika Anda ingin menangani deserialisasi dan pembukaan bungkus Vec secara otomatis, Anda dapat menggunakan pembungkus Json dari peti redis-macros.
Untuk menguji redis Anda harus dapat menguji dengan Modul Redis, untuk melakukan ini Anda harus mengatur variabel lingkungan berikut sebelum menjalankan skrip pengujian
REDIS_RS_REDIS_JSON_PATH = Jalur absolut ke modul RedisJSON ( librejson.so untuk Linux atau librejson.dylib untuk MacOS).
Silakan merujuk ke tautan ini untuk mengakses modul RedisJSON:
Jika ingin mengembangkan di perpustakaan ada beberapa perintah yang disediakan oleh makefile:
Untuk membangun:
$ make
Untuk menguji:
$ make test
Untuk menjalankan tolok ukur:
$ make bench
Untuk membuat dokumen (memerlukan kompiler malam hari, lihat rustic-lang/rust#43781):
$ make docs
Kami mendorong Anda untuk menjalankan clippy sebelum mencari penggabungan untuk pekerjaan Anda. Seratnya bisa sangat ketat. Menjalankan ini di stasiun kerja Anda sendiri dapat menghemat waktu Anda, karena Travis CI akan menggagalkan build apa pun yang tidak memenuhi clippy :
$ cargo clippy --all-features --all --tests --examples -- -D clippy::all -D warnings
Untuk menjalankan pengujian fuzz dengan afl, instal terlebih dahulu cargo-afl ( cargo install -f afl ), lalu jalankan:
$ make fuzz
Jika fuzzer menemukan kerusakan, untuk mereproduksinya, jalankan:
$ cd afl//
$ cargo run --bin reproduce -- out/crashes/
