test: add global config end-to-end test

Signed-off-by: Kouame Behouba Manasse <[email protected]>

Author: behouba

tests/e2e_criu.rs

@@ -145,6 +145,90 @@ fn setup(port: u16) -> Vec<TestProcess> {
     processes
 }
 
+fn setup_with_global_config(port: u16) -> Vec<TestProcess> {
+    println!("Setting up test environment with global config");
+
+    let make_status = Command::new("make")
+        .current_dir("tests")
+        .status()
+        .expect("Failed to run `make` in tests directory");
+    assert!(make_status.success(), "make command failed");
+
+    fs::create_dir_all("/etc/criu").expect("Failed to create /etc/criu directory");
+
+    // Create the global configuration file
+    let global_config_path = "/etc/criu/criu-coordinator.json";
+    let mut config_file =
+        fs::File::create(global_config_path).expect("Failed to create global config file");
+    let config_content = format!(
+        r#"{{
+            "address": "127.0.0.1",
+            "port": "{port}",
+            "log-file": "/tmp/criu-coordinator-global.log",
+            "dependencies": {{
+                "loop-1": ["loop-2", "loop-3"],
+                "loop-2": ["loop-1", "loop-3"],
+                "loop-3": ["loop-1", "loop-2"]
+            }}
+        }}"#
+    );
+
+    config_file
+        .write_all(config_content.as_bytes())
+        .expect("Failed to write to global config file");
+    println!("Created global config at {global_config_path}");
+
+    let mut processes = vec![];
+    let p_names = ["loop-1", "loop-2", "loop-3"];
+
+    for name in p_names.iter() {
+        let image_dir = env::temp_dir().join(format!(
+            "criu-e2e-test-global-{}-{}",
+            name,
+            std::process::id()
+        ));
+        let _ = fs::remove_dir_all(&image_dir);
+        fs::create_dir_all(&image_dir).expect("Failed to create image directory");
+
+        let dependencies: Vec<String> = p_names
+            .iter()
+            .filter(|&p| p != name)
+            .map(|&s| s.to_string())
+            .collect();
+
+        let mut command = Command::new(format!("./tests/{name}"));
+        command
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .stdin(Stdio::null());
+
+        unsafe {
+            command.pre_exec(|| {
+                if libc::setsid() == -1 {
+                    return Err(std::io::Error::last_os_error());
+                }
+                Ok(())
+            });
+        }
+
+        let child = command
+            .spawn()
+            .unwrap_or_else(|_| panic!("Failed to spawn process {}", name));
+        let pid = child.id();
+
+        processes.push(TestProcess {
+            id: name.to_string(),
+            child: Some(child),
+            pid,
+            image_dir,
+            _dependencies: dependencies,
+        });
+        println!("Spawned '{name}' with PID {pid}");
+    }
+    thread::sleep(Duration::from_millis(500));
+    processes
+}
+
 fn cleanup(server: &mut Child, processes: &mut [TestProcess]) {
     println!("\n--- Cleaning up test environment ---");
     let _ = server.kill();
@@ -172,6 +256,13 @@ fn cleanup(server: &mut Child, processes: &mut [TestProcess]) {
         let _ = fs::remove_dir_all(&p.image_dir);
     }
 
+    // Clean up global config file and directory
+    let global_config_path = PathBuf::from("/etc/criu/criu-coordinator.json");
+    if global_config_path.exists() {
+        fs::remove_file(&global_config_path).expect("Failed to remove global config file");
+        println!("Removed global config file.");
+    }
+
     let make_clean_status = Command::new("make")
         .arg("clean")
         .current_dir("tests")
@@ -307,6 +398,47 @@ fn setup_tcp_test(coordinator_port: u16, tcp_server_port: u16) -> Vec<TestProces
     processes
 }
 
