qq-cli 0.1.0

A modular Rust QQ task interface for coding agents
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use super::*;
use std::collections::BTreeMap;
use std::ffi::OsString;
use std::time::Duration;
fn deadline() -> Instant {
    Instant::now() + Duration::from_secs(10)
}

#[test]
fn named_job_reopen_requires_a_live_handle_and_closing_handles_keeps_child_alive() {
    const MODE: &str = "QQ_CLI_TEST_NAMED_JOB_CHILD";
    if let Some(root) = std::env::var_os(MODE) {
        let root = std::path::PathBuf::from(root);
        let until = Instant::now() + Duration::from_secs(15);
        while !root.join("release").exists() && Instant::now() < until {
            std::thread::sleep(Duration::from_millis(10));
        }
        return;
    }
    let temp = tempfile::tempdir().unwrap();
    struct Release(std::path::PathBuf);
    impl Drop for Release {
        fn drop(&mut self) {
            let _ = std::fs::write(&self.0, b"original release");
        }
    }
    let release = Release(temp.path().join("release"));
    let guard_job = Job::create(deadline()).unwrap();
    let mut environment =
        BTreeMap::from([(OsString::from(MODE), temp.path().as_os_str().to_owned())]);
    if let Some(system) = std::env::var_os("SystemRoot") {
        environment.insert("SYSTEMROOT".into(), system);
    }
    let executable = std::env::current_exe().unwrap();
    let arguments = ["--exact".into(),"native::job::tests::named_job_reopen_requires_a_live_handle_and_closing_handles_keeps_child_alive".into(),"--test-threads=1".into()];
    let child = guard_job
        .spawn(
            &SpawnSpec {
                program: &executable,
                arguments: &arguments,
                environment: &environment,
                directory: temp.path(),
            },
            deadline(),
        )
        .unwrap();
    let stage = std::cell::Cell::new("create");
    let result = (|| -> Result<()> {
        let job = Job::create(deadline())?;
        assert!(job.members(deadline())?.is_empty());
        let id = job.id().clone();
        // Test child cooperatively waits before doing anything. This is NOT an
        // atomic spawn containment implementation and is never used by product startup.
        stage.set("assign");
        job.assign_test_child(child.process())?;
        stage.set("observe");
        let process = Pinned::observe(child.process().identity().process_id(), deadline())?;
        stage.set("contains");
        assert!(job.contains(&process, deadline())?);
        assert_eq!(
            job.members(deadline())?,
            vec![process.identity().process_id()]
        );
        stage.set("other");
        let other = Job::create(deadline())?;
        assert!(!other.contains(&process, deadline())?);
        assert!(Job::create_named(id.clone(), deadline()).is_err());
        stage.set("reopen");
        let reopened = Job::reopen(&id, deadline())?;
        assert!(reopened.contains(&process, deadline())?);
        // Reopened handle has QUERY only: even assigning an already-member child is denied.
        assert!(reopened.assign_test_child(child.process()).is_err());
        drop(other);
        drop(job);
        process.verify(deadline())?;
        assert!(Job::reopen(&id, deadline())?.contains(&process, deadline())?);
        drop(reopened);
        process.verify(deadline())?;
        // Native observation: process membership keeps the object alive but
        // does not retain its namespace entry after the last handle closes.
        assert!(Job::reopen(&id, deadline()).is_err());
        std::fs::write(temp.path().join("release"), b"original release").unwrap();
        let until = deadline();
        loop {
            if child.process().verify(deadline()).is_err() {
                break;
            }
            assert!(Instant::now() < until, "original child timed out");
            std::thread::sleep(Duration::from_millis(10));
        }
        assert!(Job::reopen(&id, deadline()).is_err());
        Ok(())
    })();
    drop(release);
    assert!(
        result.is_ok(),
        "original Job stage {}: {:?}",
        stage.get(),
        result.err()
    );
}

#[test]
fn empty_job_disappears_and_invalid_or_expired_ids_do_not_open_objects() {
    let job = Job::create(deadline()).unwrap();
    let id = job.id().clone();
    assert!(
        Job::reopen(&id, deadline())
            .unwrap()
            .members(deadline())
            .unwrap()
            .is_empty()
    );
    drop(job);
    assert!(Job::reopen(&id, deadline()).is_err());
    for name in [
        "",
        "Global\\foreign",
        "Local\\qq-cli-123",
        "Local\\qq-cli-../../foreign",
    ] {
        let id = JobId(name.into());
        assert!(Job::reopen(&id, deadline()).is_err());
    }
    assert_eq!(Job::create(Instant::now()).err().unwrap().code, "DEADLINE");
    assert_eq!(
        Job::reopen(&JobId("invalid".into()), Instant::now())
            .err()
            .unwrap()
            .code,
        "DEADLINE"
    );
}