Support auth

Author: udzura

src/pool.rs

@@ -13,6 +13,7 @@ use mrubyedge::{
 };
 
 use crate::redis::{make_redis_object, RedisConn, RedisData};
+use crate::value::parse_redis_conn_params;
 
 // ---------------------------------------------------------------------------
 // Internal data types
@@ -78,25 +79,12 @@ fn make_pool_object(vm: &mut VM, pool: r2d2::Pool<redis::Client>) -> Rc<RObject>
 // RedisConnectionPool class methods
 // ---------------------------------------------------------------------------
 
-/// RedisConnectionPool.new(size: 5, timeout: 5, host: "127.0.0.1", port: 6379, tls: false)
+/// RedisConnectionPool.new(size: 5, timeout: 5, host: "127.0.0.1", port: 6379, tls: false, username: nil, password: nil)
 fn mrb_pool_new(vm: &mut VM, _args: &[Rc<RObject>]) -> Result<Rc<RObject>, Error> {
-    let mut host = "127.0.0.1".to_string();
-    let mut port: u16 = 6379;
-    let mut tls = false;
     let mut size: u32 = 5;
     let mut timeout: u64 = 5;
 
     if let Some(kwargs) = vm.get_kwargs() {
-        if let Some(h) = kwargs.get("host") {
-            host = h.as_ref().try_into()?;
-        }
-        if let Some(p) = kwargs.get("port") {
-            let p_val: i64 = p.as_ref().try_into()?;
-            port = p_val as u16;
-        }
-        if let Some(t) = kwargs.get("tls") {
-            tls = t.is_truthy();
-        }
         if let Some(s) = kwargs.get("size") {
             let s_val: i64 = s.as_ref().try_into()?;
             size = s_val as u32;
@@ -107,9 +95,8 @@ fn mrb_pool_new(vm: &mut VM, _args: &[Rc<RObject>]) -> Result<Rc<RObject>, Error
         }
     }
 
-    let scheme = if tls { "rediss" } else { "redis" };
-    let url = format!("{}://{}:{}", scheme, host, port);
-    let client = redis::Client::open(url.as_str())
+    let params = parse_redis_conn_params(vm);
+    let client = redis::Client::open(params.url.as_str())
         .map_err(|e| Error::RuntimeError(format!("Redis connection error: {}", e)))?;
     let pool = r2d2::Pool::builder()
         .max_size(size)

src/redis.rs

@@ -11,7 +11,7 @@ use mrubyedge::{
     },
 };
 
-use crate::value::{redis_value_to_robject, robject_to_redis_arg};
+use crate::value::{parse_redis_conn_params, redis_value_to_robject, robject_to_redis_arg};
 
 // ---------------------------------------------------------------------------
 // Internal data types
@@ -95,28 +95,10 @@ pub(crate) fn make_redis_object(vm: &mut VM, conn: RedisConn) -> Rc<RObject> {
 // Redis class methods
 // ---------------------------------------------------------------------------
 
-/// Redis.new(host: "127.0.0.1", port: 6379, tls: false)
+/// Redis.new(host: "127.0.0.1", port: 6379, tls: false, username: nil, password: nil)
 fn mrb_redis_new(vm: &mut VM, _args: &[Rc<RObject>]) -> Result<Rc<RObject>, Error> {
-    let mut host = "127.0.0.1".to_string();
-    let mut port: u16 = 6379;
-    let mut tls = false;
-
-    if let Some(kwargs) = vm.get_kwargs() {
-        if let Some(h) = kwargs.get("host") {
-            host = h.as_ref().try_into()?;
-        }
-        if let Some(p) = kwargs.get("port") {
-            let p_val: i64 = p.as_ref().try_into()?;
-            port = p_val as u16;
-        }
-        if let Some(t) = kwargs.get("tls") {
-            tls = t.is_truthy();
-        }
-    }
-
-    let scheme = if tls { "rediss" } else { "redis" };
-    let url = format!("{}://{}:{}", scheme, host, port);
-    let client = redis::Client::open(url.as_str())
+    let params = parse_redis_conn_params(vm);
+    let client = redis::Client::open(params.url.as_str())
         .map_err(|e| Error::RuntimeError(format!("Redis connection error: {}", e)))?;
     let conn = client
         .get_connection()

src/value.rs

@@ -2,9 +2,64 @@ use std::rc::Rc;
 
 use mrubyedge::{
     Error,
-    yamrb::value::{RObject, RValue},
+    yamrb::{value::{RObject, RValue}, vm::VM},
 };
 
+/// Common connection parameters extracted from kwargs.
+pub(crate) struct RedisConnParams {
+    pub url: String,
+}
+
+/// Extract common Redis connection kwargs (host, port, tls, username, password)
+/// and build a Redis URL.
+pub(crate) fn parse_redis_conn_params(vm: &mut VM) -> RedisConnParams {
+    let mut host = "127.0.0.1".to_string();
+    let mut port: u16 = 6379;
+    let mut tls = false;
+    let mut username: Option<String> = None;
+    let mut password: Option<String> = None;
+
+    if let Some(kwargs) = vm.get_kwargs() {
+        if let Some(h) = kwargs.get("host") {
+            if let Ok(v) = h.as_ref().try_into() {
+                host = v;
+            }
+        }
+        if let Some(p) = kwargs.get("port") {
+            if let Ok(v) = <&RObject as TryInto<i64>>::try_into(p.as_ref()) {
+                port = v as u16;
+            }
+        }
+        if let Some(t) = kwargs.get("tls") {
+            tls = t.is_truthy();
+        }
+        if let Some(u) = kwargs.get("username") {
+            if !u.is_nil() {
+                if let Ok(v) = u.as_ref().try_into() {
+                    username = Some(v);
+                }
+            }
+        }
+        if let Some(p) = kwargs.get("password") {
+            if !p.is_nil() {
+                if let Ok(v) = p.as_ref().try_into() {
+                    password = Some(v);
+                }
+            }
+        }
+    }
+
+    let scheme = if tls { "rediss" } else { "redis" };
+    let auth = match (username, password) {
+        (Some(u), Some(p)) => format!("{}:{}@", u, p),
+        (None, Some(p)) => format!(":{}@", p),
+        _ => String::new(),
+    };
+    let url = format!("{}://{}{}:{}", scheme, auth, host, port);
+
+    RedisConnParams { url }
+}
+
 pub(crate) fn redis_value_to_robject(val: redis::Value) -> Rc<RObject> {
     match val {
         redis::Value::Nil => RObject::nil().to_refcount_assigned(),