move assert_msg from common/misc/ to common/message/

- remove src/libtrader/network/cmd folder entirely
- add investigate log discrepancy between server and client to todo
  board

src/libtrader/client/account/authorization.rs

@@ -3,11 +3,11 @@ use ring::digest;
 use std::io;
 
 use crate::common::account::hash::hash;
+use crate::common::message::assert_msg::assert_msg;
 use crate::common::message::inst::CommandInst;
 use crate::common::message::message::Message;
 use crate::common::message::message_builder::message_builder;
 use crate::common::message::message_type::MessageType;
-use crate::common::misc::assert_msg::assert_msg;
 use crate::common::misc::return_flags::ReturnFlags;
 
 use crate::client::network::cmd::req_server_salt::req_server_salt;

src/libtrader/client/account/creation.rs

@@ -5,11 +5,11 @@ use std::io;
 use crate::client::account::hash_email::hash_email;
 use crate::client::account::hash_pwd::hash_pwd;
 
+use crate::common::message::assert_msg::assert_msg;
 use crate::common::message::inst::CommandInst;
 use crate::common::message::message::Message;
 use crate::common::message::message_builder::message_builder;
 use crate::common::message::message_type::MessageType;
-use crate::common::misc::assert_msg::assert_msg;
 use crate::common::misc::return_flags::ReturnFlags;
 
 use crate::client::network::cmd::get_server_salt::get_server_salt;

src/libtrader/client/account/retrieval_portfolio.rs

@@ -1,11 +1,11 @@
 use std::io;
 
 use crate::common::account::portfolio::Portfolio;
+use crate::common::message::assert_msg::assert_msg;
 use crate::common::message::inst::DataTransferInst;
 use crate::common::message::message::Message;
 use crate::common::message::message_builder::message_builder;
 use crate::common::message::message_type::MessageType;
-use crate::common::misc::assert_msg::assert_msg;
 use crate::common::misc::return_flags::ReturnFlags;
 
 use tokio::io::{AsyncReadExt, AsyncWriteExt};

src/libtrader/client/account/retrieval_transaction.rs

@@ -2,11 +2,11 @@ use std::io;
 
 use crate::common::account::transaction::Transaction;
 
+use crate::common::message::assert_msg::assert_msg;
 use crate::common::message::inst::DataTransferInst;
 use crate::common::message::message::Message;
 use crate::common::message::message_builder::message_builder;
 use crate::common::message::message_type::MessageType;
-use crate::common::misc::assert_msg::assert_msg;
 use crate::common::misc::return_flags::ReturnFlags;
 
 use tokio::io::{AsyncReadExt, AsyncWriteExt};

src/libtrader/client/network/cmd/get_server_salt.rs

@@ -2,11 +2,11 @@ use ring::digest;
 
 use std::io;
 
+use crate::common::message::assert_msg::assert_msg;
 use crate::common::message::inst::CommandInst;
 use crate::common::message::message::Message;
 use crate::common::message::message_builder::message_builder;
 use crate::common::message::message_type::MessageType;
-use crate::common::misc::assert_msg::assert_msg;
 use crate::common::misc::return_flags::ReturnFlags;
 
 use tokio::io::{AsyncReadExt, AsyncWriteExt};

src/libtrader/common/message/mod.rs

@@ -1,3 +1,4 @@
+pub mod assert_msg;
 pub mod inst;
 pub mod message;
 pub mod message_builder;

src/libtrader/common/misc/mod.rs

@@ -1,3 +1,2 @@
-pub mod assert_msg;
 pub mod return_flags;
 pub mod servers_pool;

src/libtrader/server/account/authorization.rs

@@ -1,11 +1,14 @@
-use data_encoding::HEXUPPER;
-use ring::pbkdf2;
+use log::warn;
 use std::num::NonZeroU32;
 
+use data_encoding::HEXUPPER;
+use ring::pbkdf2;
+
+use crate::common::message::assert_msg::assert_msg;
+use crate::common::message::inst::CommandInst;
 use crate::common::message::message::Message;
 use crate::common::message::message_builder::message_builder;
 use crate::common::message::message_type::MessageType;
-use crate::common::misc::return_flags::ReturnFlags;
 
 use crate::server::db::cmd::get_user_hash::get_user_hash;
 use crate::server::db::cmd::get_user_id::get_user_id;
