Wrap the data into a request type

snow-scanner/src/server.rs

@@ -76,14 +76,7 @@ impl ws2::Handler for Server {
 
         info!("on message: {msg}, {ws}");
 
-        let worker_message: WorkerMessages = match serde_json::from_str(msg.as_str()) {
+        let worker_message: WorkerMessages = msg.clone().into();
-            Ok(worker_message) => worker_message,
-            Err(err) => {
-                error!("Unable to understand: {msg}, {ws}: {err}");
-                // Unable to understand, close the connection
-                return ws.close();
-            }
-        };
 
         match worker_message {
             WorkerMessages::AuthenticateRequest { login } => {
@@ -94,20 +87,23 @@ impl ws2::Handler for Server {
                     return Ok(n?);*/
                     return Ok(());
                 } else {
-                    error!("Already authenticated: {msg}, {ws}");
+                    error!("Already authenticated: {ws}");
                     return Ok(());
                 }
             }
-            WorkerMessages::FooRequest { username } => {
+            WorkerMessages::GetWorkRequest {} => {
-                let echo = format!("echo: {msg}");
+                let echo = format!("wr");
                 let n = ws.send(echo);
                 Ok(n?)
             }
-            WorkerMessages::String => {
+            WorkerMessages::Invalid => {
                 error!("Unable to understand: {msg}, {ws}");
                 // Unable to understand, close the connection
                 return ws.close();
-            }
+            } /*msg => {
+                  error!("No implemented: {:#?}", msg);
+                  Ok(())
+              }*/
         }
     }
 }

snow-scanner/src/worker/modules.rs

@@ -1,9 +1,31 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(untagged)]
+#[serde(tag = "type", content = "request")]
 pub enum WorkerMessages {
+    #[serde(rename = "auth_request")]
     AuthenticateRequest { login: String },
-    FooRequest { username: String },
+    #[serde(rename = "get_work")]
-    String,
+    GetWorkRequest {},
+    #[serde(rename = "do_work")]
+    DoWorkRequest {},
+    #[serde(rename = "")]
+    Invalid,
+}
+
+impl ToString for WorkerMessages {
+    fn to_string(&self) -> String {
+        serde_json::to_string(&self).expect("To serialize").into()
+    }
+}
+
+impl Into<WorkerMessages> for String {
+    fn into(self) -> WorkerMessages {
+        let req: Result<WorkerMessages, serde_json::Error> =
+            serde_json::from_str(self.as_str());
+        match req {
+            Ok(d) => d,
+            Err(_) => WorkerMessages::Invalid,
+        }
+    }
 }

snow-scanner/src/worker/worker.rs

@@ -81,14 +81,21 @@ fn main() -> () {
                     Ok(_) => {}
                     Err(err) => error!("Processing error: {err}"),
                 }
-                if ! worker.is_authenticated() {
+                if !worker.is_authenticated() {
                     let msg: WorkerMessages = WorkerMessages::AuthenticateRequest {
                         login: "williamdes".to_string(),
                     };
-                    let msg: String = serde_json::to_string(&msg).expect("To serialize").into();
+                    let msg_string: String = msg.to_string();
-                    match ws_client.send(msg) {
+                    match ws_client.send(msg_string) {
                         Ok(_) => {
-                            worker.authenticated = true;
+                            match msg {
+                                WorkerMessages::AuthenticateRequest { login } => {
+                                    worker.authenticated = true; // Anyway, it will kick us if this is not success
+                                    info!("Logged in as: {login}")
+                                }
+                                WorkerMessages::GetWorkRequest {} => {}
+                                msg => error!("No implemented: {:#?}", msg),
+                            }
                         }
                         Err(err) => error!("Unable to connect to {url}: {err}"),
                     }