implement Copy comand

Author: Simone Mosciatti

engine_pro

@@ -489,6 +489,11 @@ pub enum Command {
         arguments: Vec<&'static str>,
         client: BlockedClient,
     },
+    Copy {
+        source: Arc<Mutex<sql::RawConnection>>,
+        destination: Arc<Mutex<sql::RawConnection>>,
+        client: BlockedClient,
+    },
 }
 
 pub enum QueryResult {
@@ -721,6 +726,20 @@ pub fn listen_and_execute<'a, L: 'a + LoopData>(
                     },
                 );
             }
+            Ok(Command::Copy {
+                source,
+                destination,
+                client,
+            }) => {
+                let source = source.lock().unwrap();
+                let destination = destination.lock().unwrap();
+                let result = match make_backup(&source, &destination)
+                {
+                    Err(e) => Err(RediSQLError::from(e)),
+                    Ok(_) => Ok(QueryResult::OK {}),
+                };
+                return_value(&client, result);
+            }
             Ok(Command::Stop) => {
                 debug!("Stop, exiting from work loop");
                 return;
@@ -1020,7 +1039,8 @@ pub fn get_dbkey_from_name(
     name: &str,
 ) -> Result<DBKey, i32> {
     let dbptr = get_dbkeyptr_from_name(ctx, name)?;
-    Ok(unsafe { dbptr.read() })
+    let dbkey = unsafe { dbptr.read() };
+    Ok(dbkey)
 }
 
 pub fn with_ch_and_loopdata<F>(

redisql_lib/src/redis.rs

@@ -806,14 +806,13 @@ unsafe extern "C" fn rdb_load(
     }
 }
 
-// TODO attention with the metadata table
-// What should happen?
 #[allow(non_snake_case)]
 extern "C" fn Backup(
     ctx: *mut r::rm::ffi::RedisModuleCtx,
     argv: *mut *mut r::rm::ffi::RedisModuleString,
     argc: ::std::os::raw::c_int,
 ) -> i32 {
+    debug!("Backup | Start");
     let (context, argvector) = r::create_argument(ctx, argv, argc);
 
     if argvector.len() != 3 {
@@ -857,18 +856,38 @@ extern "C" fn Backup(
     }
     let dest_db = dest_db.unwrap();
 
-    let source_connection = &source_db.loop_data.get_db();
-    let dest_connection = &dest_db.loop_data.get_db();
+    let blocked_client = r::rm::BlockedClient {
+        client: unsafe {
+            r::rm::ffi::RedisModule_BlockClient.unwrap()(
+                context.as_ptr(),
+                Some(reply_create_statement),
+                Some(timeout),
+                Some(free_privdata),
+                10000,
+            )
+        },
+    };
 
-    let source_connection = source_connection.lock().unwrap();
-    let dest_connection = dest_connection.lock().unwrap();
+    let source_connection = source_db.loop_data.get_db();
+    let dest_connection = dest_db.loop_data.get_db();
 
-    match r::make_backup(&source_connection, &dest_connection) {
-        Err(e) => e.reply(&context),
-        _ => {
-            let ok = r::QueryResult::OK {};
-            ok.reply(&context)
+    let cmd = r::Command::Copy {
+        source: source_connection,
+        destination: dest_connection,
+        client: blocked_client,
+    };
+
+    let ch = &source_db.tx.clone();
+    std::mem::forget(source_db);
+    std::mem::forget(dest_db);
+
+    debug!("Backup | End");
+    match ch.send(cmd) {
+        Ok(()) => {
+            debug!("Backup | Successfully send command");
+            r::rm::ffi::REDISMODULE_OK
         }
+        Err(_) => r::rm::ffi::REDISMODULE_OK,
     }
 }