More networking work, adding found keys saving.

nyash_server/proto/nyash.proto

@@ -73,11 +73,6 @@ message ProgressRequest {
 }
 
 message ProgressReply {
-    // Status code 
-    // 0 - means ok
-    // 1 - something went wrong on server
-    // 2 - something wrong with request
-    uint32 status_code = 1;
     // Brutforce progress as ratio from 0 to 1(completed)
     double progress = 2;
 }

nyash_server/src/database.rs

@@ -17,6 +17,8 @@ const COMPLETED_RANGES: TableDefinition<u128, u128> = TableDefinition::new("comp
 const JOBS_TABLE: TableDefinition<u64, (u16, u128, u128, u64, u64)> = TableDefinition::new("jobs");
 const JOBS_FREE_IDS: TableDefinition<u64, ()> = TableDefinition::new("jobs_free_ids");
 
+const FOUND_KEYS_TABLE: TableDefinition<(u128, u128), u64> = TableDefinition::new("found_keys");
+
 // get time is seconds
 fn get_timestump() -> u64 {
     use std::time::{SystemTime, UNIX_EPOCH};
@@ -444,6 +446,45 @@ pub fn db_commit_job(db: &Database, job_id: u64) -> Result<bool, redb::Error> {
 }
 
 
+#[derive(Copy, Clone, Debug)]
+pub struct FoundKey {
+    pub tweak_key: u128,
+    pub enc_key: u128,
+    pub timestump: u64
+}
+pub fn db_get_found_keys(db: &Database) -> Result<Vec<FoundKey>, redb::Error> {
+    let trx: redb::ReadTransaction = db.begin_read()?;
+    let mut res:Vec<FoundKey> = Vec::new();
+
+    {
+        let found_keys_t = trx.open_table(FOUND_KEYS_TABLE)?;
+        
+        for found_key_res in found_keys_t.iter()? {
+            let ag = found_key_res?;
+            res.push(FoundKey{
+                tweak_key: ag.0.value().0,
+                enc_key: ag.0.value().1,
+                timestump: ag.1.value(),
+            });
+        }
+    }
+    
+    return Ok(res);
+}
+
+pub fn db_put_found_key(db: &Database, tw_k: u128, en_k: u128) -> Result<u64, redb::Error> {
+    
+    let trx: redb::WriteTransaction = db.begin_write()?;
+    let new_keys_count = {
+        let mut found_keys_t = trx.open_table(FOUND_KEYS_TABLE)?;
+        found_keys_t.insert((tw_k,en_k), get_timestump());
+        found_keys_t.len()?
+    };
+    trx.commit();
+
+    return Ok(new_keys_count);
+}
+
 pub fn db_get_progress(db: &Database) -> Result<f64, redb::Error> {
     let trx: redb::ReadTransaction = db.begin_read()?;
     let progress = {

nyash_server/src/num_utils.rs

@@ -3,6 +3,8 @@
 //     i: [u32; 2],
 // }
 
+use prost::bytes::BufMut;
+
 fn u128_to_u32arr(a: u128) -> [u32;4] {
     let mut res = [0u32;4];
     let a_bytes = a.to_le_bytes();
@@ -23,6 +25,14 @@ pub fn u128_to_u64arr(a: u128) -> [u64;2] {
     return res;
 }
 
+pub fn u64arr_to_u128(a:(u64,u64)) -> u128 {
+    let mut bytes_data: [u8; 16] = [0u8;16];
+    bytes_data[0..8].copy_from_slice(a.0.to_le_bytes().as_slice());
+    bytes_data[8..].copy_from_slice(a.1.to_le_bytes().as_slice());
+
+    return u128::from_le_bytes(bytes_data);
+}
+
 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

@@ -31,6 +31,7 @@ fn work_rec_to_work_data(work_rec: database::JobRecord) -> WorkData {
 #[derive(Debug, Default)]
 pub struct NyashService {
     db: redb::Database,
+    progress: f64,
 }
 
 #[tonic::async_trait]
@@ -63,7 +64,15 @@ impl NyashLuks for NyashService {
     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;
+        match database::db_commit_job(&self.db, work_id) {
+            Ok(true) => Ok(Response::new(CommitReply {status_code: 0, progress: self.progress})),
+            Ok(false) => Ok(Response::new(CommitReply {status_code: 1, progress: self.progress})),
+            Err(_) => Err(Status::internal("DB error"))
+        }
+    }
 
+    async fn request_progress(&self, _request: Request<ProgressRequest>) -> Result<Response<ProgressReply>, Status> {
+        Ok(Response::new(ProgressReply {progress: self.progress}))
     }
 }