Add gated agent update planning, preserved handoff and Linux worker ports
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -0,0 +1,613 @@
|
||||
//! Capability-relative held files. No network-provided path or global JSON
|
||||
//! replacement. Existing bound hardlinks are retained; new stages have nlink1.
|
||||
use crate::{Budget, DurableEffectFence, Effect, digest, valid_digest};
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::{
|
||||
ffi::{CString, OsStr},
|
||||
fs::{File, Metadata},
|
||||
io::{Read, Seek, SeekFrom, Write},
|
||||
os::{
|
||||
fd::{AsRawFd, FromRawFd},
|
||||
unix::{ffi::OsStrExt, fs::MetadataExt},
|
||||
},
|
||||
path::{Component, Path, PathBuf},
|
||||
};
|
||||
use uuid::Uuid;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum Role {
|
||||
Agent,
|
||||
Helper,
|
||||
FullConfig,
|
||||
FullPin,
|
||||
}
|
||||
impl Role {
|
||||
pub fn handoff_role(self) -> rmm_updater_handoff::FileRole {
|
||||
match self {
|
||||
Self::Agent => rmm_updater_handoff::FileRole::AgentBinary,
|
||||
Self::Helper => rmm_updater_handoff::FileRole::HelperBinary,
|
||||
Self::FullConfig => rmm_updater_handoff::FileRole::LinuxFullConfig,
|
||||
Self::FullPin => rmm_updater_handoff::FileRole::LinuxFullPin,
|
||||
}
|
||||
}
|
||||
pub fn target(self) -> &'static str {
|
||||
match self {
|
||||
Self::Agent => "/usr/local/libexec/rmm-agent-remote",
|
||||
Self::Helper => "/usr/local/libexec/rmm-privileged-helper",
|
||||
Self::FullConfig => "/etc/rmm-remote/helper-full-maintenance.json",
|
||||
Self::FullPin => "/etc/rmm-remote/full-maintenance-helper-proof.json",
|
||||
}
|
||||
}
|
||||
fn label(self) -> &'static str {
|
||||
match self {
|
||||
Self::Agent => "agent",
|
||||
Self::Helper => "helper",
|
||||
Self::FullConfig => "full-config",
|
||||
Self::FullPin => "full-pin",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Identity {
|
||||
pub device: u64,
|
||||
pub inode: u64,
|
||||
pub uid: u32,
|
||||
pub gid: u32,
|
||||
pub mode: u32,
|
||||
pub links: u64,
|
||||
}
|
||||
impl Identity {
|
||||
fn of(m: &Metadata) -> Self {
|
||||
Self {
|
||||
device: m.dev(),
|
||||
inode: m.ino(),
|
||||
uid: m.uid(),
|
||||
gid: m.gid(),
|
||||
mode: m.mode(),
|
||||
links: m.nlink(),
|
||||
}
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct FileProof {
|
||||
pub identity: Identity,
|
||||
pub bytes: u64,
|
||||
pub sha256: String,
|
||||
}
|
||||
|
||||
fn name(value: &OsStr) -> Result<CString> {
|
||||
let bytes = value.as_bytes();
|
||||
ensure!(
|
||||
!bytes.is_empty() && bytes != b"." && bytes != b".." && !bytes.contains(&b'/'),
|
||||
"UPDATE_BASENAME"
|
||||
);
|
||||
Ok(CString::new(bytes)?)
|
||||
}
|
||||
fn openat(parent: &File, value: &OsStr, flags: i32, mode: u32) -> Result<File> {
|
||||
let value = name(value)?;
|
||||
// SAFETY: valid owned directory fd and NUL-terminated one-component name;
|
||||
// successful descriptor is immediately transferred into exactly one File.
|
||||
let fd = unsafe {
|
||||
libc::openat(
|
||||
parent.as_raw_fd(),
|
||||
value.as_ptr(),
|
||||
flags | libc::O_CLOEXEC | libc::O_NOFOLLOW,
|
||||
mode,
|
||||
)
|
||||
};
|
||||
ensure!(
|
||||
fd >= 0,
|
||||
"UPDATE_OPENAT: {}",
|
||||
std::io::Error::last_os_error()
|
||||
);
|
||||
Ok(unsafe { File::from_raw_fd(fd) })
|
||||
}
|
||||
|
||||
pub struct Directory {
|
||||
fd: File,
|
||||
path: PathBuf,
|
||||
identity: Identity,
|
||||
}
|
||||
impl Directory {
|
||||
/// All ancestors are held while opening their child with O_NOFOLLOW. A
|
||||
/// writable ancestor (including /tmp) is deliberately not an install root.
|
||||
pub fn open(path: &Path, owner: u32, private: bool) -> Result<Self> {
|
||||
ensure!(path.is_absolute(), "UPDATE_ABSOLUTE_DIRECTORY");
|
||||
let mut fd = File::open("/")?;
|
||||
let components: Vec<_> = path.components().collect();
|
||||
for (i, component) in components.iter().enumerate().skip(1) {
|
||||
let Component::Normal(value) = component else {
|
||||
anyhow::bail!("UPDATE_DIRECTORY_COMPONENT")
|
||||
};
|
||||
fd = openat(&fd, value, libc::O_RDONLY | libc::O_DIRECTORY, 0)?;
|
||||
let m = fd.metadata()?;
|
||||
ensure!(
|
||||
m.is_dir()
|
||||
&& m.uid() == if i + 1 == components.len() { owner } else { 0 }
|
||||
&& m.mode() & 0o022 == 0,
|
||||
"UPDATE_PROTECTED_DIRECTORY"
|
||||
);
|
||||
}
|
||||
let m = fd.metadata()?;
|
||||
ensure!(
|
||||
m.uid() == owner && (!private || m.mode() & 0o077 == 0),
|
||||
"UPDATE_PRIVATE_DIRECTORY"
|
||||
);
|
||||
Ok(Self {
|
||||
identity: Identity::of(&m),
|
||||
fd,
|
||||
path: path.to_path_buf(),
|
||||
})
|
||||
}
|
||||
pub fn identity(&self) -> &Identity {
|
||||
&self.identity
|
||||
}
|
||||
pub fn verify(&self) -> Result<()> {
|
||||
let current = Self::open(&self.path, self.identity.uid, false)?;
|
||||
ensure!(
|
||||
current.identity == self.identity
|
||||
&& Identity::of(&self.fd.metadata()?) == self.identity,
|
||||
"UPDATE_DIRECTORY_REPLACED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
pub fn file(&self, basename: &OsStr, expected: &FileProof, max: u64) -> Result<HeldFile> {
|
||||
self.verify()?;
|
||||
let mut held = HeldFile {
|
||||
fd: openat(&self.fd, basename, libc::O_RDONLY | libc::O_NONBLOCK, 0)?,
|
||||
proof: expected.clone(),
|
||||
};
|
||||
held.verify(max)?;
|
||||
self.named(basename, &held.proof.identity)?;
|
||||
Ok(held)
|
||||
}
|
||||
pub fn inspect(&self, basename: &OsStr, owner: u32, max: u64) -> Result<HeldFile> {
|
||||
self.verify()?;
|
||||
let mut fd = openat(&self.fd, basename, libc::O_RDONLY | libc::O_NONBLOCK, 0)?;
|
||||
let m = fd.metadata()?;
|
||||
ensure!(
|
||||
m.is_file()
|
||||
&& m.uid() == owner
|
||||
&& m.mode() & 0o022 == 0
|
||||
&& m.nlink() > 0
|
||||
&& m.len() <= max,
|
||||
"UPDATE_PROTECTED_FILE"
|
||||
);
|
||||
let hash = hash_file(&mut fd, max)?;
|
||||
let proof = FileProof {
|
||||
identity: Identity::of(&m),
|
||||
bytes: m.len(),
|
||||
sha256: hash,
|
||||
};
|
||||
let mut result = HeldFile { fd, proof };
|
||||
result.verify(max)?;
|
||||
self.named(basename, &result.proof.identity)?;
|
||||
Ok(result)
|
||||
}
|
||||
fn named(&self, basename: &OsStr, expected: &Identity) -> Result<()> {
|
||||
let file = openat(&self.fd, basename, libc::O_PATH, 0)?;
|
||||
ensure!(
|
||||
Identity::of(&file.metadata()?) == *expected,
|
||||
"UPDATE_NAMED_INODE_CHANGED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn absent(&self, basename: &OsStr) -> Result<()> {
|
||||
let value = name(basename)?;
|
||||
let mut m = std::mem::MaybeUninit::<libc::stat>::uninit();
|
||||
// SAFETY: live dirfd, valid basename, properly sized writable stat.
|
||||
let rc = unsafe {
|
||||
libc::fstatat(
|
||||
self.fd.as_raw_fd(),
|
||||
value.as_ptr(),
|
||||
m.as_mut_ptr(),
|
||||
libc::AT_SYMLINK_NOFOLLOW,
|
||||
)
|
||||
};
|
||||
ensure!(
|
||||
rc < 0 && std::io::Error::last_os_error().raw_os_error() == Some(libc::ENOENT),
|
||||
"UPDATE_DESTINATION_EXISTS"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn sync(&self) -> Result<()> {
|
||||
self.fd.sync_all()?;
|
||||
Ok(())
|
||||
}
|
||||
fn rename_new(&self, from: &OsStr, to: &OsStr) -> Result<()> {
|
||||
let a = name(from)?;
|
||||
let b = name(to)?;
|
||||
// SAFETY: same held directory, valid component strings; NOREPLACE
|
||||
// forbids overwriting an unexpected target including a dangling link.
|
||||
let rc = unsafe {
|
||||
libc::renameat2(
|
||||
self.fd.as_raw_fd(),
|
||||
a.as_ptr(),
|
||||
self.fd.as_raw_fd(),
|
||||
b.as_ptr(),
|
||||
libc::RENAME_NOREPLACE,
|
||||
)
|
||||
};
|
||||
ensure!(
|
||||
rc == 0,
|
||||
"UPDATE_RENAME: {}",
|
||||
std::io::Error::last_os_error()
|
||||
);
|
||||
self.sync()
|
||||
}
|
||||
}
|
||||
|
||||
pub struct HeldFile {
|
||||
fd: File,
|
||||
proof: FileProof,
|
||||
}
|
||||
impl HeldFile {
|
||||
pub fn proof(&self) -> &FileProof {
|
||||
&self.proof
|
||||
}
|
||||
pub fn verify(&mut self, max: u64) -> Result<()> {
|
||||
let m = self.fd.metadata()?;
|
||||
ensure!(
|
||||
m.is_file()
|
||||
&& Identity::of(&m) == self.proof.identity
|
||||
&& m.len() == self.proof.bytes
|
||||
&& self.proof.bytes <= max
|
||||
&& valid_digest(&self.proof.sha256),
|
||||
"UPDATE_HELD_FILE_CHANGED"
|
||||
);
|
||||
ensure!(
|
||||
hash_file(&mut self.fd, max)? == self.proof.sha256,
|
||||
"UPDATE_HELD_HASH_CHANGED"
|
||||
);
|
||||
let after = self.fd.metadata()?;
|
||||
ensure!(
|
||||
Identity::of(&m) == Identity::of(&after)
|
||||
&& m.len() == after.len()
|
||||
&& m.mtime_nsec() == after.mtime_nsec()
|
||||
&& m.mtime() == after.mtime()
|
||||
&& m.ctime() == after.ctime()
|
||||
&& m.ctime_nsec() == after.ctime_nsec(),
|
||||
"UPDATE_FILE_CHANGED_DURING_HASH"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
pub fn bytes(&mut self, max: u64) -> Result<Vec<u8>> {
|
||||
self.verify(max)?;
|
||||
self.fd.seek(SeekFrom::Start(0))?;
|
||||
let mut bytes = Vec::with_capacity(self.proof.bytes as usize);
|
||||
Read::by_ref(&mut self.fd)
|
||||
.take(max + 1)
|
||||
.read_to_end(&mut bytes)?;
|
||||
ensure!(
|
||||
bytes.len() as u64 == self.proof.bytes && digest(&bytes) == self.proof.sha256,
|
||||
"UPDATE_READ_CHANGED"
|
||||
);
|
||||
self.verify(max)?;
|
||||
Ok(bytes)
|
||||
}
|
||||
}
|
||||
fn hash_file(fd: &mut File, max: u64) -> Result<String> {
|
||||
ensure!(max <= 256 * 1024 * 1024, "UPDATE_HASH_LIMIT");
|
||||
fd.seek(SeekFrom::Start(0))?;
|
||||
let mut hash = Sha256::new();
|
||||
let mut buffer = [0; 32768];
|
||||
let mut total = 0u64;
|
||||
loop {
|
||||
let n = fd.read(&mut buffer)?;
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
total = total.checked_add(n as u64).context("UPDATE_HASH_LIMIT")?;
|
||||
ensure!(total <= max, "UPDATE_HASH_LIMIT");
|
||||
hash.update(&buffer[..n]);
|
||||
}
|
||||
Ok(hex::encode(hash.finalize()))
|
||||
}
|
||||
|
||||
/// File creation is confined to the SAME held installation directory. The
|
||||
/// private fields bind successful EOF/hash/mode checking to subsequent swap.
|
||||
pub struct Staged {
|
||||
role: Role,
|
||||
nonce: Uuid,
|
||||
basename: String,
|
||||
file: HeldFile,
|
||||
target: String,
|
||||
original: FileProof,
|
||||
}
|
||||
/// All descriptors remain untrusted input until the exact protected predecessor
|
||||
/// and the approved target hashes have been independently checked by runtime.
|
||||
pub struct StageDescriptor<'a> {
|
||||
pub role: Role,
|
||||
pub nonce: Uuid,
|
||||
pub original: &'a FileProof,
|
||||
pub expected_sha: &'a str,
|
||||
pub length: u64,
|
||||
}
|
||||
impl Staged {
|
||||
/// Stage only after the embedding agent has a real fixed approved job and
|
||||
/// authorized download. This function alone grants no stop/swap authority.
|
||||
pub fn write(
|
||||
dir: &Directory,
|
||||
descriptor: StageDescriptor<'_>,
|
||||
source: &mut impl Read,
|
||||
budget: &Budget,
|
||||
) -> Result<Self> {
|
||||
let StageDescriptor {
|
||||
role,
|
||||
nonce,
|
||||
original,
|
||||
expected_sha,
|
||||
length,
|
||||
} = descriptor;
|
||||
ensure!(
|
||||
!nonce.is_nil()
|
||||
&& valid_digest(expected_sha)
|
||||
&& length > 0
|
||||
&& length <= 256 * 1024 * 1024,
|
||||
"UPDATE_STAGE_DESCRIPTOR"
|
||||
);
|
||||
ensure!(
|
||||
original.identity.uid == 0 && original.identity.mode & 0o022 == 0,
|
||||
"UPDATE_ORIGINAL_METADATA"
|
||||
);
|
||||
let target = Path::new(role.target())
|
||||
.file_name()
|
||||
.context("UPDATE_TARGET")?
|
||||
.to_str()
|
||||
.context("UPDATE_TARGET")?
|
||||
.to_owned();
|
||||
ensure!(
|
||||
Path::new(role.target()).parent() == Some(dir.path.as_path()),
|
||||
"UPDATE_FIXED_ROLE_DIRECTORY"
|
||||
);
|
||||
dir.file(OsStr::new(&target), original, 256 * 1024 * 1024)?;
|
||||
let basename = format!(".rmm-update-{nonce}-{}.stage", role.label());
|
||||
budget.check()?;
|
||||
let mut fd = openat(
|
||||
&dir.fd,
|
||||
OsStr::new(&basename),
|
||||
libc::O_WRONLY | libc::O_CREAT | libc::O_EXCL,
|
||||
0o600,
|
||||
)?;
|
||||
let mut remaining = length;
|
||||
let mut hash = Sha256::new();
|
||||
let mut buffer = [0; 32768];
|
||||
while remaining > 0 {
|
||||
budget.check()?;
|
||||
let take = remaining.min(buffer.len() as u64) as usize;
|
||||
let n = source.read(&mut buffer[..take])?;
|
||||
ensure!(n > 0, "UPDATE_STAGE_SHORT");
|
||||
fd.write_all(&buffer[..n])?;
|
||||
hash.update(&buffer[..n]);
|
||||
remaining -= n as u64;
|
||||
}
|
||||
let mut tail = [0; 1];
|
||||
ensure!(
|
||||
source.read(&mut tail)? == 0 && hex::encode(hash.finalize()) == expected_sha,
|
||||
"UPDATE_STAGE_HASH_OR_EXCESS"
|
||||
);
|
||||
budget.check()?;
|
||||
// SAFETY: owned regular newly created file. Preserve old owner/group
|
||||
// and all mode bits; binaries/configs are not made more permissive.
|
||||
ensure!(
|
||||
unsafe { libc::fchown(fd.as_raw_fd(), original.identity.uid, original.identity.gid) }
|
||||
== 0,
|
||||
"UPDATE_STAGE_OWNER"
|
||||
);
|
||||
ensure!(
|
||||
unsafe { libc::fchmod(fd.as_raw_fd(), original.identity.mode & 0o7777) } == 0,
|
||||
"UPDATE_STAGE_MODE"
|
||||
);
|
||||
fd.sync_all()?;
|
||||
dir.sync()?;
|
||||
drop(fd);
|
||||
let file = dir.inspect(OsStr::new(&basename), 0, 256 * 1024 * 1024)?;
|
||||
ensure!(
|
||||
file.proof.identity.links == 1
|
||||
&& file.proof.sha256 == expected_sha
|
||||
&& file.proof.bytes == length,
|
||||
"UPDATE_STAGE_VERIFIED"
|
||||
);
|
||||
Ok(Self {
|
||||
role,
|
||||
nonce,
|
||||
basename,
|
||||
file,
|
||||
target,
|
||||
original: original.clone(),
|
||||
})
|
||||
}
|
||||
pub fn proof(&self) -> &FileProof {
|
||||
self.file.proof()
|
||||
}
|
||||
/// Two separately fenced namespace changes; a crash in between leaves the
|
||||
/// original backup and stage intact. This method NEVER retries or resumes.
|
||||
pub fn install(
|
||||
mut self,
|
||||
dir: &Directory,
|
||||
guard: &LedgerGuard<'_>,
|
||||
budget: &Budget,
|
||||
fence: &mut impl DurableEffectFence,
|
||||
) -> Result<Installed> {
|
||||
guard.verify_for_effect(budget)?;
|
||||
dir.verify()?;
|
||||
self.file.verify(256 * 1024 * 1024)?;
|
||||
dir.file(OsStr::new(&self.target), &self.original, 256 * 1024 * 1024)?;
|
||||
let backup = format!(".rmm-update-{}-{}.previous", self.nonce, self.role.label());
|
||||
dir.absent(OsStr::new(&backup))?;
|
||||
let save = Effect::SavePredecessor { role: self.role };
|
||||
fence.before_effect(&save)?;
|
||||
guard.verify_for_effect(budget)?;
|
||||
dir.named(OsStr::new(&self.target), &self.original.identity)?;
|
||||
dir.named(OsStr::new(&self.basename), &self.file.proof.identity)?;
|
||||
dir.rename_new(OsStr::new(&self.target), OsStr::new(&backup))?;
|
||||
dir.file(OsStr::new(&backup), &self.original, 256 * 1024 * 1024)?;
|
||||
fence.after_effect(&save, &digest(&serde_json::to_vec(&self.original)?))?;
|
||||
let publish = Effect::PublishReplacement { role: self.role };
|
||||
fence.before_effect(&publish)?;
|
||||
guard.verify_for_effect(budget)?;
|
||||
dir.named(OsStr::new(&self.basename), &self.file.proof.identity)?;
|
||||
dir.absent(OsStr::new(&self.target))?;
|
||||
dir.rename_new(OsStr::new(&self.basename), OsStr::new(&self.target))?;
|
||||
let current = dir.file(
|
||||
OsStr::new(&self.target),
|
||||
&self.file.proof,
|
||||
256 * 1024 * 1024,
|
||||
)?;
|
||||
fence.after_effect(&publish, &digest(&serde_json::to_vec(current.proof())?))?;
|
||||
Ok(Installed {
|
||||
role: self.role,
|
||||
target: self.target,
|
||||
backup,
|
||||
old: self.original,
|
||||
new: current.proof,
|
||||
})
|
||||
}
|
||||
}
|
||||
pub struct Installed {
|
||||
pub role: Role,
|
||||
target: String,
|
||||
backup: String,
|
||||
old: FileProof,
|
||||
new: FileProof,
|
||||
}
|
||||
impl Installed {
|
||||
pub fn old(&self) -> &FileProof {
|
||||
&self.old
|
||||
}
|
||||
pub fn new_file(&self) -> &FileProof {
|
||||
&self.new
|
||||
}
|
||||
/// A rollback is NOT inferred from a failed health check. Only a separately
|
||||
/// bound rollback fence may authorize it; unknown intermediate state denies.
|
||||
pub fn restore(
|
||||
self,
|
||||
dir: &Directory,
|
||||
guard: &LedgerGuard<'_>,
|
||||
budget: &Budget,
|
||||
fence: &mut impl DurableEffectFence,
|
||||
) -> Result<()> {
|
||||
guard.verify_for_effect(budget)?;
|
||||
dir.file(OsStr::new(&self.target), &self.new, 256 * 1024 * 1024)?;
|
||||
dir.file(OsStr::new(&self.backup), &self.old, 256 * 1024 * 1024)?;
|
||||
let displaced = self.backup.replace(".previous", ".rejected");
|
||||
dir.absent(OsStr::new(&displaced))?;
|
||||
let effect = Effect::RestorePredecessor { role: self.role };
|
||||
fence.before_effect(&effect)?;
|
||||
guard.verify_for_effect(budget)?;
|
||||
dir.rename_new(OsStr::new(&self.target), OsStr::new(&displaced))?;
|
||||
// No existing target can be overwritten; both code generations remain.
|
||||
guard.verify_for_effect(budget)?;
|
||||
dir.rename_new(OsStr::new(&self.backup), OsStr::new(&self.target))?;
|
||||
dir.file(OsStr::new(&self.target), &self.old, 256 * 1024 * 1024)?;
|
||||
fence.after_effect(&effect, &digest(&serde_json::to_vec(&self.old)?))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct LedgerIdentity {
|
||||
pub ledger: Identity,
|
||||
pub lock: Identity,
|
||||
}
|
||||
impl LedgerIdentity {
|
||||
pub fn sha256(&self) -> Result<String> {
|
||||
Ok(digest(&serde_json::to_vec(self)?))
|
||||
}
|
||||
}
|
||||
|
||||
/// Existing lock only: no create, truncate or alternate database. Acquire only
|
||||
/// after the caller independently confirmed every installed reader stopped.
|
||||
pub struct LedgerGuard<'a> {
|
||||
ledger: File,
|
||||
lock: File,
|
||||
directory: Directory,
|
||||
identity: LedgerIdentity,
|
||||
stopped: &'a crate::services::StoppedServices,
|
||||
}
|
||||
impl<'a> LedgerGuard<'a> {
|
||||
pub fn acquire(
|
||||
stopped: &'a crate::services::StoppedServices,
|
||||
identity: &LedgerIdentity,
|
||||
budget: &Budget,
|
||||
) -> Result<Self> {
|
||||
stopped.verify_still_stopped(budget)?;
|
||||
let directory = Directory::open(Path::new("/var/lib/rmm-helper"), 0, true)?;
|
||||
let ledger = openat(
|
||||
&directory.fd,
|
||||
OsStr::new("consumption.sqlite"),
|
||||
libc::O_RDONLY | libc::O_NONBLOCK,
|
||||
0,
|
||||
)?;
|
||||
let lock = openat(
|
||||
&directory.fd,
|
||||
OsStr::new("executor.lock"),
|
||||
libc::O_RDWR | libc::O_NONBLOCK,
|
||||
0,
|
||||
)?;
|
||||
let actual = LedgerIdentity {
|
||||
ledger: Identity::of(&ledger.metadata()?),
|
||||
lock: Identity::of(&lock.metadata()?),
|
||||
};
|
||||
ensure!(
|
||||
actual == *identity
|
||||
&& ledger.metadata()?.is_file()
|
||||
&& lock.metadata()?.is_file()
|
||||
&& actual.ledger.uid == 0
|
||||
&& actual.lock.uid == 0,
|
||||
"UPDATE_LEDGER_IDENTITY"
|
||||
);
|
||||
ensure!(
|
||||
unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0,
|
||||
"UPDATE_LEDGER_BUSY"
|
||||
);
|
||||
let result = Self {
|
||||
ledger,
|
||||
lock,
|
||||
directory,
|
||||
identity: actual,
|
||||
stopped,
|
||||
};
|
||||
result.verify_for_effect(budget)?;
|
||||
Ok(result)
|
||||
}
|
||||
pub fn identity(&self) -> &LedgerIdentity {
|
||||
&self.identity
|
||||
}
|
||||
pub fn verify(&self) -> Result<()> {
|
||||
self.directory.verify()?;
|
||||
ensure!(
|
||||
Identity::of(&self.ledger.metadata()?) == self.identity.ledger
|
||||
&& Identity::of(&self.lock.metadata()?) == self.identity.lock,
|
||||
"UPDATE_LEDGER_HELD_IDENTITY"
|
||||
);
|
||||
self.directory
|
||||
.named(OsStr::new("consumption.sqlite"), &self.identity.ledger)?;
|
||||
self.directory
|
||||
.named(OsStr::new("executor.lock"), &self.identity.lock)
|
||||
}
|
||||
pub fn verify_for_effect(&self, budget: &Budget) -> Result<()> {
|
||||
self.verify()?;
|
||||
self.stopped.verify_still_stopped(budget)
|
||||
}
|
||||
/// Caller must first COMMIT the exact LedgerReturnIntent. This consumes the
|
||||
/// guard, so it cannot be retained accidentally across the helper start.
|
||||
pub fn release(self, budget: &Budget, fence: &mut impl DurableEffectFence) -> Result<()> {
|
||||
self.verify_for_effect(budget)?;
|
||||
fence.before_effect(&Effect::ReturnLedger)?;
|
||||
self.verify_for_effect(budget)?;
|
||||
drop(self);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
impl Drop for LedgerGuard<'_> {
|
||||
fn drop(&mut self) {
|
||||
unsafe { libc::flock(self.lock.as_raw_fd(), libc::LOCK_UN) };
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user