@@ -21,7 +24,26 @@ pub async fn acc_auth(
     sql_conn: &tokio_postgres::Client,
     tls_connection: &mut TlsStream<TcpStream>,
     message: &Message,
-) -> Result<(), ReturnFlags> {
+) -> std::io::Result<()> {
+    /* assert recieved message */
+    if !assert_msg(
+        message,
+        MessageType::Command,
+        true,
+        3,
+        false,
+        0,
+        false,
+        0,
+        false,
+        0,
+    ) && message.instruction == CommandInst::LoginMethod1 as i64
+        && message.data.len() != 0
+    {
+        warn!("LOGIN_INVALID_MESSAGE");
+        return tls_connection.shutdown().await;
+    }
+
     /*
      * Parse account data.
      * */
@@ -89,7 +111,22 @@ pub async fn acc_auth(
     );
     match email_ret.is_ok() {
         true => {}
-        false => return Err(ReturnFlags::ServerAccUnauthorized),
+        false => {
+            let server_response = message_builder(
+                MessageType::ServerReturn,
+                0,
+                0,
+                0,
+                0,
+                bincode::serialize(&"Email Incorrect").unwrap(),
+            );
+            match tls_connection
+                .write_all(&bincode::serialize(&server_response).unwrap())
+                .await
+            {
+                _ => return Ok(()),
+            };
+        }
     };
     let pass_ret = pbkdf2::verify(
         pbkdf2::PBKDF2_HMAC_SHA512,
@@ -100,7 +137,22 @@ pub async fn acc_auth(
     );
     match pass_ret.is_ok() {
         true => {}
-        false => return Err(ReturnFlags::ServerAccUnauthorized),
+        false => {
+            let server_response = message_builder(
+                MessageType::ServerReturn,
+                0,
+                0,
+                0,
+                0,
+                bincode::serialize(&"Password Incorrect").unwrap(),
+            );
+            match tls_connection
+                .write_all(&bincode::serialize(&server_response).unwrap())
+                .await
+            {
+                _ => return Ok(()),
+            };
+        }
     };
 
     /*
@@ -118,7 +170,30 @@ pub async fn acc_auth(
             .duration_since(UNIX_EPOCH)
             .unwrap()
             .as_secs(),
-    )?;
+    );
+
+    /*
+     * server failed to generate JWT token.
+     * inform client about issue
+     * */
+    if jwt_token.is_err() {
+        let server_response = message_builder(
+            MessageType::ServerReturn,
+            0,
+            0,
+            0,
+            0,
+            bincode::serialize(&"Login failed, try again later.").unwrap(),
+        );
+        match tls_connection
+            .write_all(&bincode::serialize(&server_response).unwrap())
+            .await
+        {
+            // We already failed,
+            // we don't care if client doesn't recieve
+            _ => return Ok(()),
+        };
+    }
 
     /*
      * Send the JWT token
@@ -129,12 +204,12 @@ pub async fn acc_auth(
         1,
         0,
         0,
-        jwt_token.as_bytes().to_vec(),
+        jwt_token.unwrap().as_bytes().to_vec(),
     );
-    tls_connection
+    match tls_connection
         .write_all(bincode::serialize(&message).unwrap().as_slice())
         .await
-        .expect("could not write to client");
-
-    Ok(())
+    {
+        _ => Ok(()), // Don't care if client doesn't receive
+    }
 }

src/libtrader/server/account/creation.rs

@@ -1,4 +1,10 @@
 use data_encoding::HEXUPPER;
+use log::warn;
+
+use crate::common::message::assert_msg::assert_msg;
+use crate::common::message::inst::CommandInst;
+use crate::common::message::message_builder::message_builder;
+use crate::common::message::message_type::MessageType;
 
 use crate::common::account::portfolio::Portfolio;
 use crate::common::message::message::Message;
@@ -8,10 +14,34 @@ use crate::server::account::hash_email::hash_email;
 use crate::server::account::hash_pwd::hash_pwd;
 use crate::server::ds::account::Account;
 
+use tokio::io::AsyncWriteExt;
+use tokio::net::TcpStream;
+use tokio_rustls::server::TlsStream;
+
 pub async fn acc_create(
     sql_conn: &tokio_postgres::Client,
+    tls_connection: &mut TlsStream<TcpStream>,
     message: &Message,
-) -> Result<(), ReturnFlags> {
+) -> std::io::Result<()> {
+    /* assert recieved message */
+    if !assert_msg(
+        message,
+        MessageType::Command,
+        true,
+        5,
+        false,
+        0,
+        false,
+        0,
+        false,
+        0,
+    ) && message.instruction == CommandInst::Register as i64
+        && message.data.len() != 0
+    {
+        warn!("REGISTER_INVALID_MESSAGE");
+        return tls_connection.shutdown().await;
+    }
+
     /*
      * Parse account data
      * */
@@ -83,7 +113,25 @@ pub async fn acc_create(
         .await
         .unwrap()
     {
-        return Err(ReturnFlags::ServerAccUserExists);
+        /*
+         * Inform cient that user already exists
+         * Note: figure out if this is a security? issue
+         */
+        let server_response = message_builder(
+            MessageType::ServerReturn,
+            0,
+            0,
+            0,
+            0,
+            bincode::serialize(&format!("{:#?}", ReturnFlags::ServerAccUserExists)).unwrap(),
+        );
+        match tls_connection
+            .write_all(&bincode::serialize(&server_response).unwrap())
+            .await
+        {
+            // Don't care if user didn't recieve a reply
+            _ => return Ok(()),
+        };
     }
 
     /*
@@ -101,14 +149,34 @@ pub async fn acc_create(
     /*
      * Write the account to the database.
      * */
-    match sql_conn.execute("INSERT INTO accounts_schema.accounts \
+    let creation_result = sql_conn.execute("INSERT INTO accounts_schema.accounts \
         (username, email_hash, server_email_salt, client_email_salt, pass_hash, server_pass_salt, client_pass_salt)
         VALUES \
         ($1, $2, $3, $4, $5, $6, $7)",
         &[&account.username,
         &account.email_hash, &account.server_email_salt, &account.client_email_salt,
-        &account.pass_hash, &account.server_pass_salt, &account.client_pass_salt]).await {
-            Ok(_) => return Ok(()),
-            Err(_) => return Err(ReturnFlags::ServerDbWriteFailed),
+        &account.pass_hash, &account.server_pass_salt, &account.client_pass_salt]).await;
+
+    /*
+     * Send to client SQL result
+     */
+    let server_response = message_builder(
+        MessageType::ServerReturn,
+        if creation_result.is_ok() { 1 } else { 0 },
+        0,
+        0,
+        0,
+        if creation_result.is_ok() {
+            Vec::new()
+        } else {
+            bincode::serialize(&format!("{:#?}", creation_result)).unwrap()
+        },
+    );
+    match tls_connection
+        .write_all(&bincode::serialize(&server_response).unwrap())
+        .await
+    {
+        // Don't care if user didn't recieve a reply
+        _ => Ok(()),
     }
 }

src/libtrader/server/account/retrieval_portfolio.rs

@@ -2,10 +2,11 @@ use log::warn;
 
 use crate::common::account::portfolio::Portfolio;
 use crate::common::account::position::Position;
+use crate::common::message::assert_msg::assert_msg;
+use crate::common::message::inst::DataTransferInst;
 use crate::common::message::message::Message;
 use crate::common::message::message_builder::message_builder;
 use crate::common::message::message_type::MessageType;
-use crate::common::misc::return_flags::ReturnFlags;
 
 use crate::server::db::initializer::db_connect;
 use crate::server::network::jwt_wrapper::verify_jwt_token;
@@ -17,14 +18,50 @@ use tokio_rustls::server::TlsStream;
 pub async fn acc_retrieve_portfolio(
     tls_connection: &mut TlsStream<TcpStream>,
     message: &Message,
-) -> Result<(), ReturnFlags> {
+) -> std::io::Result<()> {
+    /* assert recieved message */
+    if !assert_msg(
+        message,
+        MessageType::Command,
+        true,
+        1,
+        false,
+        0,
+        false,
+        0,
+        false,
+        0,
+    ) && message.instruction == DataTransferInst::GetUserPortfolio as i64
+        && message.data.len() != 0
+    {
+        warn!("RETRIEVE_PORTFOLIO_INVALID_MESSAGE");
+        return tls_connection.shutdown().await;
+    }
+
     /* verify JWT token */
     let token = match verify_jwt_token(bincode::deserialize(&message.data).unwrap()) {
         Ok(token) => token,
         Err(_) => {
             warn!("ACC_RETRIEVE_PORTFOLIO_UNAUTH_TOKEN");
-            tls_connection.shutdown().await.unwrap();
-            return Err(ReturnFlags::ServerAccUnauthorized);
+            let server_response = message_builder(
+                MessageType::ServerReturn,
+                0,
+                0,
+                0,
+                0,
+                bincode::serialize(&"Password Incorrect").unwrap(),
+            );
+            match tls_connection
+                .write_all(&bincode::serialize(&server_response).unwrap())
+                .await
+            {
+                _ => {
+                    // TODO: do we shutdown connection or do we let handle_data caller do it's
+                    // thing
+                    tls_connection.shutdown().await.unwrap();
+                    return Ok(());
+                }
+            };
         }
     };
 
@@ -33,8 +70,7 @@ pub async fn acc_retrieve_portfolio(
         std::env::var("DB_PORTFOLIO_USER").unwrap(),
         std::env::var("DB_PORTFOLIO_PASS").unwrap(),
     )
-    .await
-    .map_err(|_| ReturnFlags::ServerRetrievePortfolioFailed)?;
+    .await?;
 
     /* get userId's portfolio positions */
     let mut portfolio: Portfolio = Portfolio::default();
@@ -71,10 +107,15 @@ pub async fn acc_retrieve_portfolio(
         0,
         bincode::serialize(&portfolio).unwrap(),
     );
-    let _ = tls_connection
+    match tls_connection
         .write_all(&bincode::serialize(&message).unwrap())
         .await
-        .expect("could not write to client");
-
-    Ok(())
+    {
+        Ok(()) => Ok(()),
+        Err(err) => {
+            // Log issue in writing to client
+            warn!("Could not write to cient! With Error: {}\nIgnoring...", err);
+            Ok(())
+        }
+    }
 }

src/libtrader/server/account/retrieval_transaction.rs

@@ -1,10 +1,11 @@
 use log::warn;
 
 use crate::common::account::transaction::Transaction;
+use crate::common::message::assert_msg::assert_msg;
+use crate::common::message::inst::DataTransferInst;
 use crate::common::message::message::Message;
 use crate::common::message::message_builder::message_builder;
 use crate::common::message::message_type::MessageType;
-use crate::common::misc::return_flags::ReturnFlags;
 
 use crate::server::network::jwt_wrapper::verify_jwt_token;
 
@@ -14,16 +15,37 @@ use tokio_rustls::server::TlsStream;
 
 pub async fn acc_retrieve_transaction(
     sql_conn: &tokio_postgres::Client,
-    socket: &mut TlsStream<TcpStream>,
+    tls_connection: &mut TlsStream<TcpStream>,
     message: &Message,
-) -> Result<(), ReturnFlags> {
+) -> std::io::Result<()> {
+    /* assert recieved message */
+    if !assert_msg(
+        message,
+        MessageType::DataTransfer,
+        true,
+        1,
+        false,
+        0,
+        false,
+        0,
+        false,
+        0,
+    ) && message.instruction == DataTransferInst::GetUserTransactionHist as i64
+        && message.data.len() != 0
+    {
+        warn!("RETRIEVE_TRANSACTION_INVALID_MESSAGE");
+        return tls_connection.shutdown().await;
+    }
+
     /* verify JWT token */
     let token = match verify_jwt_token(bincode::deserialize(&message.data).unwrap()) {
         Ok(token) => token,
         Err(_) => {
             warn!("ACC_RETRIEVE_TRANSACTION_UNAUTH_TOKEN");
-            socket.shutdown().await.unwrap();
-            return Err(ReturnFlags::ServerAccUnauthorized);
+            tls_connection.shutdown().await.unwrap();
+            // Unauth aren't big deal,
+            // maybe later we can make more sophisticated DOS attack detection
+            return Ok(());
         }
     };
 
@@ -55,10 +77,14 @@ pub async fn acc_retrieve_transaction(
         0,
         bincode::serialize(&transactions).unwrap(),
     );
-    socket
+    match tls_connection
         .write_all(&bincode::serialize(&message).unwrap())
         .await
-        .map_err(|_| ReturnFlags::ServerRetrieveTransactionFailed)?;
-
-    Ok(())
+    {
+        Ok(()) => Ok(()),
+        Err(err) => {
+            warn!("Could not write to client! Error: {}", err);
+            Ok(())
+        }
+    }
 }

src/libtrader/server/db/cmd/get_user_id.rs

@@ -5,7 +5,7 @@ use crate::common::misc::return_flags::ReturnFlags;
 pub async fn get_user_id(
     sql_conn: &tokio_postgres::Client,
     username: &str,
-) -> Result<i64, ReturnFlags> {
+) -> std::io::Result<i64> {
     /* check that user exists */
     if user_exists(sql_conn, username).await {
         for row in sql_conn
@@ -19,5 +19,8 @@ pub async fn get_user_id(
             return Ok(row.get(0));
         }
     }
-    Err(ReturnFlags::ServerGetUserIdNotFound)
+    Err(std::io::Error::new(
+        std::io::ErrorKind::NotFound,
+        format!("{}", ReturnFlags::ServerGetUserIdNotFound),
+    ))
 }

src/libtrader/server/db/initializer.rs

@@ -14,10 +14,7 @@
 /// ```rust
 /// let mut client = db_connect(DB_USER, DB_PASS)?;
 /// ```
-pub async fn db_connect(
-    user: String,
-    pass: String,
-) -> Result<tokio_postgres::Client, tokio_postgres::Error> {
+pub async fn db_connect(user: String, pass: String) -> std::io::Result<tokio_postgres::Client> {
     /* Generate the requested string */
     let db_connect_str = format!(
         "host={} port={} dbname={} user={} password={}",
@@ -28,7 +25,9 @@ pub async fn db_connect(
         pass
     );
     let (client, connection) =
-        tokio_postgres::connect(db_connect_str.as_str(), tokio_postgres::NoTls).await?;
+        tokio_postgres::connect(db_connect_str.as_str(), tokio_postgres::NoTls)
+            .await
+            .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, format!("{}", err)))?;
     tokio::spawn(async move {
         if let Err(e) = connection.await {
             eprintln!("SQL connection error: {}", e);

src/libtrader/server/initializer.rs

@@ -151,8 +151,10 @@ pub async fn libtrader_init_server() -> std::io::Result<()> {
         .next()
         .ok_or_else(|| std::io::Error::from(std::io::ErrorKind::AddrNotAvailable))?;
 
-    let config = gen_tls_server_config(&Path::new(&std::env::var("CONFIG_CERT_FILE").unwrap()), 
-                                       &Path::new(&std::env::var("CONFIG_KEY_FILE").unwrap()))?;
+    let config = gen_tls_server_config(
+        &Path::new(&std::env::var("CONFIG_CERT_FILE").unwrap()),
+        &Path::new(&std::env::var("CONFIG_KEY_FILE").unwrap()),
+    )?;
     let acceptor = TlsAcceptor::from(config);
 
     let listener = TcpListener::bind(&addr).await?;

src/libtrader/server/network/cmd/get_asset_data.rs

@@ -1,82 +0,0 @@
-//use std::io::Write;
-//
-//use crate::common::message::message::Message;
-//use crate::common::message::message_builder::message_builder;
-//use crate::common::message::message_type::MessageType;
-//use crate::common::misc::assert_msg::assert_msg;
-//
-//use crate::server::db::cmd::get_stock::get_stock_from_db_between_epochs;
-//use crate::server::network::tls_connection::TlsConnection;
-//
-//pub fn get_asset_data(tls_connection: &mut TlsConnection, message: &Message) {
-//    /* assert recieved message */
-//    if !assert_msg(
-//        message,
-//        MessageType::DataTransfer,
-//        true,
-//        3,
-//        false,
-//        0,
-//        false,
-//        0,
-//        false,
-//        0,
-//    ) {
-//        tls_connection.closing = true;
-//        warn!("GET_ASSET_DATA_MSG_ASSERT_FAILED");
-//        return;
-//    }
-//
-//    /*
-//     * Parse arguments
-//     * */
-//    /* get json data */
-//    let stringified_data = std::str::from_utf8(&message.data).unwrap();
-//    let data = json::parse(&stringified_data).unwrap();
-//    /* get symbol, start_epoch, and end_epoch */
-//    let symbol = data["symbol"].as_str().unwrap();
-//    let start_epoch = data["start_epoch"]
-//        .as_str()
-//        .unwrap()
-//        .to_string()
-//        .parse::<i64>()
-//        .unwrap();
-//    let end_epoch = data["end_epoch"]
-//        .as_str()
-//        .unwrap()
-//        .to_string()
-//        .parse::<i64>()
-//        .unwrap();
-//
-//    /* call get_stock_from_db_between_epochs() */
-//    match get_stock_from_db_between_epochs(symbol, start_epoch, end_epoch) {
-//        Ok(vals) => {
-//            /* send the data */
-//            let mut counter = 0;
-//            for val in &vals {
-//                let message = message_builder(
-//                    MessageType::DataTransfer,
-//                    1,
-//                    counter,
-//                    vals.len(),
-//                    0,
-//                    bincode::serialize(&val).unwrap(),
-//                );
-//                let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
-//                counter = counter + 1;
-//            }
-//        }
-//        Err(err) => {
-//            /* handle error */
-//            let message = message_builder(
-//                MessageType::ServerReturn,
-//                0,
-//                0,
-//                0,
-//                0,
-//                bincode::serialize(&err).unwrap(),
-//            );
-//            let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
-//        }
-//    }
-//}

src/libtrader/server/network/cmd/get_asset_info.rs

@@ -1,56 +0,0 @@
-//use std::io::Write;
-//
-//use crate::common::message::inst::DataTransferInst;
-//use crate::common::message::message::Message;
-//use crate::common::message::message_builder::message_builder;
-//use crate::common::message::message_type::MessageType;
-//use crate::common::misc::assert_msg::assert_msg;
-//
-//use crate::server::db::cmd::get_company::get_company_from_db;
-//use crate::server::network::tls_connection::TlsConnection;
-//
-//pub fn get_asset_info(tls_connection: &mut TlsConnection, message: &Message) {
-//    /* assert recieved message */
-//    if !assert_msg(
-//        message,
-//        MessageType::DataTransfer,
-//        true,
-//        1,
-//        false,
-//        0,
-//        false,
-//        0,
-//        false,
-//        0,
-//    ) {
-//        tls_connection.closing = true;
-//        warn!("GET_ASSET_INFO_INVALID_MESSAGE");
-//        return;
-//    }
-//
-//    /* call get_company_from_db() */
-//    match get_company_from_db(bincode::deserialize(&message.data).unwrap()) {
-//        Ok(company) => {
-//            let message = message_builder(
-//                MessageType::ServerReturn,
-//                DataTransferInst::GetAssetInfo as i64,
-//                0,
-//                0,
-//                1,
-//                bincode::serialize(&company).unwrap(),
-//            );
-//            let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
-//        }
-//        Err(err) => {
-//            let message = message_builder(
-//                MessageType::ServerReturn,
-//                0,
-//                0,
-//                0,
-//                0,
-//                bincode::serialize(&err).unwrap(),
-//            );
-//            let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
-//        }
-//    }
-//}

src/libtrader/server/network/cmd/login_normal.rs

@@ -1,56 +0,0 @@
-use log::warn;
-
-use crate::common::message::inst::CommandInst;
-use crate::common::message::message::Message;
-use crate::common::message::message_builder::message_builder;
-use crate::common::message::message_type::MessageType;
-use crate::common::misc::assert_msg::assert_msg;
-
-use crate::server::account::authorization::acc_auth;
-
-use tokio::io::AsyncWriteExt;
-use tokio::net::TcpStream;
-use tokio_rustls::server::TlsStream;
-
-pub async fn login_normal(
-    sql_conn: &tokio_postgres::Client,
-    tls_connection: &mut TlsStream<TcpStream>,
-    message: &Message,
-) -> std::io::Result<()> {
-    /* assert recieved message */
-    if !assert_msg(
-        message,
-        MessageType::Command,
-        true,
-        3,
-        false,
-        0,
-        false,
-        0,
-        false,
-        0,
-    ) && message.instruction == CommandInst::LoginMethod1 as i64
-        && message.data.len() != 0
-    {
-        warn!("LOGIN_INVALID_MESSAGE");
-        return tls_connection.shutdown().await;
-    }
-
-    /* call acc_auth() server version */
-    match acc_auth(sql_conn, tls_connection, message).await {
-        Ok(_) => Ok(()),
-        Err(err) => {
-            let server_response = message_builder(
-                MessageType::ServerReturn,
-                0,
-                0,
-                0,
-                0,
-                bincode::serialize(&err).unwrap(),
-            );
-            tls_connection
-                .write_all(&bincode::serialize(&server_response).unwrap())
-                .await
-        }
-    }
-}

src/libtrader/server/network/cmd/mod.rs

@@ -1,7 +0,0 @@
-pub mod get_asset_data;
-pub mod get_asset_info;
-pub mod login_normal;
-pub mod purchase_asset;
-pub mod register;
-pub mod retrieve_portfolio;
-pub mod retrieve_transactions;

src/libtrader/server/network/cmd/purchase_asset.rs

@@ -1,35 +0,0 @@
-//use crate::common::message::message::Message;
-//
-//use crate::server::network::tls_connection::TlsConnection;
-//
-//pub fn purchase_asset(_tls_connection: &mut TlsConnection, _message: &Message) {
-//    /* assert recieved message */
-//    //if message.msgtype != MessageType::Command || message.argument_count != 4
-//    //    || message.data_message_number != 0 || message.data_message_max != 0
-//    //        || message.data.len() == 0 {
-//    //            warn!("PURCHASE_ASSET_INVALID_MESSAGE");
-//    //            tls_connection.closing = true;
-//    //            return;
-//    //        }
-//
-//    //* parse request data */
-//    //let stringified_data = std::str::from_utf8(&message.data).unwrap();
-//    //let data = json::parse(&stringified_data).unwrap();
-//    //* get symbol, shares amount, price, buy or sell */
-//    //let symbol = data["symbol"].as_str().unwrap();
-//    //let shares_amount = data["shares_amount"].as_str().unwrap().to_string().parse::<i64>().unwrap();
-//    //let is_buy = data["is_buy"].as_bool().unwrap();
-//
-//    //* connect to the data base */
-//    //let mut client = db_connect(DB_USER, DB_PASS).unwrap();
-//
-//    //* check if the symbol exists */
-//    //let company = get_company_from_db(symbol);
-//    //if !company.is_ok() {
-//    //    let msg = message_builder(MessageType::ServerReturn, 0, 1, 0, 0,
-//    //                              bincode::serialize("COULDNOT FIND COMPANY")).unwrap();
-//    //    return;
-//    //}
-//
-//    //*  */
-//}

src/libtrader/server/network/cmd/register.rs

@@ -1,53 +0,0 @@
-use log::warn;
-
-use crate::common::message::inst::CommandInst;
-use crate::common::message::message::Message;
-use crate::common::message::message_builder::message_builder;
-use crate::common::message::message_type::MessageType;
-use crate::common::misc::assert_msg::assert_msg;
-
-use crate::server::account::creation::acc_create;
-
-use tokio::io::AsyncWriteExt;
-use tokio::net::TcpStream;
-use tokio_rustls::server::TlsStream;
-
-pub async fn register(
-    sql_conn: &tokio_postgres::Client,
-    tls_connection: &mut TlsStream<TcpStream>,
-    message: &Message,
-) -> std::io::Result<()> {
-    /* assert recieved message */
-    if !assert_msg(
-        message,
-        MessageType::Command,
-        true,
-        5,
-        false,
-        0,
-        false,
-        0,
-        false,
-        0,
-    ) && message.instruction == CommandInst::Register as i64
-        && message.data.len() != 0
-    {
-        warn!("REGISTER_INVALID_MESSAGE");
-        return tls_connection.shutdown().await;
-    }
-
-    /* call acc_create() server version */
-    match acc_create(sql_conn, message).await {
-        Ok(_) => {
-            let server_response =
-                message_builder(MessageType::ServerReturn, 1, 0, 0, 0, Vec::new());
-            tls_connection
-                .write_all(&bincode::serialize(&server_response).unwrap())
-                .await
-        }
-        Err(err) => {
-            warn!("REGISTER_FAILED: {}", err);
-            Ok(())
-        }
-    }
-}

src/libtrader/server/network/cmd/retrieve_portfolio.rs

@@ -1,50 +0,0 @@
-use log::warn;
-use std::io;
-
-use crate::common::message::inst::DataTransferInst;
-use crate::common::message::message::Message;
-use crate::common::message::message_type::MessageType;
-use crate::common::misc::assert_msg::assert_msg;
-use crate::common::misc::return_flags::ReturnFlags;
-
-use crate::server::account::retrieval_portfolio::acc_retrieve_portfolio;
-
-use tokio::io::AsyncWriteExt;
-use tokio::net::TcpStream;
-use tokio_rustls::server::TlsStream;
-
-pub async fn retrieve_portfolio(
-    tls_connection: &mut TlsStream<TcpStream>,
-    message: &Message,
-) -> std::io::Result<()> {
-    /* assert recieved message */
-    if !assert_msg(
-        message,
-        MessageType::Command,
-        true,
-        1,
-        false,
-        0,
-        false,
-        0,
-        false,
-        0,
-    ) && message.instruction == DataTransferInst::GetUserPortfolio as i64
-        && message.data.len() != 0
-    {
-        warn!("RETRIEVE_PORTFOLIO_INVALID_MESSAGE");
-        return tls_connection.shutdown().await;
-    }
-
-    /* call acc_retrieve_portfolio() server version */
-    match acc_retrieve_portfolio(tls_connection, message).await {
-        Ok(_) => Ok(()),
-        Err(err) => {
-            warn!("RETRIEVE_PORTFOLIO_FAILED: {}", err);
-            Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("{}: {}", ReturnFlags::ServerRetrievePortfolioFailed, err),
-            ))
-        }
-    }
-}

src/libtrader/server/network/cmd/retrieve_transactions.rs

@@ -1,51 +0,0 @@
-use log::warn;
-use std::io;
-
-use crate::common::message::inst::DataTransferInst;
-use crate::common::message::message::Message;
-use crate::common::message::message_type::MessageType;
-use crate::common::misc::assert_msg::assert_msg;
-use crate::common::misc::return_flags::ReturnFlags;
-
-use crate::server::account::retrieval_transaction::acc_retrieve_transaction;
-
-use tokio::io::AsyncWriteExt;
-use tokio::net::TcpStream;
-use tokio_rustls::server::TlsStream;
-
-pub async fn retrieve_transactions(
-    sql_conn: &tokio_postgres::Client,
-    tls_connection: &mut TlsStream<TcpStream>,
-    message: &Message,
-) -> std::io::Result<()> {
-    /* assert recieved message */
-    if !assert_msg(
-        message,
-        MessageType::DataTransfer,
-        true,
-        1,
-        false,
-        0,
-        false,
-        0,
-        false,
-        0,
-    ) && message.instruction == DataTransferInst::GetUserTransactionHist as i64
-        && message.data.len() != 0
-    {
-        warn!("RETRIEVE_TRANSACTION_INVALID_MESSAGE");
-        return tls_connection.shutdown().await;
-    }
-
-    /* call acc_retrieve_transaction() server version */
-    match acc_retrieve_transaction(sql_conn, tls_connection, message).await {
-        Ok(_) => Ok(()),
-        Err(err) => {
-            warn!("RETRIEVE_TRANSACTION_FAILED: {}", err);
-            Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("{}: {}", ReturnFlags::ServerRetrieveTransactionFailed, err),
-            ))
-        }
-    }
-}

src/libtrader/server/network/handle_data.rs

@@ -5,12 +5,11 @@ use crate::common::message::message::Message;
 use crate::common::message::message_builder::message_builder;
 use crate::common::message::message_type::MessageType;
 
-use crate::server::network::cmd::login_normal::login_normal;
-use crate::server::network::cmd::register::register;
-use crate::server::network::cmd::retrieve_portfolio::retrieve_portfolio;
-use crate::server::network::cmd::retrieve_transactions::retrieve_transactions;
+use crate::server::account::authorization::acc_auth;
+use crate::server::account::creation::acc_create;
+use crate::server::account::retrieval_portfolio::acc_retrieve_portfolio;
+use crate::server::account::retrieval_transaction::acc_retrieve_transaction;
 
-//use tokio::net::TcpStream;
 use tokio::io::AsyncWriteExt;
 use tokio::net::TcpStream;
 use tokio_rustls::server::TlsStream;
@@ -116,16 +115,16 @@ pub async fn handle_data(
             }
         }
         _ if client_msg.instruction == CommandInst::Register as i64 => {
-            register(sql_conn, socket, &client_msg).await
+            acc_create(sql_conn, socket, &client_msg).await
         }
         _ if client_msg.instruction == CommandInst::LoginMethod1 as i64 => {
-            login_normal(sql_conn, socket, &client_msg).await
+            acc_auth(sql_conn, socket, &client_msg).await
         }
         _ if client_msg.instruction == DataTransferInst::GetUserPortfolio as i64 => {
-            retrieve_portfolio(socket, &client_msg).await
+            acc_retrieve_portfolio(socket, &client_msg).await
         }
         _ if client_msg.instruction == DataTransferInst::GetUserTransactionHist as i64 => {
-            retrieve_transactions(sql_conn, socket, &client_msg).await
+            acc_retrieve_transaction(sql_conn, socket, &client_msg).await
         }
         _ => Ok(()),
     }

src/libtrader/server/network/mod.rs

@@ -1,4 +1,3 @@
-pub mod cmd;
 pub mod gen_tls_server_config;
 pub mod handle_data;
 pub mod jwt_wrapper;

todo/v1.libtrader.md

@@ -1,7 +1,9 @@
 ## To do
 
-- server move network code to somewhere plausable.
+- investigate server logging doesn't include location of log method caller
 - create correct modules
+    * [ ] fix weird file naming
+    * [ ] fix namespace naming
 - data implmentation stuff
     * [ ] implement buy & sell
     * [ ] impl on client
@@ -141,3 +143,5 @@
     * [x] Saving/Loading company values
 - configure drone ci
 - use env.sh or arguments
+- server move network code to somewhere plausable.
+    * [x] move assert_msg to message namespace