Rework server networking to use tonic gRPC lib.

nyash_server/src/main.rs

@@ -89,6 +89,7 @@ impl NyashWorkDone {
 enum NyashReq {
     NyashWorkRequest(NyashWorkRequest),
     NyashWorkDone(NyashWorkDone),
+    StatsRequest,
 }
 
 
@@ -174,9 +175,6 @@ impl NyashNoWorkResp {
     }
 }
 
-
-
-
 enum NyashResp {
     NyashWorkResp(NyashWorkResp),
     NyashErrorResp(NyashErrorResp),
@@ -188,6 +186,7 @@ fn parse_message(mut it: std::str::Split<'_, &str>) -> Result<NyashReq, Protocol
     match code {
         NyashWorkRequest::HEADER => Ok(NyashReq::NyashWorkRequest(NyashWorkRequest::from_msg(it)?)),
         NyashWorkDone::HEADER => Ok(NyashReq::NyashWorkDone(NyashWorkDone::from_msg(it)?)),
+        "STATS" => Ok(NyashReq::StatsRequest),
         _ => Err(ProtocolParseError::WrongFormat(0))
     }
 }
@@ -254,6 +253,9 @@ async fn handle_connection(stream: TcpStream, db: &redb::Database) {
                                 }
                             }
                         }
+                    },
+                    Ok(NyashReq::StatsRequest) => {
+
                     },
                     Err(ex) => println!("Error sending message: {:?}", ex)
                 }
@@ -271,6 +273,7 @@ async fn handle_connection(stream: TcpStream, db: &redb::Database) {
 
 
 async fn accept_loop(listener: TcpListener, db: redb::Database) {
+    
     while let Ok((stream, _)) = listener.accept().await {
         // Spawn a new task for each connection
         handle_connection(stream, &db).await;

nyash_server/src/num_utils.rs

@@ -13,6 +13,16 @@ fn u128_to_u32arr(a: u128) -> [u32;4] {
     return res;
 }
 
+pub fn u128_to_u64arr(a: u128) -> [u64;2] {
+    let mut res = [0u64;2];
+    let a_bytes = a.to_le_bytes();
+    let chunks = a_bytes.as_chunks::<8>().0;
+    for i in 0..2 {
+        res[i] = u64::from_le_bytes(chunks[i]);
+    }
+    return res;
+}
+
 pub fn add_u128_to_u256(a: &[u32; 8], b: u128) -> ([u32; 8], bool) {
     let mut res: [u32; 8] = [0; 8];
     let mut carry = false;

nyash_server/src/server.rs

@@ -0,0 +1,82 @@
+
+use redb;
+
+use tonic::{transport::Server, Request, Response, Status};
+
+use nyash_server::nyash_luks_server::{NyashLuks, NyashLuksServer};
+use nyash_server::{WorkRequest, WorkData, WorkReply, work_reply, WorkCommit, CommitReply, ProgressRequest, ProgressReply};
+
+pub mod nyash_server {
+    tonic::include_proto!("nyash_server"); // The string specified here must match the proto package name
+}
+
+mod database;
+mod num_utils;
+
+fn work_rec_to_work_data(work_rec: database::JobRecord) -> WorkData {
+    let tw_key = num_utils::u128_to_u64arr(work_rec.tweak_key);
+    let st_key = num_utils::u128_to_u64arr(work_rec.start_key);
+    WorkData {
+        work_id: work_rec.id,
+        work_size: work_rec.len,
+        // tweak key is 128 bit. We send it as two uint64 values
+        tweak_key0: tw_key[0],
+        tweak_key1: tw_key[1],
+        // start key is 128 bit. We send it as two uint64 values
+        start_key0: st_key[0],
+        start_key1: st_key[1],
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct NyashService {
+    db: redb::Database,
+}
+
+#[tonic::async_trait]
+impl NyashLuks for NyashService {
+    async fn request_work(&self, request: Request<WorkRequest>) -> Result<Response<WorkReply>, Status> { 
+        println!("Got a request: {:?}", request);
+        let pref_work_size: u64 = request.into_inner().pref_work_size;
+        match database::db_create_job(&self.db, pref_work_size) {
+            Ok(Some(work_rec)) => {
+                let reply = WorkReply {
+                    result: Some(work_reply::Result::WorkData(work_rec_to_work_data(work_rec))),
+                };
+                Ok(Response::new(reply)) // Send back our formatted greeting
+            },
+            Ok(None) => {
+                let reply = WorkReply {
+                    result: Some(work_reply::Result::NoWork(true)),
+                };
+                Ok(Response::new(reply))
+            },
+            Err(_ex) => {
+                let reply = WorkReply {
+                    result: Some(work_reply::Result::Error("DB Error!".to_string())),
+                };
+                Ok(Response::new(reply))
+            }
+        }        
+    }
+
+    async fn commit_work(&self, request: Request<WorkCommit>) -> Result<Response<CommitReply>, Status> {
+        println!("Got a request: {:?}", request);
+        let work_id: u64 = request.into_inner().work_id;
+        
+    }
+}
+
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let addr = "[::1]:50051".parse()?;
+    let greeter = MyGreeter::default();
+
+    Server::builder()
+        .add_service(GreeterServer::new(greeter))
+        .serve(addr)
+        .await?;
+
+    Ok(())
+}