Qualify Windows IPC client runtime and prepare bounded native providers
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-14 03:53:48 +01:00
parent 2bf0183e68
commit 9d6a6f0eb6
24 changed files with 3880 additions and 30 deletions
+222 -7
View File
@@ -337,6 +337,30 @@ fn open_ledger(directory: &Path, binding: &Binding) -> Result<(Connection, fs::F
}
Ok((db, file))
}
#[cfg(feature = "system-helper")]
enum HelperControl {
Snapshot(
u64,
tokio::task::JoinHandle<Result<reconcile::HelperSnapshot>>,
),
Apply(
u64,
tokio::task::JoinHandle<Result<reconcile::HelperSnapshot>>,
),
}
#[cfg(feature = "system-helper")]
impl HelperControl {
fn finished(&self) -> bool {
match self {
Self::Snapshot(_, t) | Self::Apply(_, t) => t.is_finished(),
}
}
fn abort(self) {
match self {
Self::Snapshot(_, t) | Self::Apply(_, t) => t.abort(),
}
}
}
struct Agent {
config: Config,
identity: EnrollmentResponse,
@@ -351,6 +375,23 @@ struct Agent {
clock: JobClock,
sync: Option<reconcile::ClientSync>,
prepared: bool,
#[cfg(feature = "system-helper")]
prepared_request: Option<Vec<u8>>,
#[cfg(feature = "system-helper")]
helper_lane: Arc<tokio::sync::Semaphore>,
#[cfg(feature = "system-helper")]
helper: Option<rmm_agent_windows::helper_runtime::Client>,
#[cfg(feature = "system-helper")]
helper_probe:
Option<tokio::task::JoinHandle<Result<Option<rmm_agent_windows::helper_runtime::Client>>>>,
#[cfg(feature = "system-helper")]
helper_probe_at: Instant,
#[cfg(feature = "system-helper")]
helper_control: Option<HelperControl>,
#[cfg(feature = "system-helper")]
helper_checked: bool,
#[cfg(feature = "system-helper")]
helper_refused: bool,
fence: Arc<EffectFence>,
completed_tx: tokio::sync::mpsc::Sender<Completion>,
completed_rx: tokio::sync::mpsc::Receiver<Completion>,
@@ -364,8 +405,110 @@ impl Agent {
sync.close();
}
self.prepared = false;
#[cfg(feature = "system-helper")]
{
self.prepared_request = None;
if let Some(control) = self.helper_control.take() {
control.abort();
}
}
self.deferred_permit = None;
}
fn helper_control_pending(&self) -> bool {
#[cfg(feature = "system-helper")]
{
self.helper_control.is_some()
|| self.helper_probe.is_some()
|| !self.helper_checked
|| self.helper_refused
}
#[cfg(not(feature = "system-helper"))]
{
false
}
}
#[cfg(feature = "system-helper")]
async fn poll_helper(
&mut self,
channel: &crate::wire_channel::Handle,
generation: u64,
) -> Result<()> {
if self
.helper_control
.as_ref()
.is_some_and(HelperControl::finished)
{
match self
.helper_control
.take()
.context("HELPER_CONTROL_REQUIRED")?
{
HelperControl::Snapshot(expected, task) => {
ensure!(expected == generation, "HELPER_CHANNEL_CHANGED");
let snapshot = task.await??;
self.send_sync(channel, generation, Some(&snapshot)).await?;
}
HelperControl::Apply(expected, task) => {
ensure!(expected == generation, "HELPER_CHANNEL_CHANGED");
let snapshot = task.await??;
self.sync
.as_mut()
.context("SYNC_NOT_CONFIGURED")?
.confirm_helper(&snapshot)?;
self.open_fence(generation)?;
}
}
}
if self
.helper_probe
.as_ref()
.is_some_and(|task| task.is_finished())
{
let result = self
.helper_probe
.take()
.context("HELPER_PROBE_REQUIRED")?
.await?;
self.helper_probe_at = Instant::now();
self.helper_checked = true;
match result {
Ok(client) => {
self.helper_refused = false;
if self.helper.as_ref().map(|c| c.pin_hash())
!= client.as_ref().map(|c| c.pin_hash())
{
self.close_gate();
}
self.helper = client;
}
Err(error) => {
self.helper_refused = true;
self.helper = None;
self.close_gate();
return Err(error);
}
}
}
if self.helper_probe.is_none()
&& self.helper_control.is_none()
&& !self.prepared
&& self.running.is_none()
&& self.helper_probe_at.elapsed() >= Duration::from_secs(30)
{
let agent = self.identity.agent_id.clone();
let asset = self.identity.asset_id.clone();
let binding = self.binding.clone();
let lane = self.helper_lane.clone();
let state = self.config.state_directory.clone();
self.helper_probe = Some(tokio::spawn(async move {
rmm_agent_windows::helper_runtime::Client::refresh(
agent, asset, binding, lane, state,
)
.await
}));
}
Ok(())
}
fn channel(&self, generation: u64) -> Result<reconcile::Channel> {
Ok(reconcile::Channel {
connection_generation: generation,
@@ -374,6 +517,7 @@ impl Agent {
}
fn ready(&self, generation: u64) -> bool {
self.config.enable_jobs
&& !self.helper_control_pending()
&& self.channel(generation).is_ok_and(|channel| {
self.sync
.as_ref()
@@ -461,15 +605,38 @@ impl Agent {
generation: u64,
) -> Result<()> {
self.fence.close();
ensure!(!self.helper_control_pending(), "HELPER_CONTROL_NOT_SETTLED");
#[cfg(feature = "system-helper")]
if let Some(helper) = self.helper.clone() {
ensure!(self.helper_control.is_none(), "HELPER_CONTROL_PENDING");
let boot = self.channel(generation)?.boot_id;
self.helper_control = Some(HelperControl::Snapshot(
generation,
tokio::spawn(async move { helper.snapshot(generation, boot).await }),
));
return Ok(());
}
self.send_sync(channel, generation, None).await
}
async fn send_sync(
&mut self,
channel: &crate::wire_channel::Handle,
generation: u64,
helper: Option<&reconcile::HelperSnapshot>,
) -> Result<()> {
let context = self.channel(generation)?;
let sync = self.sync.as_mut().context("SYNC_NOT_CONFIGURED")?;
let prepared = sync.prepare(
self.journal.connection_mut(),
self.ledger.as_ref().context("LEDGER_REQUIRED")?,
context,
None,
helper,
&self.clock,
)?;
#[cfg(feature = "system-helper")]
{
self.prepared_request = Some(prepared.request.encode_to_vec());
}
self.prepared = true;
channel.send(&prepared.envelope).await?;
Ok(())
@@ -479,14 +646,44 @@ impl Agent {
self.prepared = false;
let sync = self.sync.as_mut().context("SYNC_NOT_CONFIGURED")?;
let applied = sync.apply(self.journal.connection_mut(), &response, &self.clock)?;
ensure!(
applied.helper_instruction.is_none(),
"WINDOWS_HELPER_NOT_CONFIGURED"
);
sync.apply_consumption(
self.ledger.as_mut().context("LEDGER_REQUIRED")?,
&self.clock,
)?;
if let Some(instruction) = applied.helper_instruction {
#[cfg(feature = "system-helper")]
{
ensure!(self.helper_control.is_none(), "HELPER_CONTROL_PENDING");
let helper = self
.helper
.clone()
.context("WINDOWS_HELPER_NOT_CONFIGURED")?;
let request = self
.prepared_request
.take()
.context("ORIGINAL_SYNC_REQUEST_REQUIRED")?;
let boot = self.channel(generation)?.boot_id;
self.helper_control = Some(HelperControl::Apply(
generation,
tokio::spawn(async move {
helper.apply(&instruction.response, request, boot).await
}),
));
return Ok(());
}
#[cfg(not(feature = "system-helper"))]
{
let _ = instruction;
anyhow::bail!("WINDOWS_HELPER_NOT_CONFIGURED");
}
}
#[cfg(feature = "system-helper")]
{
self.prepared_request = None;
}
self.open_fence(generation)
}
fn open_fence(&self, generation: u64) -> Result<()> {
if self.ready(generation) {
let deadline = self
.sync
@@ -797,6 +994,8 @@ impl Agent {
tokio::select! {
Some(completion)=self.completed_rx.recv()=>{self.completed(generation,completion)?;needs_sync=true;},
_=tick.tick()=>{
#[cfg(feature = "system-helper")]
if !stop.load(Ordering::SeqCst) && self.poll_helper(&channel,generation).await.is_err() {self.close_gate();needs_sync=self.sync.is_some();}
if !stop.load(Ordering::SeqCst) && let Some((pending_generation,permit))=self.deferred_permit.take() {
ensure!(pending_generation==generation,"PENDING_PERMIT_GENERATION");self.permit(generation,permit)?;
}
@@ -809,7 +1008,7 @@ impl Agent {
if !stop.load(Ordering::SeqCst) && !busy {
if capabilities_at.elapsed()>=Duration::from_secs(60) {capabilities_at=Instant::now();if advertised!=self.capabilities(){return Ok(());}}
if self.prepared && sync_at.elapsed()>=Duration::from_secs(20){self.close_gate();needs_sync=true;}
if self.sync.is_some() && !self.prepared && (needs_sync || sync_at.elapsed()>=Duration::from_secs(40) || !self.ready(generation)) {
if self.sync.is_some() && !self.prepared && !self.helper_control_pending() && (needs_sync || sync_at.elapsed()>=Duration::from_secs(40) || !self.ready(generation)) {
if self.start_sync(&channel,generation).await.is_err(){self.close_gate();needs_sync=true;}else{needs_sync=false;}sync_at=Instant::now();
}
if !needs_sync && !self.prepared && self.ready(generation) && jobs::events(self.journal.connection())?.is_empty() && self.journal.count()?==0 {
@@ -936,7 +1135,7 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
ensure!(!config.enable_jobs || binding.is_some(),"ENABLED_JOBS_REQUIRE_BINDING");
let (ledger,ledger_file)=match &binding {Some(binding)=>{let (db,file)=open_ledger(&config.state_directory,binding)?;(Some(db),Some(file))},None=>(None,None)};
let clock=JobClock{native:Arc::new(rmm_agent_windows::clock::NativeClock::new()),enabled:config.enable_jobs};
let sync=if config.enable_jobs {binding.clone().map(reconcile::ClientSync::new)} else {None};
let sync=if config.enable_jobs {binding.clone().map(|binding|reconcile::ClientSync::new(binding).with_helper_identity(reconcile::HelperIdentity::System))} else {None};
let (completed_tx,completed_rx)=tokio::sync::mpsc::channel(1);
let mut agent = Agent {
config,
@@ -946,6 +1145,22 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
boot,
instance: Uuid::new_v4().to_string(),
started: Instant::now(), binding, ledger, _ledger_file:ledger_file, clock, sync,
#[cfg(feature="system-helper")]
prepared_request:None,
#[cfg(feature="system-helper")]
helper_lane:Arc::new(tokio::sync::Semaphore::new(1)),
#[cfg(feature="system-helper")]
helper:None,
#[cfg(feature="system-helper")]
helper_probe:None,
#[cfg(feature="system-helper")]
helper_probe_at:Instant::now()-Duration::from_secs(30),
#[cfg(feature="system-helper")]
helper_control:None,
#[cfg(feature="system-helper")]
helper_checked:false,
#[cfg(feature="system-helper")]
helper_refused:false,
prepared:false,fence:Arc::new(EffectFence::default()),completed_tx,completed_rx,running:None,deferred_permit:None,
};
agent.recover_interrupted()?;