เรดดิสอาร์เอส

redis-rs

Redis-rs เป็นไลบรารี Redis ระดับสูงสำหรับ Rust ช่วยให้เข้าถึงฟังก์ชัน Redis ทั้งหมดได้อย่างสะดวกสบายผ่าน API ที่ยืดหยุ่นมากแต่ระดับต่ำ ใช้ลักษณะการแปลงประเภทที่ปรับแต่งได้ เพื่อให้การดำเนินการใดๆ สามารถส่งคืนผลลัพธ์ในประเภทที่คุณคาดหวังได้ สิ่งนี้ทำให้ได้รับประสบการณ์การพัฒนาที่น่าพึงพอใจมาก

ลังนี้เรียกว่า redis และคุณสามารถพึ่งพามันได้โดยบรรทุกสินค้า:

 [dependencies]
redis = " 0.27.5 "

สามารถดูเอกสารประกอบเกี่ยวกับห้องสมุดได้ที่ docs.rs/redis

การทำงานขั้นพื้นฐาน

หากต้องการเปิดการเชื่อมต่อ คุณต้องสร้างไคลเอนต์ จากนั้นจึงดึงการเชื่อมต่อจากไคลเอ็นต์นั้น ในอนาคตจะมีกลุ่มการเชื่อมต่อสำหรับสิ่งเหล่านั้น ปัจจุบันการเชื่อมต่อแต่ละอย่างจะแยกจากกันและไม่ได้รวมกลุ่มกัน

คำสั่งจำนวนมากถูกนำมาใช้ผ่านลักษณะ Commands แต่การสร้างคำสั่งด้วยตนเองก็สามารถทำได้เช่นกัน

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

ตัวแปรจะถูกแปลงเป็นและจากรูปแบบ Redis สำหรับประเภทที่หลากหลาย ( String , ประเภท num, tuples, Vec ) หากคุณต้องการใช้กับประเภทของคุณเอง คุณสามารถใช้คุณลักษณะ FromRedisValue และ ToRedisArgs หรือรับมาด้วยลัง Redis-Macros

การสนับสนุนแบบอะซิงโครนัส

หากต้องการเปิดใช้งานไคลเอนต์แบบอะซิงโครนัส ให้เปิดใช้งานคุณสมบัติที่เกี่ยวข้องใน Cargo.toml, tokio-comp สำหรับผู้ใช้ tokio หรือ async-std-comp สำหรับผู้ใช้ 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"] }

การสนับสนุน TLS

หากต้องการเปิดใช้งานการรองรับ TLS คุณต้องใช้รายการคุณสมบัติที่เกี่ยวข้องใน Cargo.toml ของคุณ ปัจจุบันรองรับ native-tls และ rustls

วิธีใช้ 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"] }

วิธีใช้ 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"] }

ด้วย rustls คุณสามารถเพิ่มแฟล็กคุณลักษณะต่อไปนี้ที่ด้านบนของแฟล็กคุณลักษณะอื่นๆ เพื่อเปิดใช้งานคุณลักษณะเพิ่มเติม:

• tls-rustls-insecure : อนุญาตการเชื่อมต่อ TLS ที่ไม่ปลอดภัย
• tls-rustls-webpki-roots : ใช้ webpki-roots (ใบรับรองหลักของ Mozilla) แทนใบรับรองหลักดั้งเดิม

จากนั้นคุณควรจะสามารถเชื่อมต่อกับอินสแตนซ์ Redis ได้โดยใช้รูปแบบ rediss:// URL:

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

หากต้องการเปิดใช้งานโหมดไม่ปลอดภัย ให้เติม #insecure ต่อท้าย URL:

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

ประกาศการเลิกใช้งาน: หากคุณใช้คุณสมบัติ tls หรือ async-std-tls-comp โปรดใช้คุณสมบัติ tls-native-tls หรือ async-std-native-tls-comp ตามลำดับ

การสนับสนุนคลัสเตอร์

