Files
rust-discovery/crates/agent-windows/examples/windows_quiescent_stop.rs
T

533 lines
28 KiB
Rust

//! One reviewed development bootstrap: normal stop of the exact old agent,
//! while an existing SQLite reservation excludes a new Sync/permit journal
//! commit. No job, approval, SQL row change, helper stop, reset or force kill.
#[cfg(all(windows, feature = "system-helper"))]
mod platform {
use anyhow::{Context, Result, ensure};
use prost::Message;
use rmm_agent_core::{
auth::{Binding, Outcome, Request},
crypto::DalekVerifier,
helper_reconcile::SignedResponse,
reconcile::{Channel, verify_response_with},
};
use rmm_agent_windows::{
helper_ipc::{self as ipc, PeerProof, PinnedFile},
native,
};
use rmm_domain::{jobs::hash, reconciliation::ReconcileDecisionPayload};
use rmm_protocol::{SyncRequest, SyncResponse,Envelope,Payload};
use rusqlite::{Connection, OpenFlags};
use serde_json::json;
use std::{
fs::{File, OpenOptions},
io::{Read, Write},
mem::{size_of, zeroed},
os::windows::fs::OpenOptionsExt,
path::Path,
ptr,
time::{Duration, Instant},
};
use uuid::Uuid;
use windows_sys::Win32::{
Foundation::*, Security::*, Storage::FileSystem::*, System::Services::*,
};
const AGENT: &str = "9651b2e518b315029cebfa432261a57f0a305aeddde29c56ac22a5ccbc417b32";
const HELPER: &str = "59675a3cbb3a5d213fc764f38379d6b81baaf9d47a7124470cc2767d4985763e";
const PIN: &str = "9d46dffe88f565b8b04554335d9669f5c83211b32419908a579b1cd4560443ec";
const SETTINGS: &str = "4c073cd3d4badb09d8c0f1c270b4cee9df533df416550f68bf3e336e3da7673c";
const CONFIG: &str = "5cd4cb9802d0dd20b961de7e3cd4e5874a1e9a72fc57b577e075e2d2918baac6";
const CASE: &str = "c6c80ac4-a52e-4b69-8170-466bcf52049d";
const JOB: &str = "0a50aae9-a784-4535-b62f-ef24c301d546";
const ATTEMPT: &str = "78295f74-4565-459a-87b0-641a8b95feec";
const AGENT_STATE: &str = r"C:\ProgramData\RustDiscovery\state";
const HELPER_STATE: &str = r"C:\ProgramData\RustDiscoverySystem\state";
struct Handle(SC_HANDLE);
impl Drop for Handle {
fn drop(&mut self) {
unsafe {
CloseServiceHandle(self.0);
}
}
}
fn admin() -> Result<()> {
let mut sid = [0usize; 16];
let mut len = std::mem::size_of_val(&sid) as u32;
let mut member = 0;
ensure!(
unsafe {
CreateWellKnownSid(
WinBuiltinAdministratorsSid,
ptr::null_mut(),
sid.as_mut_ptr().cast(),
&mut len,
)
} != 0
&& unsafe {
CheckTokenMembership(ptr::null_mut(), sid.as_mut_ptr().cast(), &mut member)
} != 0
&& member != 0,
"QUIESCENT_ADMIN_REQUIRED"
);
Ok(())
}
fn service(stop:bool) -> Result<Handle> {
let manager =
Handle(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) });
ensure!(!manager.0.is_null(), "QUIESCENT_SCM_MANAGER");
let h = Handle(unsafe {
OpenServiceW(
manager.0,
ipc::wide(rmm_agent_windows::SERVICE_NAME).as_ptr(),
SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG | if stop {SERVICE_STOP}else{0},
)
});
ensure!(!h.0.is_null(), "QUIESCENT_SCM_AGENT");
Ok(h)
}
fn status(h: &Handle) -> Result<SERVICE_STATUS_PROCESS> {
let mut s = unsafe { zeroed() };
let mut n = 0;
ensure!(
unsafe {
QueryServiceStatusEx(
h.0,
SC_STATUS_PROCESS_INFO,
(&mut s as *mut SERVICE_STATUS_PROCESS).cast(),
size_of::<SERVICE_STATUS_PROCESS>() as u32,
&mut n,
)
} != 0,
"QUIESCENT_SCM_STATUS"
);
Ok(s)
}
fn protected(path: &Path, readers: &[String], expected: &str) -> Result<(PinnedFile, Vec<u8>)> {
let mut file = PinnedFile::open(path, false, readers, &[], false)?;
ensure!(
file.file.metadata()?.len() <= 65536,
"QUIESCENT_PUBLIC_FILE_LIMIT"
);
let mut raw = Vec::new();
(&mut file.file).take(65537).read_to_end(&mut raw)?;
ensure!(
raw.len() <= 65536 && hash(&raw) == expected,
"QUIESCENT_PUBLIC_HASH"
);
file.check()?;
Ok((file, raw))
}
fn hold_agent(path: &Path) -> Result<File> {
native::private_path(path, false)?;
Ok(OpenOptions::new()
.read(true)
.share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
.open(path)?)
}
fn check_id(file: &File, path: &Path) -> Result<()> {
let actual = hold_agent(path)?;
ensure!(
ipc::file_identity(file)? == ipc::file_identity(&actual)?,
"QUIESCENT_DATABASE_REPLACED"
);
Ok(())
}
fn receipt(dir: &Path, name: &str, value: &serde_json::Value) -> Result<()> {
let bytes = serde_json::to_vec(value)?;
ensure!(bytes.len() <= 16384, "QUIESCENT_RECEIPT_LIMIT");
let path = dir.join(name);
let mut f = OpenOptions::new()
.write(true)
.create_new(true)
.share_mode(FILE_SHARE_READ)
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH)
.open(&path)?;
f.write_all(&bytes)?;
f.sync_all()?;
drop(f);
let mut read = PinnedFile::open(&path, false, &[], &[], false)?;
ensure!(read.sha256()? == hash(&bytes), "QUIESCENT_RECEIPT_READBACK");
Ok(())
}
struct Idle {
decision: Uuid,
checkpoint: u64,
helper_checkpoint: u64,
request_sha256: String,
response_sha256: String,
original_echo_job: Uuid,
pending_request:Option<String>,
pending_request_sha256:Option<String>,
}
fn idle(
db: &Connection,
consumption: &Connection,
helper: &Connection,
intents: &Connection,
binding: &Binding,
) -> Result<Idle> {
let (journal,checkpoint,generation,last,pending,helper_id,helper_cp,fault):(String,u64,u64,String,Option<String>,String,u64,Option<String>)=db.query_row("SELECT journal_id,checkpoint,generation,last_decision,pending_request,helper_id,helper_checkpoint,fault FROM reconcile_meta WHERE id=1",[],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?,r.get(5)?,r.get(6)?,r.get(7)?)))?;
ensure!(fault.is_none(),"QUIESCENT_AGENT_FAULT");
let (helper_journal, helper_last, helper_fault,helper_agent_cp): (String, String, Option<String>,u64) = helper
.query_row(
"SELECT journal_id,last_decision,fault,agent_checkpoint FROM helper_sync_meta WHERE id=1",
[],
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?,r.get(3)?)),
)?;
ensure!(
helper_fault.is_none() && helper_last == last && helper_journal == helper_id,
"QUIESCENT_HELPER_HEAD_DIFFERS"
);
let (raw_response, raw_request, applied_cp): (Vec<u8>, Vec<u8>, u64) = helper.query_row(
"SELECT response,request,checkpoint FROM helper_sync_decisions WHERE decision_id=?1",
[&last],
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
)?;
ensure!(
applied_cp == helper_cp,
"QUIESCENT_HELPER_APPLIED_CHECKPOINT"
);
let signed: SignedResponse = serde_json::from_slice(&raw_response)?;
let parsed: ReconcileDecisionPayload = serde_json::from_slice(&signed.decision_bytes)?;
let (agent_request, agent_response): (Vec<u8>, Vec<u8>) = db.query_row(
"SELECT request,response FROM reconcile_requests WHERE id=?1",
[parsed.request_id.to_string()],
|r| Ok((r.get(0)?, r.get(1)?)),
)?;
let response = SyncResponse::decode(agent_response.as_slice())?;
let request = SyncRequest::decode(agent_request.as_slice())?;
ensure!(
raw_request == agent_request
&& signed.decision_bytes == response.decision_bytes
&& signed.signature == response.signature,
"QUIESCENT_RAW_SIGNED_CONTROL_DIFFERS"
);
let verified = verify_response_with(
&DalekVerifier,
binding,
&request,
&Channel {
connection_generation: parsed.connection_generation,
boot_id: parsed.boot_id,
},
&response,
parsed.issued_at,
)?;
ensure!(
verified.decision_id.to_string() == last
&& verified.journal_id.to_string() == journal
&& verified.checkpoint == helper_agent_cp
&& verified.checkpoint<=checkpoint
&& verified.connection_generation<=generation
&& verified.helper_journal_id.map(|id| id.to_string()) == Some(helper_id.clone())
&& verified.helper_checkpoint == helper_cp
&& verified.ready
&& verified.helper_ready
&& verified.reason == "CONSISTENT",
"QUIESCENT_SIGNED_HEAD_BINDING"
);
let pending_request=if let Some(id)=pending.as_ref() {
let (request_raw,envelope_raw,row_generation,response):(Vec<u8>,Vec<u8>,u64,Option<Vec<u8>>)=db.query_row("SELECT request,envelope,generation,response FROM reconcile_requests WHERE id=?1",[id],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?)))?;
ensure!(response.is_none() && request_raw.len()<=rmm_domain::MAX_MESSAGE && envelope_raw.len()<=rmm_domain::MAX_MESSAGE,"QUIESCENT_ONLY_UNRESPONDED_CONTROL");
let request=SyncRequest::decode(request_raw.as_slice())?;
let envelope=Envelope::decode(envelope_raw.as_slice())?;
ensure!(request.encode_to_vec()==request_raw && envelope.encode_to_vec()==envelope_raw
&& request.request_id==*id && request.journal_id==journal && request.checkpoint==checkpoint
&& request.previous_decision_id==last && request.helper_previous_decision_id==last
&& request.helper_journal_id==helper_id && request.helper_checkpoint>=helper_cp
&& request.assignment_version==binding.assignment_version && request.journal_complete
&& request.durable_message_ids.is_empty() && request.attempts.len()==2
&& row_generation==generation && envelope.connection_generation==generation
&& envelope.agent_id==binding.agent_id.to_string() && envelope.enrollment_generation==binding.enrollment_generation
&& envelope.boot_id==verified.boot_id.to_string() && envelope.sequence==checkpoint
&& rmm_protocol::valid_envelope(&envelope,&binding.agent_id.to_string(),generation)
&& matches!(envelope.payload,Some(Payload::SyncRequest(ref body)) if body==&request),"QUIESCENT_PENDING_CONTROL_BINDING");
Some(request)
}else {
ensure!(verified.checkpoint==checkpoint && verified.connection_generation==generation,"QUIESCENT_WITHOUT_PENDING_EXACT_HEAD");
None
};
let busy:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying','unknown','awaiting_reboot'))",[],|r|r.get(0))?;
ensure!(!busy, "QUIESCENT_EFFECT_PENDING");
let (scope, original) = rmm_agent_windows::echo_probe::archive(db, binding)?
.context("QUIESCENT_ECHO_ARCHIVE_MISSING")?;
ensure!(
rmm_agent_windows::echo_completion::installed(db, binding, &scope, &original)?,
"QUIESCENT_ECHO_COMPLETION_MISSING"
);
let (total,echo,pending_new):(u64,u64,u64)=db.query_row("SELECT count(*),sum(job=?1 AND attempt=?2 AND state='succeeded'),sum(job=?3 AND attempt=?4 AND state IN ('accepted','expired') AND grant_id='') FROM job_attempts",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string(),JOB,ATTEMPT],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?;
ensure!(
total == 2 && echo == 1 && pending_new == 1,
"QUIESCENT_EXPECTED_TWO_JOB_HISTORY"
);
if let Some(request)=&pending_request {
let echo=request.attempts.iter().filter(|r|r.job_id==scope.job_id.to_string() && r.attempt_id==scope.attempt_id.to_string()).collect::<Vec<_>>();
let new=request.attempts.iter().filter(|r|r.job_id==JOB && r.attempt_id==ATTEMPT).collect::<Vec<_>>();
ensure!(echo.len()==1 && new.len()==1,"QUIESCENT_PENDING_EXPECTED_ATTEMPTS");
let old=echo[0];let new=new[0];
let old_grant:String=db.query_row("SELECT grant_id FROM job_attempts WHERE job=?1 AND attempt=?2",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string()],|r|r.get(0))?;
ensure!(old.state=="succeeded" && old.consumption=="consumed" && old.grant_id==old_grant
&& !old.grant_id.is_empty() && old.job_payload_hash==scope.job_payload_hash && old.update_handoff_bytes.is_empty()
&& matches!(new.state.as_str(),"accepted"|"expired") && new.consumption=="unconsumed" && new.grant_id.is_empty()
&& new.update_handoff_bytes.is_empty(),"QUIESCENT_PENDING_NO_NEW_EFFECT");
}
let (total, new): (u64, u64) = consumption.query_row(
"SELECT count(*),COALESCE(sum(job=?1 OR attempt=?2),0) FROM consumed",
[JOB, ATTEMPT],
|r| Ok((r.get(0)?, r.get(1)?)),
)?;
ensure!(total == 1 && new == 0, "QUIESCENT_CONSUMPTION_CHANGED");
let (start,outcome,finished):(Vec<u8>,Vec<u8>,Vec<u8>)=consumption.query_row("SELECT e.start,e.outcome,c.result FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.job=?1 AND c.attempt=?2",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?;
let start: serde_json::Value = serde_json::from_slice(&start)?;
let request: Request = serde_json::from_value(start["request"].clone())?;
let at = serde_json::from_value(start["reserved_at"].clone())?;
let (job, _) = binding.verify_with(&request, at, &DalekVerifier)?;
let o: Outcome = serde_json::from_slice(&outcome)?;
ensure!(
scope.matches_job(&job)
&& o.state == "succeeded"
&& o.evidence["postconditions_passed"] == true
&& outcome == finished,
"QUIESCENT_ORIGINAL_ECHO_EVIDENCE"
);
ensure!(
helper.query_row("SELECT count(*) FROM consumed", [], |r| r.get::<_, u64>(0))? == 0
&& intents.query_row("SELECT count(*) FROM system_intents", [], |r| r
.get::<_, u64>(0))?
== 0,
"QUIESCENT_HELPER_WORK_PRESENT"
);
Ok(Idle {
decision: verified.decision_id,
checkpoint,
helper_checkpoint: helper_cp,
request_sha256: hash(&raw_request),
response_sha256: hash(&raw_response),
original_echo_job: scope.job_id,
pending_request:pending,
pending_request_sha256:pending_request.as_ref().map(|r|hash(&r.encode_to_vec())),
})
}
fn safe_error(error:&anyhow::Error)->serde_json::Value {
for cause in error.chain() {
let text=cause.to_string();
if text.starts_with("QUIESCENT_") && text.bytes().all(|b|b.is_ascii_uppercase()||b==b'_') {return json!({"code":text});}
if let Some(sql)=cause.downcast_ref::<rusqlite::Error>() {
return match sql {
rusqlite::Error::SqliteFailure(code,_)=>json!({"code":"SQLITE_FAILURE","sqlite_code":format!("{:?}",code.code),"extended_code":code.extended_code}),
rusqlite::Error::QueryReturnedNoRows=>json!({"code":"SQLITE_NO_ROWS"}),
rusqlite::Error::InvalidColumnIndex(index)=>json!({"code":"SQLITE_COLUMN_INDEX","index":index}),
rusqlite::Error::InvalidColumnType(index,column,_)=>json!({"code":"SQLITE_COLUMN_TYPE","index":index,"column":column}),
_=>json!({"code":"SQLITE_READ_FAILED"}),
};
}
}
json!({"code":"SIGNED_OR_ARCHIVED_EVIDENCE_CHECK_FAILED"})
}
fn safe_metadata(db:&Connection,consumed:&Connection,helper:&Connection,intents:&Connection)->Result<serde_json::Value> {
let agent=db.query_row("SELECT checkpoint,generation,last_decision,pending_request,helper_checkpoint,fault IS NOT NULL FROM reconcile_meta WHERE id=1",[],|r|Ok(json!({
"checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"pending_request":r.get::<_,Option<String>>(3)?,"helper_checkpoint":r.get::<_,u64>(4)?,"fault_present":r.get::<_,bool>(5)?})))?;
let helper_meta=helper.query_row("SELECT checkpoint,generation,last_decision,fault IS NOT NULL,agent_checkpoint FROM helper_sync_meta WHERE id=1",[],|r|Ok(json!({
"current_capture_checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"fault_present":r.get::<_,bool>(3)?,"agent_checkpoint":r.get::<_,u64>(4)?})))?;
let mut q=db.prepare("SELECT job,attempt,state,grant_id<>'' FROM job_attempts ORDER BY job LIMIT 8")?;
let jobs=q.query_map([],|r|Ok(json!({"job_id":r.get::<_,String>(0)?,"attempt_id":r.get::<_,String>(1)?,"state":r.get::<_,String>(2)?,"grant_present":r.get::<_,bool>(3)?})))?.collect::<rusqlite::Result<Vec<_>>>()?;
let counts=json!({"events":db.query_row("SELECT count(*) FROM events",[],|r|r.get::<_,u64>(0))?,"job_events":db.query_row("SELECT count(*) FROM job_events",[],|r|r.get::<_,u64>(0))?,
"agent_consumed":consumed.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0))?,"agent_execution_evidence":consumed.query_row("SELECT count(*) FROM execution_evidence",[],|r|r.get::<_,u64>(0))?,
"helper_consumed":helper.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0))?,"helper_intents":intents.query_row("SELECT count(*) FROM system_intents",[],|r|r.get::<_,u64>(0))?});
Ok(json!({"agent":agent,"helper":helper_meta,"jobs":jobs,"counts":counts}))
}
pub fn run() -> Result<()> {
let args=std::env::args().skip(1).collect::<Vec<_>>();
let read_only=args==["--read-idle-check"];
ensure!(read_only || args==["--stop-known-idle-agent"],"QUIESCENT_ARGUMENTS");
admin()?;
let bootstrap = PinnedFile::open(
Path::new(r"C:\ProgramData\RustDiscoveryBootstrap"),
true,
&[],
&[],
false,
)?;
let dir = bootstrap.path.join(format!("quiescent-stop-{CASE}"));
let mut dir_guard=if read_only {None}else{
std::fs::create_dir(&dir)?;
Some(PinnedFile::open(&dir,true,&[],&[],false)?)
};
let readers = [
ipc::service_sid(rmm_agent_windows::SERVICE_NAME)?,
ipc::service_sid(ipc::HELPER_SERVICE)?,
];
let (mut pin_guard, raw) = protected(
Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-pin.json"),
&readers,
PIN,
)?;
let pin: ipc::Pin = serde_json::from_slice(&raw)?;
pin.validate()?;
ensure!(
pin.agent.binary_sha256 == AGENT && pin.helper.binary_sha256 == HELPER,
"QUIESCENT_EXACT_PAIR"
);
let (mut settings_guard, _) = protected(
Path::new(r"C:\ProgramData\RustDiscoverySystem\helper.json"),
&readers,
SETTINGS,
)?;
let (mut config_guard, raw) = protected(
Path::new(r"C:\ProgramData\RustDiscovery\config.json"),
&[readers[0].clone()],
CONFIG,
)?;
let cfg: serde_json::Value = serde_json::from_slice(&raw)?;
ensure!(
cfg["enable_jobs"] == true
&& cfg.get("windows_echo_probe_only").is_none_or(|v|v==false)
&& cfg["state_directory"] == AGENT_STATE,
"QUIESCENT_EXACT_CONFIGURATION"
);
let agent_service = service(!read_only)?;
let before = status(&agent_service)?;
ensure!(
before.dwCurrentState == SERVICE_RUNNING,
"QUIESCENT_AGENT_NOT_RUNNING"
);
let mut peer = PeerProof::for_service(&pin.agent, before.dwProcessId)?;
let helper_manager=Handle(unsafe{OpenSCManagerW(ptr::null(),ptr::null(),SC_MANAGER_CONNECT)});
ensure!(!helper_manager.0.is_null(),"QUIESCENT_HELPER_SCM_MANAGER");
let helper_service=Handle(unsafe{OpenServiceW(helper_manager.0,ipc::wide(ipc::HELPER_SERVICE).as_ptr(),SERVICE_QUERY_STATUS|SERVICE_QUERY_CONFIG)});
ensure!(!helper_service.0.is_null(),"QUIESCENT_HELPER_SCM");
let helper_before=status(&helper_service)?;
ensure!(helper_before.dwCurrentState==SERVICE_RUNNING,"QUIESCENT_HELPER_NOT_RUNNING");
let mut helper_peer=PeerProof::for_service(&pin.helper,helper_before.dwProcessId)?;
// Keep original journal/sidecar names and ledger against replacement.
let journal_path = Path::new(AGENT_STATE).join("telemetry.sqlite");
let journal_file = hold_agent(&journal_path)?;
let _wal = hold_agent(&Path::new(AGENT_STATE).join("telemetry.sqlite-wal"))?;
let _shm = hold_agent(&Path::new(AGENT_STATE).join("telemetry.sqlite-shm"))?;
let consumption_path = Path::new(AGENT_STATE).join("consumption.sqlite");
let consumption_file = hold_agent(&consumption_path)?;
let helper_writer = ipc::service_sid(ipc::HELPER_SERVICE)?;
let mut helper_file = PinnedFile::open_read_shared(
&Path::new(HELPER_STATE).join("ledger.sqlite"),
false,
&[],
std::slice::from_ref(&helper_writer),
)?;
let mut intent_file = PinnedFile::open_read_shared(
Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite"),
false,
&[],
&[readers[0].clone()],
)?;
let db = Connection::open_with_flags(&journal_path, if read_only {OpenFlags::SQLITE_OPEN_READ_ONLY}else{OpenFlags::SQLITE_OPEN_READ_WRITE})?;
db.busy_timeout(Duration::from_millis(20))?;
let consumed =
Connection::open_with_flags(&consumption_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
let helper =
Connection::open_with_flags(&helper_file.path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
let intents =
Connection::open_with_flags(&intent_file.path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
if read_only {
let mut observations=Vec::new();
for _ in 0..10 {
db.execute_batch("BEGIN")?;helper.execute_batch("BEGIN")?;
let checked=idle(&db,&consumed,&helper,&intents,&pin.binding);
let metadata=safe_metadata(&db,&consumed,&helper,&intents)?;
let error=checked.as_ref().err().map(safe_error);
helper.execute_batch("ROLLBACK")?;db.execute_batch("ROLLBACK")?;
observations.push(json!({"observed_at":chrono::Utc::now(),"idle_check_passed":checked.is_ok(),"error":error,"metadata":metadata}));
std::thread::sleep(Duration::from_millis(100));
}
peer.check()?;helper_peer.check()?;
println!("{}",serde_json::to_string(&json!({"schema_version":1,"mode":"read_idle_check","read_only":true,"quiescence_reservation_held":false,"stop_requested":false,"case_created":false,"sql_data_changed":false,"samples":observations}))?);
return Ok(());
}
let until = Instant::now() + Duration::from_secs(30);
let locked = loop {
if Instant::now() >= until {
anyhow::bail!("QUIESCENT_HEAD_NOT_OBSERVED_NO_STOP");
}
if db.execute_batch("BEGIN IMMEDIATE").is_err() {
std::thread::sleep(Duration::from_millis(25));
continue;
}
helper.execute_batch("BEGIN")?;
let value = idle(&db, &consumed, &helper, &intents, &pin.binding);
helper.execute_batch("ROLLBACK")?;
match value {
Ok(value) => break value,
Err(_) => {
db.execute_batch("ROLLBACK")?;
std::thread::sleep(Duration::from_millis(25));
}
}
};
// All final observations occur while new agent writes remain excluded.
peer.check()?;
helper_peer.check()?;
pin_guard.check()?;
settings_guard.check()?;
config_guard.check()?;
dir_guard.as_mut().context("QUIESCENT_CASE_GUARD")?.check()?;
check_id(&journal_file, &journal_path)?;
check_id(&consumption_file, &consumption_path)?;
helper_file.check()?;
intent_file.check()?;
let current = status(&agent_service)?;
ensure!(
current.dwCurrentState == SERVICE_RUNNING && current.dwProcessId == before.dwProcessId,
"QUIESCENT_ORIGINAL_PROCESS_CHANGED"
);
receipt(
&dir,
"stop-intent.json",
&json!({"schema_version":1,"case_id":CASE,"observed_at":chrono::Utc::now(),"agent_sha256":AGENT,"helper_sha256":HELPER,"pin_sha256":PIN,"config_sha256":CONFIG,
"agent_pid":before.dwProcessId,"journal_file_id":ipc::file_identity(&journal_file)?,"consumption_file_id":ipc::file_identity(&consumption_file)?,"helper_ledger_file_id":helper_file.identity,"decision_id":locked.decision,
"checkpoint":locked.checkpoint,"helper_applied_checkpoint":locked.helper_checkpoint,"signed_request_sha256":locked.request_sha256,"signed_helper_response_sha256":locked.response_sha256,"original_echo_job":locked.original_echo_job,
"pending_job":JOB,"pending_control_request":locked.pending_request,"pending_control_request_sha256":locked.pending_request_sha256,"new_grants":0,"helper_consumptions":0,"helper_intents":0,"sql_data_changed":false,"agent_journal_immediate_reservation_held":true,"stop_service_only":rmm_agent_windows::SERVICE_NAME,"force_kill":false}),
)?;
let mut returned: SERVICE_STATUS = unsafe { zeroed() };
let stop_ok =
unsafe { ControlService(agent_service.0, SERVICE_CONTROL_STOP, &mut returned) } != 0;
let error = if stop_ok {
None
} else {
Some(unsafe { GetLastError() })
};
let wait = Instant::now() + Duration::from_secs(125);
let mut final_status = status(&agent_service)?;
while stop_ok && final_status.dwCurrentState != SERVICE_STOPPED && Instant::now() < wait {
std::thread::sleep(Duration::from_millis(50));
final_status = status(&agent_service)?;
}
let stopped = stop_ok && final_status.dwCurrentState == SERVICE_STOPPED;
helper_peer.check()?;
// Still held through the confirmed stop (or bounded honest failure).
check_id(&journal_file, &journal_path)?;
check_id(&consumption_file, &consumption_path)?;
receipt(
&dir,
"stop-result.json",
&json!({"schema_version":1,"case_id":CASE,"observed_at":chrono::Utc::now(),"normal_stop_requested_once":stop_ok,"native_error":error,"stopped":stopped,"state":final_status.dwCurrentState,"pid":final_status.dwProcessId,
"sql_data_changed":false,"job_executed":false,"helper_stopped":false,"reset":false,"force_kill":false,"reservation_held_until_observation":true}),
)?;
db.execute_batch("ROLLBACK")?;
ensure!(stopped, "QUIESCENT_STOP_UNCONFIRMED_NO_FORCE");
println!("{{\"case_id\":\"{CASE}\",\"stopped\":true,\"sql_data_changed\":false}}");
Ok(())
}
}
#[cfg(all(windows, feature = "system-helper"))]
fn main() {
if let Err(error) = platform::run() {
eprintln!("{}", error);
std::process::exit(1);
}
}
#[cfg(not(all(windows, feature = "system-helper")))]
fn main() {
eprintln!("Windows SYSTEM-helper SDK bootstrap only");
std::process::exit(1);
}