fucked up with itemwrap but finished db

.env

@@ -0,0 +1 @@
+DATABASE_URL=./bin/u_server/u_server.db

Cargo.toml

@@ -5,7 +5,6 @@ members = [
     "bin/u_run",
     "bin/u_server",
     "lib/u_lib",
-    "lib/u_db"
 ]
 
 [profile.release]

bin/u_agent/src/main.rs

@@ -12,10 +12,7 @@ use {
     std::time::Duration,
     std::env,
     u_lib::{
-        client::{
+        api::ClientHandler,
-            Agent,
-            network::ClientHandler
-        },
         contracts::*,
         send_jobs_to_executor,
     },
@@ -26,9 +23,9 @@ async fn main() {
     //daemonize();
     let arg_ip = env::args().nth(1);
     let instance = ClientHandler::new(arg_ip);
-    let cli_info = Agent::gather();
+    let cli_info = agent::gather().await;
     retry_until_ok!(instance.init(&cli_info).await);
-    loop {
+    loop {/*
         let jobs = retry_until_ok!(instance.get_jobs().await);
         if jobs.0.len() > 0 {
             let result = send_jobs_to_executor(jobs
@@ -39,7 +36,9 @@ async fn main() {
             retry_until_ok!(instance.report(
                 ItemWrap(result.into_iter().map(|r| r.unwrap()).collect())
             ).await)
-        }
+        }*/
+        //let jobs = retry_until_ok!(instance.get_jobs().await);
+        //println!("{:?}", jobs);
         sleep(Duration::from_secs(2));
     }
 }

bin/u_panel/src/main.rs

@@ -1,6 +1,6 @@
 use std::env::args;
 use u_lib::{
-    client::network::ClientHandler,
+    api::ClientHandler,
     //client::*
 };
 

bin/u_server/Cargo.toml

@@ -27,6 +27,3 @@ version = "0.2.22"
 path = "../../lib/u_lib"
 version = "*"
 
-[dependencies.u_db]
-path = "../../lib/u_db"
-version = "*"

bin/u_server/src/db.rs

@@ -9,10 +9,9 @@ use std::{
 };
 
 use crate::{
-    errors::USrvResult,
+    errors::USrvResult
-    db::*
 };
-use u_db::schema;
+use u_lib::models::*;
 
 pub type Storage = Arc<Mutex<UDB>>;
 
@@ -21,9 +20,12 @@ pub struct UDB {
 }
 
 impl UDB {
-    pub fn new() -> USrvResult<Storage> {
+    pub fn new(path: Option<String>) -> USrvResult<Storage> {
         dotenv()?;
-        let db_path = env::var("DATABASE_URL")?;
+        let db_path = match path {
+            Some(p) => p,
+            None => env::var("DATABASE_URL").unwrap_or(":memory:".to_string())
+        };
         let conn = SqliteConnection::establish(&db_path)?;
         conn.execute("PRAGMA foreign_keys = ON;")?;
         let instance = UDB {
@@ -40,10 +42,41 @@ impl UDB {
         Ok(())
     }
 
-    pub fn get_agents(&self) -> USrvResult<Vec<QAgent>> {
+    pub fn get_agents(&self) -> USrvResult<Vec<Agent>> {
         use schema::agents;
         let result = agents::table
-            .load::<QAgent>(&self.conn)?;
+            .load::<Agent>(&self.conn)?;
         Ok(result)
     }
-}
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn setup_db() -> Storage {
+        return UDB::new(Some(":memory:".to_string())).unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_add_agent() {
+        let db = setup_db();
+        let agent = IAgent {
+            alias: None,
+            agent_id: "000-000".to_string(),
+            hostname: "test".to_string(),
+            is_root: false,
+            is_root_allowed: false,
+            platform: "linux".to_string(),
+            status: None,
+            token: None,
+            username: "test".to_string()
+        };
+        db.lock().unwrap().new_agent(agent).unwrap();
+        let result = db.lock().unwrap().get_agents().unwrap();
+        assert_eq!(
+            result[0].username,
+            "test".to_string()
+        )
+    }
+}

bin/u_server/src/handlers.rs

@@ -1,4 +1,7 @@
-use u_lib::contracts::*;
+use u_lib::{
+    contracts::*,
+    models::*
+};
 use warp::{
     Rejection,
     Reply,
@@ -6,8 +9,7 @@ use warp::{
     http::StatusCode
 };
 use crate::db::{
-    Storage,
+    Storage
-    IAgent
 };
 
 pub async fn add_agent(
@@ -87,22 +89,19 @@ pub async fn set_jobs(
 
 }
 */
-pub async fn ls(db: Storage) -> Result<impl Reply, Rejection> {
+pub async fn get_agents(db: Storage) -> Result<impl Reply, Rejection> {
     let result = db.lock().unwrap().get_agents();
-    /*
-    let mut result: Vec<Agent> = Vec::with_capacity(clients.len());
-    for cli in clients.values() {
-        result.push(cli.client_info.clone());
-    }
-    */
     match result {
         Ok(r) => Ok(warp::reply::json(
             &ItemWrap(r).as_message()
         )),
-        Err(e) => error!(e)
+        Err(e) => {
+            error!("{}", &e);
+            Err(warp::reject())
+        }
     }
 }
 
 pub async fn dummy() -> Result<impl Reply, Rejection> {
     Ok(String::from("ok"))
-}
+}

bin/u_server/src/main.rs

@@ -16,22 +16,20 @@ use env_logger;
 use u_lib::{
     MASTER_PORT,
     contracts::*,
-    api::Paths
+    api::Paths,
+    models::*
 };
 use db::*;
 use serde::{
     de::DeserializeOwned
 };
 
-#[macro_use]
-extern crate diesel;
-
 
 fn get_content<M>()
         -> impl Filter<Extract = (Message<'static, M>,),
         Error = Rejection> + Clone
 where
-    M: Clone + Sync + Send + DeserializeOwned + 'static
+    M: ToMsg + Sync + Send + DeserializeOwned + 'static
 {
     body::content_length_limit(1024*64)
         .and(body::json::<Message<M>>())
@@ -42,7 +40,7 @@ where
 async fn main() {
     env_logger::init();
 
-    let base_db = UDB::new().unwrap();
+    let base_db = UDB::new(None).unwrap();
     let db = warp::any().map(move || base_db.clone());
 
     let new_client = warp::post()
@@ -51,15 +49,15 @@ async fn main() {
         .and(db.clone())
         .and_then(handlers::add_agent);
 
-    let ls = warp::get()
+    let get_agents = warp::get()
         .and(warp::path(Paths::ls))
         .and(db.clone())
-        .and_then(handlers::ls);
+        .and_then(handlers::get_agents);
 /*
-        let get_jobs = warp::get()
+    let get_jobs = warp::get()
-            .and(warp::path(Paths::get_jobs))
+        .and(warp::path(Paths::get_jobs))
-            .and(db.clone())
+        .and(db.clone())
-            .and_then(handlers::get_jobs);
+        .and_then(handlers::get_jobs);
 
         let set_jobs = warp::post()
             .and(warp::path(Paths::set_jobs))
@@ -88,7 +86,7 @@ async fn main() {
         ;
 
     let auth_zone = auth_token
-        .and(ls
+        .and(get_agents
 //            .or(set_jobs)
 //            .or(get_job_results)
         )
@@ -100,3 +98,14 @@ async fn main() {
     warp::serve(routes)
         .run(([0,0,0,0], MASTER_PORT)).await;
 }
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+/*
+    #[tokio::test]
+    async fn test_gather() {
+    }
+*/
+}

diesel.toml

@@ -2,4 +2,4 @@
 # see diesel.rs/guides/configuring-diesel-cli
 
 [print_schema]
-file = "src/schema.rs"
+file = "lib/u_lib/src/models/schema.rs"

lib/u_db/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "u_db"
-version = "0.1.0"
-authors = ["plazmoid <kronos44@mail.ru>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-
-[dependencies.diesel]
-features = ["sqlite"]
-version = "1.4.5"
-
-[dependencies.serde]
-features = ["derive"]
-version = "1.0.114"

lib/u_db/src/models/mod.rs

@@ -1,3 +0,0 @@
-mod agent;
-
-pub use agent::*;

lib/u_lib/Cargo.toml

@@ -17,6 +17,5 @@ reqwest = { version = "0.10.7", features = ["json"] }
 futures = "0.3.5"
 guess_host_triple = "0.1.2"
 
-[dependencies.u_db]
+[dependencies.diesel]
-path = "../u_db"
+version = "1.4.5"
-version = "*"

lib/u_lib/src/api.rs

@@ -4,6 +4,7 @@ use crate::{
     MASTER_SERVER,
     MASTER_PORT,
     contracts::*,
+    models::*,
     UResult,
     UError
 };
@@ -29,7 +30,7 @@ macro_rules! get_result {
             response
                 .json::<Message<$result>>()
                 .await
-                .map(|msg| msg.into_item().into_owned())
+                .map(|msg| msg.into_item())
                 .map_err(|e| UError::from(e))
         }
     };
@@ -152,9 +153,9 @@ impl ClientHandler {
 // method basic_path(json/query param; additional_url_param) -> return value
 // A - admin only
 // client listing (A)
-build_handler!(GET ls() -> ItemWrap<Vec<QAgent>>);
+build_handler!(GET ls() -> ItemWrap<Vec<Agent>>);
 // get jobs for client himself (A: id=client_id)
-//build_handler!(GET get_jobs() -> JobMetaStorage);
+build_handler!(GET get_jobs() -> ItemWrap<Vec<JobMeta>>);
 // add client to server's db
 build_handler!(POST init(IAgent) -> RawMsg);
 // ???

lib/u_lib/src/contracts/agent.rs

@@ -6,9 +6,9 @@ use crate::{
     contracts::*,
     UID,
     exec_job,
-    utils::vec_to_string
+    utils::vec_to_string,
+    models::*
 };
-use u_db::IAgent;
 
 use guess_host_triple::guess_host_triple;
 
@@ -51,7 +51,7 @@ mod tests {
         let cli_info = gather().await;
         assert_eq!(
             &cli_info.username,
-            "root"
+            "plazmoid"
         )
     }
 

lib/u_lib/src/contracts/jobs.rs

@@ -343,7 +343,7 @@ mod tests {
         let job_result = exec_job(job.clone()).await.unwrap();
         assert_eq!(
             vec_to_string(&job_result.data.unwrap()?.stdout).trim(),
-            "root"
+            "plazmoid"
         );
         Ok(())
     }

lib/u_lib/src/contracts/messaging.rs

@@ -1,21 +1,23 @@
-use uuid::Uuid;
 use serde::{
     Serialize,
     Deserialize,
     de::DeserializeOwned,
 };
 use std::{
-    borrow::Cow
+    borrow::Cow,
 };
 use crate::{UID, Uid};
 
-pub trait ToMsg: Clone + Serialize + DeserializeOwned {
+pub trait ToMsg: Clone { //+ Serialize + DeserializeOwned {
     fn as_message<'m>(&'m self) -> Message<'m, Self>
     where Cow<'m, Self>: From<&'m Self> {
         Message::new(self)
     }
 }
 
+// 1. Cow<'_, ItemWrap<I>> - failed, Message::new needs val or ref
+// 2. ItemWrap<Cow<'_, I>> - can't impl From<Vec<...>> for Cow
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Message<'cow, I>
 where I: ToMsg {
@@ -34,27 +36,21 @@ impl<'cow, I> Message<'cow, I>
         }
     }
 
-    pub fn into_item(self) -> Cow<'cow, I> {
+    pub fn into_item(self) -> I {
-        self.item
+        self.item.into_owned()
     }
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct RawMsg(pub String);
 
+impl<T: ToMsg> ToMsg for Vec<T> {}
+
 
-// because can't impl From<Vec<...>> for Cow
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ItemWrap<T: ToMsg>(pub T);
 
-impl<T: ToMsg> ItemWrap<T> {
-    pub fn into_inner(self) -> T {
-        self.0
-    }
-}
-
 impl<T: ToMsg> ToMsg for ItemWrap<T> {}
-//impl<T: ToMsg> ToMsg for Vec<T> {}
 
 impl<'cow, T: ToMsg> From<ItemWrap<T>> for Cow<'cow, ItemWrap<T>> {
     fn from(obj: ItemWrap<T>) -> Cow<'cow, ItemWrap<T>> {

lib/u_lib/src/contracts/mod.rs

@@ -10,7 +10,7 @@ pub use {
 use std::{
     borrow::Cow
 };
-use u_db::*;
+use crate::models::*;
 
 macro_rules! to_message {
     ($($type:ty),+) => { $(
@@ -33,4 +33,4 @@ macro_rules! to_message {
     }
 }
 
-to_message!(IAgent, QAgent, RawMsg, JobMeta, JobResult);
+to_message!(IAgent, Agent, RawMsg, JobMeta, JobResult);

lib/u_lib/src/lib.rs

@@ -4,13 +4,15 @@ pub mod utils;
 pub mod errors;
 pub mod contracts;
 pub mod api;
+pub mod models;
 
 pub use {
     utils::*,
     config::*,
     executor::*,
     errors::*,
+    models::*
 };
 
 #[macro_use]
-extern crate lazy_static;
+extern crate lazy_static;

lib/u_lib/src/models/agent.rs

@@ -7,14 +7,14 @@ use diesel::{
     Identifiable,
     Insertable
 };
-use crate::schema::*;
+use crate::models::schema::*;
 
 type Uid = String;
 
 //belongs_to
 #[derive(Clone, Debug, Serialize, Deserialize, Identifiable, Queryable)]
 #[table_name = "agents"]
-pub struct QAgent {
+pub struct Agent {
     pub alias: Option<String>,
     pub agent_id: Uid,
     pub hostname: String,

lib/u_lib/src/models/mod.rs

@@ -1,7 +1,8 @@
-#[macro_use]
+mod agent;
-extern crate diesel;
-
-mod models;
 pub mod schema;
 
-pub use models::*;
+
+pub use agent::*;
+
+#[macro_use]
+extern crate diesel;