Integrate signed agent catalog, tenant enrollment and HTTPS installers
This commit is contained in:
@@ -105,7 +105,7 @@ impl Settings {
|
||||
})
|
||||
}
|
||||
fn permits_script(&self, job: &JobPayload) -> bool {
|
||||
self.schema_version == 3
|
||||
self.schema_version >= 3
|
||||
&& job.execution_identity == "system"
|
||||
&& job.action.full_maintenance()
|
||||
&& job.action.valid_execution_identity("system")
|
||||
@@ -117,11 +117,17 @@ impl Settings {
|
||||
&& self.allowed_script_profiles.as_deref()
|
||||
== Some(&[rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1])
|
||||
}
|
||||
fn permits_reboot(&self, job: &JobPayload) -> bool {
|
||||
self.schema_version == 4
|
||||
&& self.allow_reboot
|
||||
&& rmm_domain::windows_reboot::supported(job)
|
||||
&& job.max_runtime_seconds <= self.max_runtime_seconds
|
||||
}
|
||||
pub fn validate(&self) -> Result<()> {
|
||||
ensure!(
|
||||
matches!(self.schema_version, 1..=3)
|
||||
matches!(self.schema_version, 1..=4)
|
||||
&& (self.schema_version >= 2 || self.allowed_msi_recipe_sha256.is_none())
|
||||
&& (self.schema_version == 3 || self.allowed_script_profiles.is_none())
|
||||
&& (self.schema_version >= 3 || self.allowed_script_profiles.is_none())
|
||||
&& self
|
||||
.allowed_msi_recipe_sha256
|
||||
.as_ref()
|
||||
@@ -137,7 +143,7 @@ impl Settings {
|
||||
&& self.allowed_script_profiles.as_deref().is_none_or(
|
||||
|v| v == [rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1]
|
||||
)
|
||||
&& !self.allow_reboot
|
||||
&& (self.schema_version == 4 || !self.allow_reboot)
|
||||
&& (1..=120).contains(&self.max_runtime_seconds)
|
||||
&& self.allowed_services.len() <= 16,
|
||||
"SYSTEM_POLICY_PROFILE"
|
||||
@@ -228,14 +234,14 @@ pub fn read_settings() -> Result<(Settings, Vec<PinnedFile>)> {
|
||||
settings.validate()?;
|
||||
Ok((settings, vec![root, file]))
|
||||
}
|
||||
struct WindowsBoot(Uuid);
|
||||
pub struct WindowsBoot(Uuid);
|
||||
impl BootSource for WindowsBoot {
|
||||
fn current_boot(&self) -> Result<Uuid> {
|
||||
Ok(self.0)
|
||||
}
|
||||
}
|
||||
impl WindowsBoot {
|
||||
fn capture() -> Result<Self> {
|
||||
pub fn capture() -> Result<Self> {
|
||||
// The exact existing fixed read-only CIM getter, independently called here.
|
||||
// No caller values, execution-policy flag, or supplied command are accepted.
|
||||
let rt = tokio::runtime::Builder::new_current_thread()
|
||||
@@ -306,6 +312,16 @@ impl LedgerGuard {
|
||||
guard.check(&db)?;
|
||||
Ok((guard, db))
|
||||
}
|
||||
pub(crate) fn update_identity(
|
||||
&self,
|
||||
db: &Connection,
|
||||
) -> Result<crate::update_state::LedgerIdentity> {
|
||||
self.check(db)?;
|
||||
Ok(crate::update_state::LedgerIdentity {
|
||||
ledger: self.ledger.identity,
|
||||
lock: self.lock.identity,
|
||||
})
|
||||
}
|
||||
fn check_files(&self) -> Result<()> {
|
||||
for file in [&self.root, &self.lock, &self.ledger] {
|
||||
ensure!(
|
||||
@@ -833,6 +849,17 @@ struct UnsettledMsi {
|
||||
request_sha256: String,
|
||||
installer: Box<crate::package::Installer>,
|
||||
}
|
||||
/// Internal native-control adapter. No caller can construct readiness, choose
|
||||
/// another database, or replace the real held executor through the wire.
|
||||
pub(crate) struct UpdateContext<'a> {
|
||||
pub db:&'a mut Connection,
|
||||
pub guard:&'a LedgerGuard,
|
||||
pub binding:&'a Binding,
|
||||
pub clock:&'a BoundClock,
|
||||
pub pin:&'a Pin,
|
||||
pub boot:&'a WindowsBoot,
|
||||
pub sync:Option<&'a mut HelperSync<DalekVerifier>>,
|
||||
}
|
||||
pub struct SystemHelper {
|
||||
settings: Settings,
|
||||
pin: Pin,
|
||||
@@ -845,6 +872,7 @@ pub struct SystemHelper {
|
||||
last_diagnostic: Option<Instant>,
|
||||
last_apply_diagnostic: Option<Instant>,
|
||||
unsettled_msi: Option<UnsettledMsi>,
|
||||
pending_update_activation: Option<crate::update_admission::Activation>,
|
||||
}
|
||||
impl SystemHelper {
|
||||
pub fn open() -> Result<Self> {
|
||||
@@ -870,8 +898,13 @@ impl SystemHelper {
|
||||
last_diagnostic: None,
|
||||
last_apply_diagnostic: None,
|
||||
unsettled_msi: None,
|
||||
pending_update_activation: None,
|
||||
})
|
||||
}
|
||||
pub(crate) fn update_context(&mut self)->UpdateContext<'_> {
|
||||
UpdateContext{db:&mut self.db,guard:&self.guard,binding:&self.settings.binding,clock:&self.clock,
|
||||
pin:&self.pin,boot:&self.boot,sync:self.sync.as_mut()}
|
||||
}
|
||||
pub fn pin(&self) -> &Pin {
|
||||
&self.pin
|
||||
}
|
||||
@@ -922,54 +955,8 @@ impl SystemHelper {
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
// One authenticated control call, same original bytes/capture/deadline.
|
||||
// Only a typed clock failure proven before BEGIN can be retried.
|
||||
fn apply_control_with_clock(
|
||||
&mut self,
|
||||
response: &rmm_agent_core::helper_reconcile::SignedResponse,
|
||||
request: &[u8],
|
||||
issued: chrono::DateTime<chrono::Utc>,
|
||||
until: chrono::DateTime<chrono::Utc>,
|
||||
) -> Result<rmm_agent_core::helper_reconcile::Applied> {
|
||||
let began = Instant::now();
|
||||
loop {
|
||||
ensure!(
|
||||
began.elapsed() < Duration::from_secs(3),
|
||||
"SYSTEM_APPLY_CLOCK_WAIT_EXPIRED"
|
||||
);
|
||||
match crate::job_readiness::response_window(
|
||||
issued,
|
||||
until,
|
||||
began.elapsed(),
|
||||
self.clock.reading().ok().map(|r| (r.own_wall, r.upper)),
|
||||
) {
|
||||
crate::job_readiness::ResponseWindow::WaitForClock => {
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
continue;
|
||||
}
|
||||
crate::job_readiness::ResponseWindow::Expired => {
|
||||
anyhow::bail!("SYSTEM_APPLY_ORIGINAL_DEADLINE_EXPIRED")
|
||||
}
|
||||
crate::job_readiness::ResponseWindow::WithinWindow => {}
|
||||
}
|
||||
self.sync()?;
|
||||
match self.sync.as_mut().unwrap().apply(
|
||||
&mut self.db,
|
||||
&self.guard,
|
||||
response,
|
||||
request,
|
||||
&self.clock,
|
||||
&self.boot,
|
||||
) {
|
||||
Ok(value) => return Ok(value),
|
||||
Err(error)
|
||||
if rmm_agent_core::helper_reconcile::retryable_precommit_clock(&error) =>
|
||||
{
|
||||
std::thread::sleep(Duration::from_millis(20))
|
||||
}
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
}
|
||||
fn wait_apply_clock(&self,issued:chrono::DateTime<chrono::Utc>,until:chrono::DateTime<chrono::Utc>)->Result<()> {
|
||||
crate::job_readiness::wait_for_helper_apply_clock(&self.clock,issued,until)
|
||||
}
|
||||
/// Passive, bounded static denial metadata only. Never feeds a gate.
|
||||
fn record_apply_error(&mut self,error:&anyhow::Error)->Result<()> {
|
||||
@@ -1030,6 +1017,13 @@ impl SystemHelper {
|
||||
| Operation::TimeClose { .. } => {
|
||||
anyhow::bail!("SYSTEM_TIME_PIPE_REQUIRED")
|
||||
}
|
||||
Operation::UpdateObserve{request}=>{
|
||||
Ok(ReplyBody::UpdateObservation{response:Box::new(crate::update_observer::collect(self.update_context(),request)?)})
|
||||
}
|
||||
Operation::UpdateHealth{request}=>{
|
||||
ensure!(matches!(request.method,rmm_agent_core::update_handoff::NativeControlOperation::Health{..}),"UPDATE_AGENT_HEALTH_ONLY");
|
||||
Ok(ReplyBody::UpdateHealth{reply:Box::new(crate::update_control::handle_agent_health(self.update_context(),peer,request)?)})
|
||||
}
|
||||
Operation::Probe {} => {
|
||||
let ready = self.settings.enable_effects
|
||||
&& self
|
||||
@@ -1042,22 +1036,31 @@ impl SystemHelper {
|
||||
})
|
||||
.unwrap_or(false);
|
||||
Ok(ReplyBody::Probe {
|
||||
update_observer_configured:Some(crate::update_admission::configured(&self.settings.binding)),
|
||||
clock_qualified: self.clock.now().is_ok(),
|
||||
ready,
|
||||
ledger: self.guard.ledger.identity,
|
||||
lock: self.guard.lock.identity,
|
||||
reboot_privilege_available: if self.settings.schema_version == 4
|
||||
&& self.settings.allow_reboot
|
||||
{
|
||||
Some(crate::reboot::privilege_available()?)
|
||||
} else {
|
||||
None
|
||||
},
|
||||
})
|
||||
}
|
||||
Operation::Snapshot { generation } => {
|
||||
self.clock = self.clock.for_generation(*generation);
|
||||
self.sync()?;
|
||||
let snapshot = self.sync.as_mut().unwrap().snapshot(
|
||||
&mut self.db,
|
||||
&self.guard,
|
||||
*generation,
|
||||
&self.clock,
|
||||
&self.boot,
|
||||
)?;
|
||||
let snapshot = if let Some(grant)=crate::update_control::active_grant(&self.db)? {
|
||||
let budget=crate::update_native::Budget::new(&self.boot,self.boot.current_boot()?,Duration::from_secs(5))?;
|
||||
let guard=crate::update_control::Guard::open(&self.db,&self.guard,&self.settings.binding,
|
||||
&self.clock,&self.pin,&budget,grant)?;
|
||||
self.sync.as_mut().unwrap().snapshot(&mut self.db,&guard,*generation,&self.clock,&self.boot)?
|
||||
} else {
|
||||
self.sync.as_mut().unwrap().snapshot(&mut self.db,&self.guard,*generation,&self.clock,&self.boot)?
|
||||
};
|
||||
Ok(ReplyBody::Snapshot { snapshot })
|
||||
}
|
||||
Operation::Apply {
|
||||
@@ -1068,16 +1071,20 @@ impl SystemHelper {
|
||||
serde_json::from_slice(&response.decision_bytes)?;
|
||||
self.clock
|
||||
.require_generation(decision.connection_generation)?;
|
||||
// Same authenticated original call, BEFORE any application.
|
||||
// The independent time pipe continues on its own thread.
|
||||
// No signature/deadline/lease is relaxed and no Execute retry.
|
||||
let value = self.apply_control_with_clock(
|
||||
response,
|
||||
request_bytes,
|
||||
decision.issued_at,
|
||||
decision.valid_until,
|
||||
)?;
|
||||
let no_start_anchor = if value.ready && self.settings.enable_effects {
|
||||
self.wait_apply_clock(decision.issued_at,decision.valid_until)?;
|
||||
self.sync()?;
|
||||
let value = if let Some(grant)=crate::update_control::active_grant(&self.db)? {
|
||||
let budget=crate::update_native::Budget::new(&self.boot,self.boot.current_boot()?,Duration::from_secs(5))?;
|
||||
let guard=crate::update_control::Guard::open(&self.db,&self.guard,&self.settings.binding,
|
||||
&self.clock,&self.pin,&budget,grant)?;
|
||||
self.sync.as_mut().unwrap().apply(&mut self.db,&guard,response,request_bytes,&self.clock,&self.boot)?
|
||||
} else {
|
||||
self.sync.as_mut().unwrap().apply(&mut self.db,&self.guard,response,request_bytes,&self.clock,&self.boot)?
|
||||
};
|
||||
let no_start_anchor = if value.ready
|
||||
&& (self.settings.enable_effects
|
||||
|| crate::update_admission::configured(&self.settings.binding))
|
||||
{
|
||||
let guard = DenialGuard {
|
||||
ledger: &self.guard,
|
||||
pin: &self.pin,
|
||||
@@ -1109,9 +1116,41 @@ impl SystemHelper {
|
||||
Operation::Execute {
|
||||
generation,
|
||||
request,
|
||||
} => Ok(ReplyBody::Executed {
|
||||
outcome: self.execute(*generation, request, peer)?,
|
||||
}),
|
||||
} => {
|
||||
let job = self.settings.binding.job(&request.job_bytes)?;
|
||||
if matches!(job.action, Action::UpdateAgent { .. }) {
|
||||
ensure!(
|
||||
self.pending_update_activation.is_none(),
|
||||
"UPDATE_ACTIVATION_PENDING"
|
||||
);
|
||||
self.clock.require_generation(*generation)?;
|
||||
self.sync()?;
|
||||
let prepared = crate::update_admission::Prepared::new(
|
||||
&self.db,
|
||||
crate::update_admission::Local {
|
||||
binding: &self.settings.binding,
|
||||
guard: &self.guard,
|
||||
clock: &self.clock,
|
||||
boot: &self.boot,
|
||||
pin: &self.pin,
|
||||
generation: *generation,
|
||||
},
|
||||
self.sync.as_ref().context("SYSTEM_SYNC_REQUIRED")?,
|
||||
request,
|
||||
)?;
|
||||
peer.check()?;
|
||||
let accepted = prepared.consume(
|
||||
&mut self.db,
|
||||
self.sync.as_mut().context("SYSTEM_SYNC_REQUIRED")?,
|
||||
)?;
|
||||
self.pending_update_activation = Some(prepared.into_activation());
|
||||
Ok(ReplyBody::UpdateAccepted { accepted })
|
||||
} else {
|
||||
Ok(ReplyBody::Executed {
|
||||
outcome: self.execute(*generation, request, peer)?,
|
||||
})
|
||||
}
|
||||
}
|
||||
Operation::Abandon {
|
||||
anchor,
|
||||
request,
|
||||
@@ -1125,10 +1164,15 @@ impl SystemHelper {
|
||||
let job = self.settings.binding.job(&request.job_bytes)?;
|
||||
ensure!(
|
||||
job.execution_identity == "system"
|
||||
&& job.max_runtime_seconds <= self.settings.max_runtime_seconds
|
||||
&& (matches!(&job.action,Action::SetServiceState{unit,state} if matches!(state.as_str(),"running"|"stopped")&&self.settings.allowed_services.iter().any(|r|r.name==*unit))
|
||||
|| self.settings.permits_msi(&job)
|
||||
|| self.settings.permits_script(&job)),
|
||||
&& ((job.max_runtime_seconds <= self.settings.max_runtime_seconds
|
||||
&& (matches!(&job.action,Action::SetServiceState{unit,state} if matches!(state.as_str(),"running"|"stopped")&&self.settings.allowed_services.iter().any(|r|r.name==*unit))
|
||||
|| self.settings.permits_msi(&job)
|
||||
|| self.settings.permits_script(&job)
|
||||
|| self.settings.permits_reboot(&job)))
|
||||
|| crate::update_admission::permits_denial(
|
||||
&self.settings.binding,
|
||||
&job
|
||||
)),
|
||||
"SYSTEM_ABANDON_POLICY_DENIED"
|
||||
);
|
||||
self.sync()?;
|
||||
@@ -1227,6 +1271,9 @@ impl SystemHelper {
|
||||
if job.action.windows_msi().is_some() {
|
||||
return self.execute_msi(generation, request, &job, &permit, peer);
|
||||
}
|
||||
if matches!(job.action, Action::Reboot { .. }) {
|
||||
return self.execute_reboot(generation, request, &job, &permit, peer);
|
||||
}
|
||||
let mut provider = PreparedService::prepare(&self.settings, &job)?;
|
||||
self.recheck()?;
|
||||
peer.check()?;
|
||||
@@ -1272,6 +1319,69 @@ impl SystemHelper {
|
||||
ledger::finish(&self.db, &permit, &outcome)?;
|
||||
Ok(outcome)
|
||||
}
|
||||
fn execute_reboot(
|
||||
&mut self,
|
||||
generation: u64,
|
||||
request: &Request,
|
||||
job: &JobPayload,
|
||||
permit: &ExecutionPermitPayload,
|
||||
peer: &mut ipc::PeerProof,
|
||||
) -> Result<Outcome> {
|
||||
ensure!(
|
||||
self.settings.permits_reboot(job),
|
||||
"SYSTEM_REBOOT_POLICY_DENIED"
|
||||
);
|
||||
self.observe_unsettled_msi()?;
|
||||
ensure!(
|
||||
self.unsettled_msi.is_none(),
|
||||
"SYSTEM_MSI_PREVIOUS_PROCESS_UNSETTLED"
|
||||
);
|
||||
let provider = crate::reboot::Prepared::prepare(job)?;
|
||||
self.recheck()?;
|
||||
peer.check()?;
|
||||
let (_, fresh, recorded_at) =
|
||||
verified_window(&self.settings.binding, request, &self.clock)?;
|
||||
ensure!(
|
||||
&fresh == permit && !STOP.load(Ordering::SeqCst),
|
||||
"SYSTEM_REBOOT_START_FENCED"
|
||||
);
|
||||
let boot = self.boot.current_boot()?;
|
||||
crate::helper_runtime::intent::Store::require_not_denied(
|
||||
request,
|
||||
boot,
|
||||
generation,
|
||||
&self.pin.policy_sha256,
|
||||
&self.pin.helper.binary_sha256,
|
||||
)?;
|
||||
ledger::begin_execution(&mut self.db, permit, request, boot, recorded_at)?;
|
||||
self.sync.as_mut().unwrap().close();
|
||||
let outcome = provider
|
||||
.request(boot, || {
|
||||
self.clock.require_generation(generation)?;
|
||||
self.recheck()?;
|
||||
peer.check()?;
|
||||
ensure!(
|
||||
!STOP.load(Ordering::SeqCst),
|
||||
"SYSTEM_REBOOT_CANCELLED_BEFORE_REQUEST"
|
||||
);
|
||||
verified_window(&self.settings.binding, request, &self.clock)?;
|
||||
crate::helper_runtime::intent::Store::require_not_denied(
|
||||
request,
|
||||
boot,
|
||||
generation,
|
||||
&self.pin.policy_sha256,
|
||||
&self.pin.helper.binary_sha256,
|
||||
)?;
|
||||
Ok(())
|
||||
})
|
||||
.unwrap_or_else(|_| Outcome::unknown("WINDOWS_REBOOT_REQUEST_UNCONFIRMED"));
|
||||
ledger::persist_outcome(&self.db, permit, &outcome)?;
|
||||
self.guard.check(&self.db)?;
|
||||
// Awaiting/Unknown deliberately keeps consumed.result NULL. Only the
|
||||
// existing signed new-boot reconciliation may finish the same attempt.
|
||||
ledger::finish(&self.db, permit, &outcome)?;
|
||||
Ok(outcome)
|
||||
}
|
||||
fn execute_script(
|
||||
&mut self,
|
||||
generation: u64,
|
||||
@@ -1650,30 +1760,76 @@ unsafe extern "system" fn service_main(_: u32, _: *mut *mut u16) {
|
||||
let mut helper = SystemHelper::open()?;
|
||||
let server = ipc::Server::bind(helper.pin().clone())?;
|
||||
let time_server = ipc::Server::bind_time(helper.pin().clone())?;
|
||||
let update_server=crate::update_control::server_pin(&helper.settings.binding,&helper.pin.helper)?
|
||||
.map(crate::update_control_ipc::Server::bind).transpose()?;
|
||||
let time_pin = helper.pin().clone();
|
||||
let time_clock = helper.clock.source();
|
||||
let time_worker = std::thread::Builder::new()
|
||||
.name("rmm-helper-time-control".into())
|
||||
.spawn(move || time_control(time_server, time_pin, time_clock))?;
|
||||
scm_status(SERVICE_RUNNING, 0);
|
||||
let mut next_update_unknown=Instant::now();
|
||||
while !STOP.load(Ordering::SeqCst) {
|
||||
if Instant::now()>=next_update_unknown {
|
||||
next_update_unknown=Instant::now()+Duration::from_secs(2);
|
||||
if let Err(error)=crate::update_control::observe_worker_unknown(helper.update_context()) {
|
||||
let _diagnostic=helper.record_pipe_error(&error);
|
||||
}
|
||||
}
|
||||
// A failed observation keeps the owned slot and its handles locked.
|
||||
if helper.observe_unsettled_msi().is_err()
|
||||
&& let Some(sync) = &mut helper.sync
|
||||
{
|
||||
sync.close();
|
||||
}
|
||||
if let Some(update_server)=&update_server {
|
||||
match update_server.receive() {
|
||||
Ok(Some(mut incoming))=> {
|
||||
let reply=crate::update_control::handle_updater(helper.update_context(),&mut incoming.peer,&incoming.request);
|
||||
let result=match reply {
|
||||
Ok(reply)=>update_server.reply(&mut incoming,&reply),
|
||||
Err(error)=>Err(error),
|
||||
};
|
||||
update_server.disconnect();
|
||||
if let Err(error)=result {
|
||||
if let Some(sync)=&mut helper.sync {sync.close();}
|
||||
let _diagnostic=helper.record_pipe_error(&error);
|
||||
}
|
||||
}
|
||||
Ok(None)=>{},
|
||||
Err(error)=> {
|
||||
update_server.disconnect();
|
||||
if let Some(sync)=&mut helper.sync {sync.close();}
|
||||
let _diagnostic=helper.record_pipe_error(&error);
|
||||
}
|
||||
}
|
||||
}
|
||||
match server.receive() {
|
||||
Ok(Some(mut incoming)) => {
|
||||
let reply = helper.handle(&incoming.call, &mut incoming.peer);
|
||||
if let Err(error) = server.reply(&reply, &mut incoming.peer) {
|
||||
let delivered = server.reply(&reply, &mut incoming.peer);
|
||||
server.disconnect();
|
||||
if let Err(error) = delivered {
|
||||
if let Some(sync) = &mut helper.sync {
|
||||
sync.close();
|
||||
}
|
||||
// Receipt loss cannot trigger an Activate or a retry.
|
||||
helper.pending_update_activation = None;
|
||||
let _diagnostic = helper.record_pipe_error(&error);
|
||||
} else if matches!(reply.body, ReplyBody::UpdateAccepted { .. })
|
||||
&& let Some(activation) = helper.pending_update_activation.take()
|
||||
&& let Err(error) = activation.dispatch_after_reply(
|
||||
&helper.db,
|
||||
&helper.guard,
|
||||
&helper.clock,
|
||||
&helper.boot,
|
||||
)
|
||||
{
|
||||
if let Some(sync) = &mut helper.sync {
|
||||
sync.close();
|
||||
}
|
||||
server.disconnect();
|
||||
let _diagnostic = helper.record_pipe_error(&error);
|
||||
}
|
||||
server.disconnect();
|
||||
}
|
||||
Ok(None) => {}
|
||||
Err(error) => {
|
||||
@@ -1862,6 +2018,26 @@ mod tests {
|
||||
let mut null = legacy;
|
||||
null["allowed_script_profiles"] = serde_json::Value::Null;
|
||||
assert!(serde_json::from_value::<Settings>(null).is_err());
|
||||
let mut reboot = job.clone();
|
||||
reboot.action = Action::Reboot {
|
||||
reason: "Windows-MVP".into(),
|
||||
dependency_group: "windows-mvp".into(),
|
||||
reconnect_timeout_seconds: 180,
|
||||
};
|
||||
reboot.max_runtime_seconds = 60;
|
||||
settings.max_runtime_seconds = 120;
|
||||
settings.allow_reboot = true;
|
||||
for v in 1..=3 {
|
||||
settings.schema_version = v;
|
||||
assert!(!settings.permits_reboot(&reboot));
|
||||
}
|
||||
settings.schema_version = 4;
|
||||
assert!(settings.permits_reboot(&reboot));
|
||||
settings.allow_reboot = false;
|
||||
assert!(!settings.permits_reboot(&reboot));
|
||||
settings.allow_reboot = true;
|
||||
reboot.execution_identity = "agent_service".into();
|
||||
assert!(!settings.permits_reboot(&reboot));
|
||||
}
|
||||
#[test]
|
||||
fn service_adapter_exposes_only_implemented_states() {
|
||||
|
||||
Reference in New Issue
Block a user