+fn check_tcp_connection(server_pid: u32, client_pid: u32, server_port: u16) -> bool {
+    let output = match Command::new("ss").args(["-tpen"]).output() {
+        Ok(out) => out,
+        Err(e) => {
+            println!("Failed to execute 'ss' command: {e}. Is it installed?");
+            return false;
+        }
+    };
+
+    if !output.status.success() {
+        println!("'ss' command failed with status: {}", output.status);
+        return false;
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let server_pid_str = format!("pid={server_pid}");
+    let client_pid_str = format!("pid={client_pid}");
+    let server_port_str = format!(":{server_port}");
+
+    // We expect to find two entries for the connections for each process.
+    let server_conn_found = stdout.lines().any(|line| {
+        line.contains("ESTAB") && line.contains(&server_port_str) && line.contains(&server_pid_str)
+    });
+
+    let client_conn_found = stdout.lines().any(|line| {
+        line.contains("ESTAB") && line.contains(&server_port_str) && line.contains(&client_pid_str)
+    });
+
+    if !server_conn_found || !client_conn_found {
+        println!("Could not verify established TCP connection via 'ss'.");
+        if !server_conn_found {
+            println!("Did not find connection for server PID {server_pid} on port {server_port}");
+        }
+        if !client_conn_found {
+            println!("Did not find connection for client PID {client_pid} to port {server_port}");
+        }
+    }
+
+    server_conn_found && client_conn_found
+}
+
 #[test]
 #[ignore] // requires require root privileges (make test-e2e)
 fn e2e_dump_and_restore_with_criu() {
@@ -317,7 +449,7 @@ fn e2e_dump_and_restore_with_criu() {
 
     assert!(is_criu_installed(), "CRIU command not found in PATH");
 
-    let coordinator_path = fs::canonicalize("target/debug/criu-coordinator")
+    let coordinator_path = fs::canonicalize(CRIU_COORDINATOR_PATH)
         .expect("Could not find criu-coordinator binary. Run 'cargo build' first.")
         .to_str()
         .unwrap()
@@ -418,48 +550,134 @@ fn e2e_dump_and_restore_with_criu() {
     }
 }
 
+#[test]
+#[ignore]
+fn e2e_dump_and_restore_with_global_config() {
+    assert!(
+        is_root(),
+        "This test must be run with root privileges for 'criu' and to write to /etc."
+    );
+    assert!(is_criu_installed(), "CRIU command not found in PATH");
 
-fn check_tcp_connection(server_pid: u32, client_pid: u32, server_port: u16) -> bool {
-    let output = match Command::new("ss").args(["-tpen"]).output() {
-        Ok(out) => out,
-        Err(e) => {
-            println!("Failed to execute 'ss' command: {e}. Is it installed?");
-            return false;
-        }
-    };
+    let coordinator_path = fs::canonicalize(CRIU_COORDINATOR_PATH)
+        .expect("Could not find criu-coordinator binary. Run 'cargo build' first.")
+        .to_str()
+        .unwrap()
+        .to_owned();
 
-    if !output.status.success() {
-        println!("'ss' command failed with status: {}", output.status);
-        return false;
-    }
+    let port = pick_port();
+    let addr = format!("127.0.0.1:{port}");
+    let server = spawn_server(port);
+    assert!(
+        server_ready(&addr, 20),
+        "Server failed to start at {}",
+        addr
+    );
 
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let server_pid_str = format!("pid={server_pid}");
-    let client_pid_str = format!("pid={client_pid}");
-    let server_port_str = format!(":{server_port}");
+    let processes = setup_with_global_config(port);
+    let mut _guard = TestGuard { server, processes };
 
-    // We expect to find two entries for the connections for each process.
-    let server_conn_found = stdout.lines().any(|line| {
-        line.contains("ESTAB") && line.contains(&server_port_str) && line.contains(&server_pid_str)
-    });
+    println!("\n--- Starting checkpoint phase (global config) ---");
+    let mut dump_handles = vec![];
+    for p in &_guard.processes {
+        let coordinator_path_clone = coordinator_path.clone();
+        let p_id = p.id.clone();
+        let p_pid = p.pid;
+        let p_image_dir = p.image_dir.clone();
+        dump_handles.push(thread::spawn(move || {
+            let out = Command::new("sudo")
+                .args([
+                    "criu",
+                    "dump",
+                    "-t",
+                    &p_pid.to_string(),
+                    "-D",
+                    p_image_dir.to_str().unwrap(),
+                    "-j",
+                    "-v4",
+                    "--action-script",
+                    &coordinator_path_clone,
+                ])
+                .output()
+                .expect("failed to execute criu");
+            (p_id, out)
+        }));
+    }
 
-    let client_conn_found = stdout.lines().any(|line| {
-        line.contains("ESTAB") && line.contains(&server_port_str) && line.contains(&client_pid_str)
-    });
+    for handle in dump_handles {
+        let (id, output) = handle.join().unwrap();
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        assert!(
+            output.status.success() && stderr.contains("Dumping finished successfully"),
+            "CRIU failed for process '{}' with global config.\nStderr:\n{}",
+            id,
+            stderr
+        );
+        println!("Checkpoint successful for {id}");
+    }
 
-    if !server_conn_found || !client_conn_found {
-        println!("Could not verify established TCP connection via 'ss'.");
-        if !server_conn_found {
-            println!("Did not find connection for server PID {server_pid} on port {server_port}");
-        }
-        if !client_conn_found {
-            println!("Did not find connection for client PID {client_pid} to port {server_port}");
+    println!("\n--- REAPING checkpointed processes (global config) ---");
+    for p in &mut _guard.processes {
+        if let Some(mut child) = p.child.take() {
+            match child.wait() {
+                Ok(status) => println!(
+                    "Reaped process {} (PID {}) with exit status: {}",
+                    p.id, p.pid, status
+                ),
+                Err(e) => eprintln!("Error reaping process {} (PID {}): {}", p.id, p.pid, e),
+            }
         }
     }
 
-    server_conn_found && client_conn_found
-}
+    thread::sleep(Duration::from_millis(500));
+    println!("\n--- Starting restore phase (global config) ---");
+    let mut restore_handles = vec![];
+    for p in &_guard.processes {
+        let coordinator_path_clone = coordinator_path.clone();
+        let p_id = p.id.clone();
+        let p_image_dir = p.image_dir.clone();
+        restore_handles.push(thread::spawn(move || {
+            let out = Command::new("sudo")
+                .args([
+                    "criu",
+                    "restore",
+                    "-D",
+                    p_image_dir.to_str().unwrap(),
+                    "-d",
+                    "-v4",
+                    "--action-script",
+                    &coordinator_path_clone,
+                ])
+                .output()
+                .expect("failed to execute criu restore");
+            (p_id, out)
+        }));
+    }
 
+    for handle in restore_handles {
+        let (id, output) = handle.join().unwrap();
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        assert!(
+            output.status.success() && stderr.contains("Restore finished successfully"),
+            "CRIU restore failed for process '{}' with global config.\nStderr:\n{}",
+            id,
+            stderr
+        );
+        println!("Restore successful for {id}");
+    }
+
+    thread::sleep(Duration::from_millis(500));
+
+    println!("\n--- VERIFYING restored processes (global config) ---");
+    for p in &_guard.processes {
+        assert!(
+            get_pid_by_name(&p.id).is_some(),
+            "Process {} was not found running after restore.",
+            p.id
+        );
+        println!("Verified process {} is running.", p.id);
+    }
+}
 
 #[test]
 #[ignore] // requires require root privileges (make test-e2e)