Add auth actions and ensure auth setup before DDL in ConnectionBuilder

Author: ohsayan

CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All changes in this project will be noted in this file.
 
+## 0.7.2
+
+### New features
+
+- Support for authn in `ConnectionBuilder`
+- Support for `auth` actions in `Actions` and `AsyncActions`
+
+### Fixes
+
+- Ensure auth setup is done before DDL in `ConnectionBuilder`
+
+## 0.7.1
+
+### Fixes
+
+- Fixed infinite loop due to bad `Default` impl for `ConnectionBuilder`
+
 ## 0.7.0
 
 ### New features

src/actions.rs

@@ -38,18 +38,12 @@
 //! ```
 //!
 
-use crate::error::{errorstring, SkyhashError};
-use crate::types::Array;
-use crate::types::FromSkyhashBytes;
-use crate::types::SnapshotResult;
-use crate::Element;
-use crate::GetIterator;
-use crate::IntoSkyhashAction;
-use crate::IntoSkyhashBytes;
-use crate::Query;
-use crate::RespCode;
-use crate::SkyQueryResult;
-use crate::SkyResult;
+use crate::{
+    error::{errorstring, SkyhashError},
+    types::{Array, FromSkyhashBytes, RawString, SnapshotResult},
+    Element, GetIterator, IntoSkyhashAction, IntoSkyhashBytes, OriginKey, Query, RespCode,
+    SkyQueryResult, SkyResult,
+};
 
 cfg_async!(
     use crate::AsyncResult;
@@ -414,4 +408,28 @@ implement_actions! {
         }
         Element::UnsignedInt(int) => int as u64
     }
+
+    // auth
+    /// Attempt to claim the root account using the given `origin_key`. This will return the
+    /// root user token
+    fn auth_claim(origin_key: OriginKey) -> String {
+        { Query::from("auth").arg("claim").arg(RawString::from(origin_key.to_vec())) }
+        Element::String(code) => code
+    }
+    /// Attempt to authenticate using the given `user` and `token`
+    fn auth_login(user: &'s str, token: &'s str) -> () {
+        { Query::from("auth").arg("login").arg(user).arg(token) }
+        Element::RespCode(RespCode::Okay) => ()
+    }
+    /// Attempt to log out
+    fn auth_logout() -> () {
+        { Query::from("auth").arg("logout") }
+        Element::RespCode(RespCode::Okay) => ()
+    }
+    /// Attempt to restore the `user` account using the `origin_key`. This will return the new
+    /// token for the given user
+    fn auth_restore(origin_key: OriginKey, user: &'s str) -> String {
+        { Query::from("auth").arg("restore").arg(user).arg(RawString::from(origin_key.to_vec())) }
+        Element::String(tok) => tok
+    }
 }

src/lib.rs

@@ -266,6 +266,8 @@ cfg_sync!(
 pub type SkyResult<T> = Result<T, self::error::Error>;
 /// A result type for queries
 pub type SkyQueryResult = SkyResult<Element>;
+/// The origin key is used for first-time authentication and restoration of tokens
+pub type OriginKey = [u8; 40];
 
 /// A connection builder for easily building connections
 ///
@@ -300,6 +302,7 @@ pub struct ConnectionBuilder {
     port: u16,
     host: String,
     entity: String,
+    auth: Option<(String, String)>,
 }
 
 impl Default for ConnectionBuilder {
@@ -308,6 +311,7 @@ impl Default for ConnectionBuilder {
             port: 2004,
             host: "127.0.0.1".to_owned(),
             entity: "default:default".to_owned(),
+            auth: None,
         }
     }
 }
@@ -332,12 +336,20 @@ impl ConnectionBuilder {
         self.entity = entity;
         self
     }
+    /// Set the username and authentication token (defaults to no authentication)
+    pub fn set_auth(mut self, user: String, token: String) -> Self {
+        self.auth = Some((user, token));
+        self
+    }
     cfg_sync! {
         /// Get a [sync connection](sync::Connection) to the database
         pub fn get_connection(&self) -> SkyResult<sync::Connection> {
-            use crate::ddl::Ddl;
+            use crate::{ddl::Ddl, actions::Actions};
             let mut con =
                 sync::Connection::new(&self.host, self.port)?;
+            if let Some((ref user, ref token)) = self.auth {
+                con.auth_login(user, token)?;
+            }
             con.switch(&self.entity)?;
             Ok(con)
         }
@@ -347,12 +359,15 @@ impl ConnectionBuilder {
                 &self,
                 sslcert: String,
             ) -> SkyResult<sync::TlsConnection> {
-                use crate::ddl::Ddl;
+                use crate::{ddl::Ddl, actions::Actions};
                 let mut con = sync::TlsConnection::new(
                     &self.host,
                     self.port,
                     &sslcert,
                 )?;
+                if let Some((ref user, ref token)) = self.auth {
+                    con.auth_login(user, token)?;
+                }
                 con.switch(&self.entity)?;
                 Ok(con)
             }
@@ -361,9 +376,12 @@ impl ConnectionBuilder {
     cfg_async! {
         /// Get an [async connection](aio::Connection) to the database
         pub async fn get_async_connection(&self) -> SkyResult<aio::Connection> {
-            use crate::ddl::AsyncDdl;
+            use crate::{ddl::AsyncDdl, actions::AsyncActions};
             let mut con = aio::Connection::new(&self.host, self.port)
                 .await?;
+            if let Some((ref user, ref token)) = self.auth {
+                con.auth_login(user, token).await?;
+            }
             con.switch(&self.entity).await?;
             Ok(con)
         }
@@ -373,13 +391,16 @@ impl ConnectionBuilder {
                 &self,
                 sslcert: String,
             ) -> SkyResult<aio::TlsConnection> {
-                use crate::ddl::AsyncDdl;
+                use crate::{ddl::AsyncDdl, actions::AsyncActions};
                 let mut con = aio::TlsConnection::new(
                     &self.host,
                     self.port,
                     &sslcert,
                 )
                 .await?;
+                if let Some((ref user, ref token)) = self.auth {
+                    con.auth_login(user, token).await?;
+                }
                 con.switch(&self.entity).await?;
                 Ok(con)
             }