Basic multi-user UI. r=fabrice (#505)

Basic multi-user UI. r=fabrice

* Address nit s/to_owned/String::from

Author: ferjm

Cargo.lock

@@ -28,7 +28,7 @@ foxbox_taxonomy = { path = "components/taxonomy/" }
 openzwave-adapter = { path = "components/openzwave-adapter/" }
 tls = { path = "components/tls/" }
 
-foxbox_users = { git = "https://github.com/fxbox/users.git", rev = "d4e5277" }
+foxbox_users = { git = "https://github.com/fxbox/users.git", rev = "ec53c3a" }
 iron-cors = { git = "https://github.com/fxbox/iron-cors.git", rev = "f397cd2" }
 multicast_dns = { git = "https://github.com/fxbox/multicast-dns.git", rev = "a6e4bcc" }
 

Cargo.toml

@@ -17,7 +17,7 @@ features = ["ssl"]
 
 [dependencies]
 clippy = "0.0.71"
-foxbox_users = { git = "https://github.com/fxbox/users.git", rev = "d4e5277" }
+foxbox_users = { git = "https://github.com/fxbox/users.git", rev = "ec53c3a" }
 hyper = "0.8.1"
 libc = "0.2.7"
 log = "0.3"

components/core/Cargo.toml

@@ -224,13 +224,13 @@ pub enum WatchEvent {
 #[derive(Debug, Clone, PartialEq)]
 pub enum User {
     None,
-    Id(i32)
+    Id(String)
 }
 
 #[test]
 fn test_user_partialeq() {
     assert_eq!(User::None, User::None);
-    assert_eq!(User::Id(1), User::Id(1));
+    assert_eq!(User::Id(String::from("1")), User::Id(String::from("1")));
 }
 
 impl<K> Parser<Targetted<K, Payload>> for Targetted<K, Payload> where K: Parser<K> + Clone {

components/taxonomy/src/api.rs

@@ -64,7 +64,7 @@ impl<Env, T> ScriptManager<Env, T>
     ///   id, // Record identifier. Primary key.
     ///   source, // Script source. Defines the behavior of the rule.
     ///   is_enabled, // Boolean flag that indicates if the rule is enabled or disabled.
-    ///   owner // User identifier (i32) of the owner of the rule. Defaults to no user (-1).
+    ///   owner // User identifier (String) of the owner of the rule. Defaults to no user.
     /// }
     ///
     /// The database stores the raw script source, but only after the source has been parsed
@@ -76,7 +76,7 @@ impl<Env, T> ScriptManager<Env, T>
             id          TEXT NOT NULL PRIMARY KEY,
             source      TEXT NOT NULL,
             is_enabled  BOOL NOT NULL DEFAULT 1,
-            owner       INTEGER NOT NULL DEFAULT -1
+            owner       TEXT
         )", &[]));
 
         Ok(ScriptManager {
@@ -100,10 +100,11 @@ impl<Env, T> ScriptManager<Env, T>
             let id: Id<ScriptId> = Id::new(&id_string);
             let source: String = try!(row.get_checked(1));
             let is_enabled: bool = try!(row.get_checked(2));
-            let owner_value: i32 = try!(row.get_checked(3));
-            let owner: User = match owner_value {
-                -1 => User::None,
-                _ => User::Id(owner_value)
+            let owner_value: String = try!(row.get_checked(3));
+            let owner: User = if owner_value.is_empty() {
+                User::None
+            } else {
+                User::Id(owner_value)
             };
 
             if is_enabled {
@@ -120,15 +121,15 @@ impl<Env, T> ScriptManager<Env, T>
     /// Attempt to add a new script.
     /// The script will be executed and persisted to disk.
     /// The ID is chosen by the consumer and must be unique.
-    /// The script may have (User::Id(i32)) or may not have a owner (User::None).
+    /// The script may have (User::Id(String)) or may not have a owner (User::None).
     /// If the script has owner, this value will be propagated to Thinkerbell's
     /// adapter.
     pub fn put(&mut self, id: &Id<ScriptId>, source: &String, owner: &User) -> Result<(), Error> {
         try!(self.start_script(&id, &source, &owner));
 
-        let owner_value: i32 = match *owner {
-            User::Id(id) => id,
-            User::None => -1
+        let owner_value: String = match *owner {
+            User::Id(ref id) => id.clone(),
+            User::None       => String::from("")
         };
 
         let connection = try!(rusqlite::Connection::open(&self.path));
@@ -215,10 +216,11 @@ impl<Env, T> ScriptManager<Env, T>
         let mut rows = try!(stmt.query(&[&id.to_string()]));
         let first_row = try!(try!(rows.nth(0).ok_or(Error::NoSuchScriptError)));
         let source = try!(first_row.get_checked(0));
-        let owner_value = try!(first_row.get_checked(1));
-        let owner = match owner_value {
-            -1 => User::None,
-            _ => User::Id(owner_value)
+        let owner_value: String = try!(first_row.get_checked(1));
+        let owner = if owner_value.is_empty() {
+            User::None
+        } else {
+            User::Id(owner_value)
         };
         Ok((source, owner))
     }

components/thinkerbell/src/manager.rs

@@ -40,13 +40,13 @@ fn test_database_add_remove_script() {
 
     println!("* Putting a recipe in the database. It should be reported as running.");
     let name = Id::<ScriptId>::new("Sample Ruleset");
-    db.put(&name, &load_json("./examples/ruleset.json"), &User::Id(1)).unwrap();
+    db.put(&name, &load_json("./examples/ruleset.json"), &User::Id(String::from("1"))).unwrap();
     assert_eq!(db.get_running_count(), 1);
 
 
     println!("* The recipe should have the user with which it was stored.");
     let (_, owner) = db.get_source_and_owner(&name).unwrap();
-    assert_eq!(owner, User::Id(1));
+    assert_eq!(owner, User::Id(String::from("1")));
 
     println!("* Enable the recipe again. It should still be reported as running.");
     db.set_enabled(&name, true).unwrap();
@@ -65,10 +65,10 @@ fn test_database_add_remove_script() {
     assert_eq!(db.get_running_count(), 0);
 
     println!("* Add again the recipe. It should be reported as running again.");
-    db.put(&name, &load_json("./examples/ruleset.json"), &User::Id(1)).unwrap();
+    db.put(&name, &load_json("./examples/ruleset.json"), &User::Id(String::from("1"))).unwrap();
     assert_eq!(db.get_running_count(), 1);
 
     println!("* Overwrite the recipe. It should still be reported as running.");
-    db.put(&name, &load_json("./examples/ruleset.json"), &User::Id(1)).unwrap();
+    db.put(&name, &load_json("./examples/ruleset.json"), &User::Id(String::from("1"))).unwrap();
     assert_eq!(db.get_running_count(), 1);
 }

components/thinkerbell/tests/test_manager.rs

@@ -18,6 +18,7 @@
 //! issued a push notification on each of their subscriptions.
 //!
 
+use foxbox_taxonomy::api::User;
 use super::Subscription;
 use libc::c_int;
 use rusqlite::{ self, Connection };
@@ -34,6 +35,13 @@ fn escape_option(opt: &Option<String>) -> Option<String> {
     };
 }
 
+fn user_to_str(user: &User) -> String {
+    match *user {
+        User::Id(ref user)  => user.clone(),
+        User::None          => String::from("")
+    }
+}
+
 pub struct WebPushDb {
     db: Connection,
 }
@@ -43,14 +51,14 @@ impl WebPushDb {
     pub fn new(path: &str) -> Self {
         let db = Connection::open(path).unwrap();
         db.execute("CREATE TABLE IF NOT EXISTS subscriptions (
-                    user_id     INTEGER,
+                    user_id     TEXT,
                     push_uri    TEXT NOT NULL UNIQUE,
                     public_key  TEXT NOT NULL,
                     auth        TEXT
             )", &[]).unwrap();
 
         db.execute("CREATE TABLE IF NOT EXISTS resources (
-                    user_id     INTEGER,
+                    user_id     TEXT,
                     resource    TEXT NOT NULL
             )", &[]).unwrap();
 
@@ -60,35 +68,36 @@ impl WebPushDb {
     }
 
     /// Adds a new push subscription `sub` bound to the user `user_id`.
-    pub fn subscribe(&self, user_id: i32, sub: &Subscription) -> rusqlite::Result<c_int> {
+    pub fn subscribe(&self, user_id: &User, sub: &Subscription) -> rusqlite::Result<c_int> {
         self.db.execute("INSERT INTO subscriptions VALUES ($1, $2, $3, $4)",
-                        &[&user_id, &escape(&sub.push_uri), &escape(&sub.public_key), &escape_option(&sub.auth)]
+                        &[&escape(&user_to_str(user_id)), &escape(&sub.push_uri), &escape(&sub.public_key), &escape_option(&sub.auth)]
         )
     }
 
     /// Removes an existing push subscription identified by `push_uri`.
-    pub fn unsubscribe(&self, _: i32, push_uri: &str) -> rusqlite::Result<c_int> {
+    pub fn unsubscribe(&self, _: &User, push_uri: &str) -> rusqlite::Result<c_int> {
         self.db.execute("DELETE FROM subscriptions WHERE push_uri=$1",
                         &[&escape(push_uri)]
         )
     }
 
     /// Sets the resources to subscribe to notifications for the user `user_id`.
-    pub fn set_resources(&self, user_id: i32, resources: &[String]) -> rusqlite::Result<()> {
-        try!(self.db.execute("DELETE FROM resources WHERE user_id=$1", &[&user_id]));
+    pub fn set_resources(&self, user_id: &User, resources: &[String]) -> rusqlite::Result<()> {
+        try!(self.db.execute("DELETE FROM resources WHERE user_id=$1",
+                             &[&user_to_str(user_id)]));
         for resource in resources.iter() {
             try!(self.db.execute("INSERT INTO resources VALUES ($1, $2)",
-                                 &[&user_id, &escape(resource)]
+                                 &[&escape(&user_to_str(user_id)), &escape(resource)]
             ));
         }
         Ok(())
     }
 
     /// Gets the resources subscribed to by the user `user_id`.
-    pub fn get_resources(&self, user_id: i32) -> rusqlite::Result<Vec<String>> {
+    pub fn get_resources(&self, user_id: &User) -> rusqlite::Result<Vec<String>> {
         let mut subs = Vec::new();
         let mut stmt = try!(self.db.prepare("SELECT resource FROM resources WHERE user_id=$1"));
-        let rows = try!(stmt.query(&[&user_id]));
+        let rows = try!(stmt.query(&[&user_to_str(user_id)]));
         let (count, _) = rows.size_hint();
         subs.reserve_exact(count);
         for result_row in rows {
@@ -99,10 +108,10 @@ impl WebPushDb {
     }
 
     /// Gets the push subscriptions for the user `user_id`.
-    pub fn get_subscriptions(&self, user_id: i32) -> rusqlite::Result<Vec<Subscription>> {
+    pub fn get_subscriptions(&self, user_id: &User) -> rusqlite::Result<Vec<Subscription>> {
         let mut subs = Vec::new();
         let mut stmt = try!(self.db.prepare("SELECT push_uri, public_key, auth FROM subscriptions WHERE user_id=$1"));
-        let rows = try!(stmt.query(&[&user_id]));
+        let rows = try!(stmt.query(&[&user_to_str(user_id)]));
         let (count, _) = rows.size_hint();
         subs.reserve_exact(count);
         for result_row in rows {
@@ -159,64 +168,65 @@ pub fn remove_test_db() {
 #[cfg(test)]
 describe! tests {
     before_each {
+        use foxbox_taxonomy::api::User;
         let db = WebPushDb::new(&get_db_environment());
     }
 
     it "should manage subscription correctly" {
         use super::super::Subscription;
 
-        let subs0 = db.get_subscriptions(1).unwrap();
+        let subs0 = db.get_subscriptions(&User::Id(String::from("1"))).unwrap();
         assert_eq!(subs0.len(), 0);
 
         let sub = Subscription {
             push_uri: "test_push_uri".to_owned(),
             public_key: "test_public_key".to_owned(),
             auth: Some("test_auth".to_owned())
         };
-        db.subscribe(1, &sub).unwrap();
+        db.subscribe(&User::Id(String::from("1")), &sub).unwrap();
 
-        let subs1 = db.get_subscriptions(1).unwrap();
+        let subs1 = db.get_subscriptions(&User::Id(String::from("1"))).unwrap();
         assert_eq!(subs1.len(), 1);
         assert_eq!(subs1[0], sub);
 
-        db.unsubscribe(1, &sub.push_uri).unwrap();
+        db.unsubscribe(&User::Id(String::from("1")), &sub.push_uri).unwrap();
 
-        let subs2 = db.get_subscriptions(1).unwrap();
+        let subs2 = db.get_subscriptions(&User::Id(String::from("1"))).unwrap();
         assert_eq!(subs2.len(), 0);
     }
 
     it "should manage resources correctly" {
-        let res0 = db.get_resources(1).unwrap();
+        let res0 = db.get_resources(&User::Id(String::from("1"))).unwrap();
         assert_eq!(res0.len(), 0);
 
         let res = vec!["resource1".to_owned(), "resource2".to_owned()];
-        db.set_resources(1, &res).unwrap();
+        db.set_resources(&User::Id(String::from("1")), &res).unwrap();
 
-        let res1 = db.get_resources(1).unwrap();
+        let res1 = db.get_resources(&User::Id(String::from("1"))).unwrap();
         assert_eq!(res1.len(), 2);
         assert_eq!(res1[0], "resource1".to_owned());
         assert_eq!(res1[1], "resource2".to_owned());
 
-        db.set_resources(1, &[]).unwrap();
+        db.set_resources(&User::Id(String::from("1")), &[]).unwrap();
 
-        let res2 = db.get_resources(1).unwrap();
+        let res2 = db.get_resources(&User::Id(String::from("1"))).unwrap();
         assert_eq!(res2.len(), 0);
     }
 
     it "should yield subscriptions given a resource" {
         use super::super::Subscription;
 
-        db.subscribe(1, &Subscription {
+        db.subscribe(&User::Id(String::from("1")), &Subscription {
             push_uri: "u1_sub0_puri".to_owned(),
             public_key: "u1_sub0_pkey".to_owned(),
             auth: Some("u1_sub0_auth".to_owned())
         }).unwrap();
-        db.subscribe(1, &Subscription {
+        db.subscribe(&User::Id(String::from("1")), &Subscription {
             push_uri: "u1_sub1_puri".to_owned(),
             public_key: "u1_sub1_pkey".to_owned(),
             auth: None
         }).unwrap();
-        db.subscribe(2, &Subscription {
+        db.subscribe(&User::Id(String::from("2")), &Subscription {
             push_uri: "u2_sub0_puri".to_owned(),
             public_key: "u2_sub0_pkey".to_owned(),
             auth: Some("u2_sub0_auth".to_owned())
@@ -226,11 +236,11 @@ describe! tests {
             public_key: "u3_sub0_pkey".to_owned(),
             auth: Some("u3_sub0_auth".to_owned())
         };
-        db.subscribe(3, &u3_sub0).unwrap();
+        db.subscribe(&User::Id(String::from("3")), &u3_sub0).unwrap();
 
-        db.set_resources(1, &["res1".to_owned()]).unwrap();
-        db.set_resources(2, &["res1".to_owned(), "res2".to_owned()]).unwrap();
-        db.set_resources(3, &["res2".to_owned(), "res3".to_owned()]).unwrap();
+        db.set_resources(&User::Id(String::from("1")), &["res1".to_owned()]).unwrap();
+        db.set_resources(&User::Id(String::from("2")), &["res1".to_owned(), "res2".to_owned()]).unwrap();
+        db.set_resources(&User::Id(String::from("3")), &["res2".to_owned(), "res3".to_owned()]).unwrap();
 
         let subs1 = db.get_resource_subscriptions("res1").unwrap();
         assert_eq!(subs1.len(), 3);