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

//! Recover the existing signed control binding; never discover, repair or retain a process.
use super::{
    Outcome, ServiceRun, conflict,
    journal::{load, path},
    unknown,
};
use crate::core::error::{AppError, Result};
use crate::native::{job::Job, process::Pinned};
use crate::storage::{
    references::References,
    state::{Installation, Instance, Transaction},
};
use std::time::Instant;

pub struct ControlRun {
    service: ServiceRun,
    endpoint: String,
}
impl ControlRun {
    pub fn service(&self) -> &ServiceRun {
        &self.service
    }
    pub fn endpoint(&self) -> &str {
        &self.endpoint
    }
}
pub fn reopen_control(
    tx: &Transaction<'_>,
    refs: &References,
    instance: &Instance,
    installation: &Installation,
    deadline: Instant,
) -> Result<ControlRun> {
    crate::core::deadline::check(deadline)?;
    if tx
        .registry
        .instances
        .iter()
        .filter(|i| i.id == instance.id)
        .count()
        != 1
        || !tx.registry.instances.iter().any(|i| i == instance)
        || tx
            .registry
            .installations
            .iter()
            .filter(|i| i.id == installation.id)
            .count()
            != 1
        || !tx.registry.installations.iter().any(|i| i == installation)
        || instance.installation_id != installation.id
        || !matches!(
            instance.state.as_str(),
            "starting" | "login_required" | "ready"
        )
    {
        return Err(conflict());
    }
    let record = load(&path(tx.store(), &instance.id, &instance.run_id)?, refs)?;
    if record.outcome != Outcome::Spawned
        || record.target.instance_id != instance.id
        || record.target.run_id != instance.run_id
        || record.target.installation_id != installation.id
        || record.target.installation_digest != installation.digest
    {
        return Err(conflict());
    }
    let unavailable = || {
        AppError::new(
            "CONTROL_NOT_BOUND",
            "This run has no existing signed control binding; no endpoint was probed.",
            4,
        )
    };
    let expected = record.discovery.as_ref().ok_or_else(unavailable)?;
    let endpoint = expected
        .control_endpoint
        .as_deref()
        .ok_or_else(unavailable)?;
    let control = record.prelogin.as_ref().ok_or_else(unavailable)?;
    if expected.endpoint != instance.endpoint
        || control.endpoint != endpoint
        || endpoint == expected.endpoint
        || control.owner.image() != expected.image
        || record
            .service
            .as_ref()
            .is_some_and(|s| s.owner != control.owner || s.endpoint != expected.endpoint)
    {
        return Err(conflict());
    }
    crate::transport::client::Endpoint::parse(endpoint)?;
    let job = Job::reopen(&record.job, deadline)?;
    let owner = Pinned::reopen(&control.owner, deadline)?;
    if !job.contains(&owner, deadline)? {
        return Err(conflict());
    }
    let retained = crate::napcat::runtime::retention::existing(
        tx,
        refs,
        &instance.id,
        &instance.run_id,
        &job,
        &owner,
        deadline,
    )?;
    if retained.outcome() != crate::napcat::runtime::retention::Outcome::Retained {
        return Err(unknown());
    }
    crate::core::deadline::check(deadline)?;
    Ok(ControlRun {
        service: ServiceRun { job, owner },
        endpoint: endpoint.into(),
    })
}