terrible ws implementation

3 files changed, 108 insertions, 9 deletions

diff --git a/src/database.rs b/src/database.rs
index 74d9c1a..48c6b12 100644
--- a/src/database.rs
+++ b/src/database.rs
@@ -6,6 +6,7 @@ use super::*;
 
 pub struct Database {
     db: Connection,
+    newest_message_id: Option<UID>,
 }
 impl Database {
     pub fn get_message(&self, id: usize) -> Option<Message> {
@@ -40,11 +41,18 @@ impl Database {
     pub fn get_next_message_id(&self) -> UID {
         UID::from(self.get_table_length("messages"))
     }
-    pub fn get_message_newest_id(&self) -> Option<UID> {
-        match self.get_table_length("messages") {
-            0 => None,
-            n => Some(UID::new(n - 1)),
+    pub fn get_message_newest_id(&mut self) -> Option<UID> {
+        match self.newest_message_id {
+            None => {
+                self.newest_message_id = match self.get_table_length("messages") {
+                0 => None,
+                n => Some(UID::new(n - 1)),
+                }
+            },
+            Some(_) => ()
         }
+
+        self.newest_message_id
     }
 
     fn message_from_row(&self, row: sqlite::Row) -> Message{
@@ -137,6 +145,8 @@ impl Database {
             }
         }
 
+        self.newest_message_id = Some(msg.id());
+
         Ok(msg.id())
     }
 
@@ -379,6 +389,7 @@ impl Database {
 
         Database {
             db: db,
+            newest_message_id: None
         }
     }
 }
\ No newline at end of file
diff --git a/src/database/types.rs b/src/database/types.rs
index 4656e49..65aca05 100644
--- a/src/database/types.rs
+++ b/src/database/types.rs
@@ -234,4 +234,20 @@ impl ReceiveMessage {
 pub struct ReceiveUpdateField {pub user: UID, pub field: DataField, pub data: String}
 
 #[derive(Deserialize, Clone)]
-pub struct ReceiveStatus {pub user: UID, pub status: Status}
\ No newline at end of file
+pub struct ReceiveStatus {pub user: UID, pub status: Status}
+
+pub enum BinaryMessage {
+    GetMessageNewestId
+}
+impl std::convert::From<&[u8]> for BinaryMessage {
+    fn from(t: &[u8]) -> BinaryMessage {
+        match t {
+            _ => BinaryMessage::GetMessageNewestId,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum WebSocketMessage {
+    NewMessage
+}
\ No newline at end of file
diff --git a/src/main.rs b/src/main.rs
index af0234a..fd76ec7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,12 +4,13 @@ mod database;
 
 use rocket::serde::json::Json;
 use rocket::State;
-use std::sync::Mutex;
+use std::sync::{Mutex, Arc};
 use database::types::*;
+use tungstenite::accept;
 
 
 struct SharedDB {
-    sdb: Mutex<database::Database>
+    sdb: Arc<Mutex<database::Database>>
 }
 
 #[derive(serde::Serialize)]
@@ -64,7 +65,7 @@ fn get_message_list(id_start: u64, id_end: u64, db: &State<SharedDB>) -> Json<Re
 }
 #[get("/get_message_id_newest")]
 fn get_message_id_newest(db: &State<SharedDB>) -> Json<Response<UID, &'static str>> {
-    let lock = db.sdb.lock().unwrap();
+    let mut lock = db.sdb.lock().unwrap();
     match lock.get_message_newest_id() {
         Some(n) => Json(Response(Ok(n))),
         None => Json(Response(Err("No messages")))
@@ -145,6 +146,7 @@ fn api_index(db: &State<SharedDB>) -> Json<Info> {
 }
 
 
+
 #[derive(serde::Serialize)]
 struct HitCount {
     c: usize
@@ -152,6 +154,75 @@ struct HitCount {
 
 #[launch]
 fn rocket() -> _ {
+    let database = std::sync::Arc::new(Mutex::new(database::Database::new()));
+
+    let websocketdb = Arc::clone(&database);
+    let rocketdb = Arc::clone(&database);
+
+    std::thread::spawn(move || {
+        let listen = std::net::TcpListener::bind("127.0.0.1:8001").unwrap();
+
+        loop {
+            for connection in listen.incoming() {
+
+                let wsconnectiondb = Arc::clone(&websocketdb);
+                std::thread::spawn(move || {
+                    let mut websocket = accept(connection.unwrap()).unwrap();
+                    let mut newest = 0;
+
+                    loop {
+                        // TX
+                        let mut db = wsconnectiondb.lock().unwrap();
+                        let local_newest = match db.get_message_newest_id() {
+                            Some(n) => n.into(),
+                            None => 0
+                        };
+                        drop(db);
+
+                        if local_newest > newest {
+                            let m = serde_json::to_string(&WebSocketMessage::NewMessage).unwrap();
+                            websocket.write_message(tungstenite::Message::text(m)).unwrap();
+                            newest = local_newest;
+                        }
+
+                        std::thread::sleep(std::time::Duration::from_millis(100));
+
+                        // RX
+                        // let _ = match websocket.read_message() {
+                        //     Ok(n) => n,
+                        //     Err(_) => {println!("closed"); break}
+                        // };
+
+                        // if msg.is_binary() {
+                        //     if msg.len() > 0 {
+                        //         match msg.into_data()[0..=1].into() {
+                        //             BinaryMessage::GetMessageNewestId => {
+                        //                 let db = wsconnectiondb.lock().unwrap();
+                        //                 let m = db.get_message_newest_id();
+                        //                 drop(db);
+
+                        //                 let m = serde_json::to_string(&m).unwrap();
+                        //                 websocket.write_message(tungstenite::Message::text(m)).unwrap();
+                        //             },
+                        //             // Return error of unsupported data
+                        //             _ => (),
+                        //         }
+                        //     } else {
+                        //         // Return error of empty data
+                        //         websocket.write_message(msg).unwrap();
+                        //     }
+
+                        // } else if msg.is_text() {
+                        //     println!("{}", msg.into_text().unwrap());
+                        // }
+
+                    }
+                    
+                });
+            }
+        }
+    });
+
     rocket::build()
     .mount("/api", routes![
         get_message,
@@ -167,7 +238,8 @@ fn rocket() -> _ {
         get_message_list,
         set_user_data,
         set_user_status,
+
     ])
     .mount("/", routes![api_index])
-    .manage(SharedDB{sdb: Mutex::new(database::Database::new())})
+    .manage(SharedDB{sdb: rocketdb})
 }
\ No newline at end of file