Switch to rust-url and added support for password based authentication.

This fixes redis-rs#11

Author: mitsuhiko

Cargo.toml

@@ -6,6 +6,9 @@ authors = ["Armin Ronacher <armin.ronacher@active-4.com>"]
 [dependencies.rust-crypto]
 git = "https://github.com/DaGenix/rust-crypto.git"
 
+[dependencies.url]
+git = "https://github.com/servo/rust-url"
+
 [lib]
 name = "redis"
 path = "src/redis/lib.rs"

src/redis/client.rs

@@ -1,14 +1,11 @@
-use url::Url;
-
-use connection::{Connection, connect, PubSub, connect_pubsub, ConnectionLike};
-use types::{RedisResult, Value, Error, InvalidClientConfig};
+use connection::{ConnectionInfo, IntoConnectionInfo, Connection, connect,
+                 PubSub, connect_pubsub, ConnectionLike};
+use types::{RedisResult, Value};
 
 
 /// The client type.
 pub struct Client {
-    host: String,
-    port: u16,
-    db: i64,
+    connection_info: ConnectionInfo,
 }
 
 /// The client acts as connector to the redis server.  By itself it does not
@@ -32,20 +29,9 @@ impl Client {
     /// Connects to a redis server and returns a client.  This does not
     /// actually open a connection yet but it does perform some basic
     /// checks on the URL that might make the operation fail.
-    pub fn open(uri: &str) -> RedisResult<Client> {
-        let u = unwrap_or!(from_str::<Url>(uri), return Err(Error::simple(
-            InvalidClientConfig, "Redis URL did not parse")));
-        ensure!(u.scheme.as_slice() == "redis", Err(Error::simple(
-            InvalidClientConfig, "URL provided is not a redis URL")));
-
+    pub fn open<T: IntoConnectionInfo>(params: T) -> RedisResult<Client> {
         Ok(Client {
-            host: u.host,
-            port: u.port.unwrap_or(6379),
-            db: match u.path.to_string().as_slice().trim_chars('/') {
-                "" => 0,
-                path => unwrap_or!(from_str::<i64>(path), return Err(Error::simple(
-                    InvalidClientConfig, "Path is not a valid redis database number")))
-            },
+            connection_info: try!(params.into_connection_info())
         })
     }
 
@@ -55,7 +41,7 @@ impl Client {
     /// (like unreachable host) so it's important that you handle those
     /// errors.
     pub fn get_connection(&self) -> RedisResult<Connection> {
-        Ok(try_io!(connect(self.host.as_slice(), self.port, self.db)))
+        Ok(try_io!(connect(&self.connection_info)))
     }
 
     /// Returns a PubSub connection.  A pubsub connection can be used to
@@ -64,7 +50,7 @@ impl Client {
     ///
     /// Note that redis' pubsub operates across all databases.
     pub fn get_pubsub(&self) -> RedisResult<PubSub> {
-        Ok(try_io!(connect_pubsub(self.host.as_slice(), self.port)))
+        Ok(try_io!(connect_pubsub(&self.connection_info)))
     }
 }
 
@@ -80,6 +66,6 @@ impl ConnectionLike for Client {
     }
 
     fn get_db(&self) -> i64 {
-        self.db
+        self.connection_info.db
     }
 }

src/redis/connection.rs

@@ -4,12 +4,99 @@ use std::cell::RefCell;
 use std::collections::HashSet;
 use std::str;
 
+use url;
+
 use cmd::{cmd, pipe, Pipeline};
 use types::{RedisResult, Okay, Error, Value, Data, Nil, InternalIoError,
-            ToRedisArgs, FromRedisValue, from_redis_value};
+            ToRedisArgs, FromRedisValue, from_redis_value,
+            InvalidClientConfig};
 use parser::Parser;
 
 
+static DEFAULT_PORT: u16 = 6370;
+
+fn redis_scheme_type_mapper(scheme: &str) -> url::SchemeType {
+    match scheme {
+        "redis" => url::RelativeScheme(DEFAULT_PORT),
+        _ => url::NonRelativeScheme,
+    }
+}
+
+/// This function takes a redis URL string and parses it into a URL
+/// as used by rust-url.  This is necessary as the default parser does
+/// not understand how redis URLs function.
+pub fn parse_redis_url(input: &str) -> url::ParseResult<url::Url> {
+    let mut parser = url::UrlParser::new();
+    parser.scheme_type_mapper(redis_scheme_type_mapper);
+    match parser.parse(input) {
+        Ok(result) => {
+            if result.scheme.as_slice() != "redis" {
+                Err(url::InvalidScheme)
+            } else {
+                Ok(result)
+            }
+        },
+        Err(err) => Err(err),
+    }
+}
+
+
+/// Holds the connection information that redis should use for connecting.
+pub struct ConnectionInfo {
+    pub host: String,
+    pub port: u16,
+    pub db: i64,
+    pub passwd: Option<String>,
+}
+
+/// Converts an object into a connection info struct.  This allows the
+/// constructor of the client to accept connection information in a
+/// range of different formats.
+pub trait IntoConnectionInfo {
+    fn into_connection_info(self) -> RedisResult<ConnectionInfo>;
+}
+
+impl IntoConnectionInfo for ConnectionInfo {
+    fn into_connection_info(self) -> RedisResult<ConnectionInfo> {
+        Ok(self)
+    }
+}
+
+impl<'a> IntoConnectionInfo for &'a str {
+    fn into_connection_info(self) -> RedisResult<ConnectionInfo> {
+        match parse_redis_url(self) {
+            Ok(u) => u.into_connection_info(),
+            Err(_) => Err(Error::simple(
+                InvalidClientConfig, "Redis URL did not parse")),
+        }
+    }
+}
+
+impl IntoConnectionInfo for url::Url {
+    fn into_connection_info(self) -> RedisResult<ConnectionInfo> {
+        ensure!(self.scheme.as_slice() == "redis", Err(Error::simple(
+            InvalidClientConfig, "URL provided is not a redis URL")));
+
+        println!("{}", self);
+
+        Ok(ConnectionInfo {
+            host: unwrap_or!(self.serialize_host(),
+                    return Err(Error::simple(InvalidClientConfig,
+                        "Missing hostname"))),
+            port: self.port().unwrap_or(DEFAULT_PORT),
+            db: match self.serialize_path().unwrap_or("".to_string())
+                    .as_slice().trim_chars('/') {
+                "" => 0,
+                path => unwrap_or!(from_str::<i64>(path),
+                    return Err(Error::simple(InvalidClientConfig,
+                        "Path is not a valid redis database number")))
+            },
+            passwd: self.password().and_then(|pw| Some(pw.to_string())),
+        })
+    }
+}
+
+
 struct ActualConnection {
     sock: TcpStream,
 }
@@ -60,11 +147,13 @@ impl ActualConnection {
 }
 
 
-pub fn connect(host: &str, port: u16, db: i64) -> IoResult<Connection> {
-    let con = try!(ActualConnection::new(host, port));
-    let rv = Connection { con: RefCell::new(con), db: db };
-    if db != 0 {
-        match cmd("SELECT").arg(db).query::<Value>(&rv) {
+pub fn connect(connection_info: &ConnectionInfo) -> IoResult<Connection> {
+    let con = try!(ActualConnection::new(
+        connection_info.host[], connection_info.port));
+    let rv = Connection { con: RefCell::new(con), db: connection_info.db };
+
+    if connection_info.db != 0 {
+        match cmd("SELECT").arg(connection_info.db).query::<Value>(&rv) {
             Ok(Okay) => {}
             _ => { return Err(IoError {
                 kind: ConnectionFailed,
@@ -73,12 +162,27 @@ pub fn connect(host: &str, port: u16, db: i64) -> IoResult<Connection> {
             }); }
         }
     }
+
+    match connection_info.passwd {
+        Some(ref passwd) => {
+            match cmd("AUTH").arg(passwd[]).query::<Value>(&rv) {
+                Ok(Okay) => {}
+                _ => { return Err(IoError {
+                    kind: ConnectionFailed,
+                    desc: "Password authentication failed",
+                    detail: None,
+                }); }
+            }
+        },
+        None => {},
+    }
+
     Ok(rv)
 }
 
-pub fn connect_pubsub(host: &str, port: u16) -> IoResult<PubSub> {
+pub fn connect_pubsub(connection_info: &ConnectionInfo) -> IoResult<PubSub> {
     Ok(PubSub {
-        con: try!(connect(host, port, 0)),
+        con: try!(connect(connection_info)),
         channels: HashSet::new(),
         pchannels: HashSet::new(),
     })

src/redis/lib.rs

@@ -256,7 +256,8 @@ extern crate "rust-crypto" as crypto;
 pub use parser::{parse_redis_value, Parser};
 pub use client::Client;
 pub use script::{Script, ScriptInvocation};
-pub use connection::{Connection, ConnectionLike, PubSub, Msg, transaction};
+pub use connection::{Connection, ConnectionLike, ConnectionInfo,
+                     IntoConnectionInfo, PubSub, Msg, transaction};
 pub use cmd::{cmd, Cmd, pipe, Pipeline, Iter, pack_command};
 pub use commands::{
     Commands,