คุณสามารถเปิดใช้งานการรองรับ Redis Cluster ได้โดยเปิดใช้งานฟีเจอร์ cluster ใน Cargo.toml ของคุณ:

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

จากนั้นคุณสามารถใช้ ClusterClient ซึ่งยอมรับรายการโหนดที่มีอยู่ โปรดทราบว่าจำเป็นต้องระบุเพียงโหนดเดียวในคลัสเตอร์เมื่อสร้างอินสแตนซ์ไคลเอ็นต์ แม้ว่าคุณจะสามารถระบุได้หลายโหนดก็ตาม

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

คุณสามารถเปิดใช้งานการสนับสนุน Async Redis Cluster ได้โดยเปิดใช้งานคุณสมบัติ cluster-async พร้อมกับรันไทม์อะซิงก์ที่คุณต้องการ เช่น:

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

การสนับสนุน JSON

สามารถเปิดใช้งานการรองรับโมดูล RedisJSON ได้โดยการระบุ "json" เป็นคุณสมบัติใน Cargo.toml ของคุณ

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

จากนั้นคุณก็สามารถนำเข้าลักษณะ JsonCommands ซึ่งจะเพิ่มคำสั่ง json ให้กับการเชื่อมต่อ Redis ทั้งหมด (อย่าสับสนกับเพียง Commands ที่เพิ่มเฉพาะคำสั่งเริ่มต้นเท่านั้น)

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

หากต้องการแยกวิเคราะห์ผลลัพธ์ คุณจะต้องใช้ serde_json (หรือ json lib อื่นๆ) เพื่อดีซีเรียลไลซ์ผลลัพธ์จากไบต์ มันจะเป็น Vec เสมอ หากไม่พบผลลัพธ์ที่เส้นทาง มันก็จะเป็น Vec ที่ว่างเปล่า หากคุณต้องการจัดการการดีซีเรียลไลซ์และการคลาย Vec โดยอัตโนมัติ คุณสามารถใช้ตัวห่อ Json จากลัง Redis-Macros

การพัฒนา

ในการทดสอบ redis คุณจะต้องทดสอบกับโมดูล Redis ได้ โดยในการดำเนินการนี้ คุณต้องตั้งค่าตัวแปรสภาพแวดล้อมต่อไปนี้ก่อนที่จะรันสคริปต์ทดสอบ

• REDIS_RS_REDIS_JSON_PATH = พาธสัมบูรณ์ไปยังโมดูล RedisJSON (ไม่ว่าจะเป็น librejson.so สำหรับ Linux หรือ librejson.dylib สำหรับ MacOS)

• โปรดดูลิงก์นี้เพื่อเข้าถึงโมดูล RedisJSON:

หากคุณต้องการพัฒนาบนไลบรารี่ makefile จะมีคำสั่งบางส่วนมาให้:

วิธีสร้าง:

 $ make

วิธีทดสอบ:

 $ make test

หากต้องการเรียกใช้การวัดประสิทธิภาพ:

 $ make bench

หากต้องการสร้างเอกสาร (ต้องใช้คอมไพเลอร์ทุกคืน ดูที่rust-lang/rust#43781):

 $ make docs

เราขอแนะนำให้คุณเรียกใช้ clippy ก่อนที่จะค้นหาการรวมงานของคุณ ผ้าสำลีอาจค่อนข้างเข้มงวด การรันสิ่งนี้บนเวิร์กสเตชันของคุณเองสามารถช่วยประหยัดเวลาได้ เนื่องจาก Travis CI จะทำให้บิลด์ใดๆ ที่ไม่เป็นไปตามข้อกำหนดของ clippy ล้มเหลว:

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

หากต้องการรันการทดสอบ fuzz ด้วย afl ให้ติดตั้ง cargo-afl ( cargo install -f afl ) ก่อน จากนั้นจึงรัน:

 $ make fuzz

หาก fuzzer พบข้อขัดข้อง ให้รัน:

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