Qualify Windows IPC client runtime and prepare bounded native providers
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -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()?;
|
||||
|
||||
Reference in New Issue
Block a user