Qyriad/dynix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: Qyriad:a9b63f4d58aeceb894f58b366f7323b964512c09
Branches Tags
Qyriad:main
..
compare: Qyriad:420fac5f18c44b6b06c1ab5bb94cb84e658b8556
Branches Tags
Qyriad:main

No commits in common. "a9b63f4d58aeceb894f58b366f7323b964512c09" and "420fac5f18c44b6b06c1ab5bb94cb84e658b8556" have entirely different histories.
a9b63f4d58 ... 420fac5f18

12 changed files with 210 additions and 520 deletions
Download patch file Download diff file Expand all files Collapse all files

10
Cargo.lock generated
View file

@ -223,7 +223,6 @@ dependencies = [
"tracing",
"tracing-human-layer",
"tracing-subscriber",
"which",
]
[[package]]
@ -852,15 +851,6 @@ version = "0.11.1+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
[[package]]
name = "which"
version = "8.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "81995fafaaaf6ae47a7d0cc83c67caf92aeb7e5331650ae6ff856f7c0c60c459"
dependencies = [
"libc",
]
[[package]]
name = "windows"
version = "0.61.3"

19
Cargo.toml
View file

@ -47,7 +47,6 @@ tap = "1.0.1"
tracing = { version = "0.1.44", features = ["attributes"] }
tracing-human-layer = "0.2.1"
tracing-subscriber = { version = "0.3.22", default-features = false, features = ["std", "env-filter", "fmt", "ansi", "registry", "parking_lot"] }
which = "8.0.2"
[profile.dev]
opt-level = 1
@ -64,21 +63,3 @@ opt-level = 1
[profile.release.package."*"]
debug = true
debug-assertions = true
[lints.clippy]
#arithmetic_side_effects = "warn"
as_ptr_cast_mut = "warn"
assigning_clones = "warn"
borrow_as_ptr = "warn"
#cargo_common_metadata = "warn"
cast_lossless = "warn"
#cast_possible_truncation = "warn"
cast_possible_wrap = "warn"
cast_ptr_alignment = "warn"
cast_sign_loss = "warn"
clear_with_drain = "warn"
coerce_container_to_any = "warn"
derive_partial_eq_without_eq = "warn"
doc_broken_link = "warn"
doc_comment_double_space_linebreaks = "warn"
doc_markdown = "warn"

2
package.nix
View file

@ -58,8 +58,6 @@ in {
inherit (self) strictDeps __structuredAttrs;
inherit (self) doCheck doInstallCheck;
outputs = [ "out" "doc" ];
src = lib.fileset.toSource {
root = ./.;
fileset = lib.fileset.unions [

10
rustfmt.toml
View file

@ -4,13 +4,3 @@
match_block_trailing_comma = true
merge_derives = false
# Unstable options.
blank_lines_upper_bound = 3
format_code_in_doc_comments = true
format_macro_matchers = true
# When structs, slices, arrays, and block/array-like macros are used as the last argument in an expression list,
# allow them to overflow (like blocks/closures) instead of being indented on a new line.
overflow_delimited_expr = true
# Put `type` and `const` items before methods.
reorder_impl_items = true

16
shell.nix
View file

@ -16,21 +16,7 @@
fenixLib ? let
src = fetchTarball "https://github.com/nix-community/fenix/archive/main.tar.gz";
in import src { inherit pkgs; },
fenixBaseToolchain ? fenixLib.stable.withComponents [
"cargo"
"rustc"
"llvm-tools"
"rust-std"
"rust-docs"
"rust-src"
"rustc-dev"
"clippy"
],
fenixToolchain ? fenixLib.combine [
fenixBaseToolchain
# Rustfmt is very handy to have as nightly.
fenixLib.latest.rustfmt
],
fenixToolchain ? fenixLib.latest.toolchain,
}: let
inherit (pkgs) lib;

377
src/daemon.rs
View file

@ -1,7 +1,7 @@
use std::{
env, io,
ops::Deref,
os::fd::{AsFd, BorrowedFd, IntoRawFd, OwnedFd, RawFd},
process::{Command, Stdio},
sync::{
Arc, LazyLock,
atomic::{AtomicUsize, Ordering},
@ -11,31 +11,18 @@ use std::{
use iddqd::{BiHashMap, IdOrdMap};
use mio::{Events, Interest, Poll, Token, event::Event, net::UnixListener, unix::SourceFd};
use mio::{Events, Interest, Poll, Token, net::UnixListener, unix::SourceFd};
use rustix::{
buffer::spare_capacity,
net::SocketFlags,
process::{Pid, PidfdFlags, Uid, WaitId, WaitIdOptions},
};
mod rustix {
pub use rustix::process::{getuid, pidfd_open, waitid};
pub use rustix::*;
}
//mod rustix_prelude {
// pub use rustix::process::{getuid, pidfd_open, waitid};
//}
use rustix::{buffer::spare_capacity, net::SocketFlags, process::Uid};
use serde::{Deserialize, Serialize};
use serde_json::StreamDeserializer;
use crate::prelude::*;
pub mod api;
use api::DaemonCmd;
use crate::daemon_tokfd::{FdInfo, FdKind};
use crate::{
SourceFile, SourceLine,
daemon_tokfd::{FdInfo, FdKind},
prelude::*,
};
use crate::{OwnedFdWithFlags, TokenFd};
@ -56,13 +43,75 @@ pub static TMPDIR: LazyLock<&'static Path> = LazyLock::new(|| {
Box::leak(dir)
});
pub static NIXOS_REBUILD: LazyLock<&'static Path> = LazyLock::new(|| {
which::which("nixos-rebuild")
.inspect_err(|e| error!("couldn't find `nixos-rebuild` in PATH: {e}"))
.map(PathBuf::into_boxed_path)
.map(|boxed| &*Box::leak(boxed))
.unwrap_or(Path::new("/run/current-system/sw/bin/nixos-rebuild"))
});
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[derive(Deserialize, Serialize)]
#[serde(untagged)]
pub enum ConvenientAttrPath {
Dotted(Box<str>),
Split(Box<[Box<str>]>),
}
impl ConvenientAttrPath {
/// Not currently used, but here for completeness.
#[expect(dead_code)]
pub fn clone_from_dotted(s: &str) -> Self {
Self::Dotted(Box::from(s))
}
/// Not currently used, but here for completeness.
#[expect(dead_code)]
pub fn clone_from_split(s: &[&str]) -> Self {
Self::from_str_iter(s.iter().map(Deref::deref))
}
pub fn from_str_iter<'i, I>(iter: I) -> Self
where
I: Iterator<Item = &'i str>,
{
let boxed = iter.map(Box::from);
Self::Split(Box::from_iter(boxed))
}
pub fn to_nix_decl(&self) -> Box<str> {
use ConvenientAttrPath::*;
match self {
Dotted(s) => s.clone(),
Split(path) => {
// FIXME: quote if necessary
path.join(".").into_boxed_str()
},
}
}
}
impl<'i> FromIterator<&'i str> for ConvenientAttrPath {
fn from_iter<I>(iter: I) -> Self
where
I: IntoIterator<Item = &'i str>,
{
Self::from_str_iter(iter.into_iter())
}
}
impl FromIterator<Box<str>> for ConvenientAttrPath {
fn from_iter<I>(iter: I) -> Self
where
I: IntoIterator<Item = Box<str>>,
{
Self::Split(Box::from_iter(iter))
}
}
#[derive(Debug, Clone, PartialEq)]
#[derive(serde::Deserialize, serde::Serialize)]
#[serde(tag = "action", content = "args", rename_all = "snake_case")]
// FIXME: rename to not confuse with the clap argument type.
pub enum DaemonCmd {
Append {
name: ConvenientAttrPath,
value: Box<str>,
},
}
const TIMEOUT_NEVER: Option<Duration> = None;
@ -72,49 +121,12 @@ fn next_token() -> Token {
// If the increment wrapped to 0, then we just increment it again.
if tok == 0 {
warn!("File descriptor token wrapped. That's... a lot.");
return next_token();
return Token(NEXT_TOKEN_NUMBER.fetch_add(1, Ordering::SeqCst));
}
Token(tok)
}
trait EventExt {
type Display;
fn display(&self) -> Self::Display;
}
#[derive(Copy)]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
struct EventDisplay {
token: Token,
error: bool,
writable: bool,
write_closed: bool,
readable: bool,
read_closed: bool,
}
impl EventExt for Event {
type Display = EventDisplay;
fn display(&self) -> Self::Display {
EventDisplay {
token: self.token(),
error: self.is_error(),
writable: self.is_writable(),
write_closed: self.is_write_closed(),
readable: self.is_readable(),
read_closed: self.is_read_closed(),
}
}
}
impl Display for EventDisplay {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
todo!()
}
}
#[derive(Debug)]
pub struct Daemon {
config_path: Arc<Path>,
@ -187,32 +199,6 @@ impl Daemon {
token
}
fn register_with_name<S>(&mut self, fd: RawFd, kind: FdKind, name: Box<OsStr>) -> Token {
let token = next_token();
debug!(
"Registering new {} FdInfo for {fd} ({}) with token {token:?}",
name.to_string_lossy(),
kind.name_str(),
);
self.fd_info
.insert_unique(FdInfo::new_with_name(fd, kind, name))
.unwrap();
self.tokfd
.insert_unique(TokenFd { token, fd })
.unwrap_or_else(|e| todo!("{e}"));
let mut source = SourceFd(&fd);
self.poller
.registry()
.register(&mut source, token, Interest::READABLE)
.unwrap_or_else(|e| unreachable!("registering {fd:?} with poller failed: {e}"));
token
}
fn deregister(&mut self, fd: RawFd) {
let info = self
.fd_info
@ -356,36 +342,9 @@ impl Daemon {
self.fd.as_fd()
}
}
const DAEMON: Token = Token(0);
/// Private helpers.
impl Daemon {
//fn proxy_stdio(&mut self, fd: &BorrowedFd) -> Result<(), IoError> {
// let info = self.fd_info.get(&fd.as_raw_fd()).unwrap();
// let label = match info.kind {
// FdKind::ChildStdout => "stdout",
// FdKind::ChildStderr => "stderr",
// other => unreachable!("child stdio cannot have kind {other:?}"),
// };
// // FIXME: don't use a new allocation every time.
// let mut buffer: Vec<u8> = Vec::with_capacity(1024);
// // FIXME: handle line buffering correctly.
// loop {
// let count = rustix::io::read(fd, spare_capacity(&mut buffer))
// .inspect_err(|e| error!("read() on child stdio fd {fd:?} failed: {e}"))?;
//
// if count == 0 {
// break;
// }
//
// for line in buffer.lines() {
// debug!("[child {label}]: {}", line.as_bstr())
// }
// }
//
// Ok(())
//}
fn read_cmd(&mut self, fd: &BorrowedFd) -> Result<(), IoError> {
// FIXME: don't use a new allocation every time.
let mut cmd_buffer: Vec<u8> = Vec::with_capacity(1024);
@ -424,63 +383,42 @@ impl Daemon {
}
fn dispatch_cmd(&mut self, cmd: DaemonCmd) -> Result<(), IoError> {
// Write the new file...
let (name, value) = match cmd {
DaemonCmd::Append { name, value } => (name, value),
};
let source_file = crate::open_source_file(self.config_path.clone())?;
let mut opts = File::options();
opts.read(true)
.write(true)
.create(false)
.custom_flags(libc::O_CLOEXEC);
let source_file = SourceFile::open_from(self.config_path.clone(), opts)?;
let pri = crate::get_where(source_file.clone()).unwrap_or_else(|e| todo!("{e}"));
let new_pri = pri - 1;
//let new_pri_line =
// crate::get_next_prio_line(source_file.clone(), Arc::from(name), Arc::from(value));
// Get next priority line.
let opt_name = name.to_nix_decl();
let new_line = crate::get_next_prio_line(source_file.clone(), &opt_name, new_pri, &value)
.unwrap_or_else(|e| panic!("someone is holding a reference to source.lines(): {e}"));
let source_lines = source_file.lines()?;
let penultimate = source_lines.get(source_lines.len() - 2);
// FIXME: don't rely on whitespace lol
debug_assert_eq!(penultimate.map(SourceLine::text).as_deref(), Some(" ];"));
let penultimate = penultimate.unwrap();
let new_generation = 0 - new_pri;
let new_line = SourceLine {
line: penultimate.line,
path: source_file.path(),
text: Arc::from(format!(
" {} = lib.mkOverride ({}) ({}); # DYNIX GENERATION {}",
name.to_nix_decl(),
new_pri,
value,
new_generation,
)),
};
drop(source_lines);
crate::write_next_prio(source_file, new_line).unwrap_or_else(|e| todo!("{e}"));
// Rebuild and switch.
// FIXME: allow passing additional args.
let child = Command::new(*NIXOS_REBUILD)
.arg("switch")
.arg("--log-format")
.arg("raw-with-logs")
.arg("--no-reexec")
.arg("-v")
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.inspect_err(|e| {
error!("failed to spawn `nixos-rebuild` command: {e}");
})?;
debug!("Spanwed child process {}", child.id());
let pid = Pid::from_child(&child);
let stdout = child.stdout.unwrap_or_else(|| {
unreachable!("`child` is given `.stdout(Stdio::piped())`");
});
let stderr = child.stderr.unwrap_or_else(|| {
unreachable!("`child` is given `.stderr(Stdio::piped())`");
});
let _token = self.register(stdout.into_raw_fd(), FdKind::ChildStdout);
let _token = self.register(stderr.into_raw_fd(), FdKind::ChildStderr);
match rustix::process::pidfd_open(pid, PidfdFlags::NONBLOCK) {
Ok(pidfd) => {
debug!("Opened pidfd {pidfd:?}, for process {pid}");
self.register(pidfd.into_raw_fd(), FdKind::Pid(pid));
},
Err(e) if e.kind() == IoErrorKind::NotFound => {
warn!("child {pid} not found; died before we could open it?");
},
Err(e) => {
error!("Error opening pidfd for child {pid}: {e}");
return Err(e)?;
},
}
Ok(())
}
@ -498,6 +436,7 @@ impl Daemon {
);
}
let mut daemon_source = SourceFd(&raw_fd);
const DAEMON: Token = Token(0);
self.tokfd
.insert_unique(TokenFd {
token: DAEMON,
@ -514,24 +453,15 @@ impl Daemon {
loop {
if tracing::enabled!(tracing::Level::DEBUG) {
debug!("Daemon loop iteration, with file descriptors: ");
//
trace!("Daemon loop iteration, with file descriptors: ");
for info in &self.fd_info {
debug!("- {}", info.display());
trace!("- {}", info.display());
}
}
let poll_result = self.poller.poll(&mut events, TIMEOUT_NEVER);
self.handle_poll(poll_result, &events)?;
}
}
fn handle_poll(
&mut self,
poll_result: Result<(), IoError>,
events: &Events,
) -> Result<(), IoError> {
match poll_result {
Ok(()) => {
match self.poller.poll(&mut events, TIMEOUT_NEVER) {
Ok(_) => {
trace!(
"mio::Poller::poll() got events: {:?}",
events.iter().size_hint().0,
@ -546,12 +476,11 @@ impl Daemon {
},
Err(e) if e.kind() == IoErrorKind::Interrupted => {
// EINTR is silly.
// Return early, and poll() again.
return Ok(());
continue;
},
Err(e) => {
if let Some(Errno::BADF) = e.raw_os_error().map(Errno::from_raw_os_error) {
panic!("EBADF on poller fd; IO safety violation?");
unreachable!("EBADF on poller fd; IO safety violation?");
}
warn!("mio Poll::poll() error: {e}");
self.fd_error_push(self.poller.as_raw_fd(), e)
@ -561,16 +490,8 @@ impl Daemon {
},
}
for event in events {
self.handle_event(event)?;
}
Ok(())
}
fn handle_event(&mut self, event: &Event) -> Result<(), IoError> {
trace!("Handling event {event:#?}");
for event in &events {
trace!("event is {event:?}");
match event.token() {
DAEMON => {
let is_sock = self.main_fd_info().kind == FdKind::Socket;
@ -578,8 +499,7 @@ impl Daemon {
// SAFETY: oh boy: disjoint borrows with extra steps.
let file_fd = unsafe { BorrowedFd::borrow_raw(self.fd.as_raw_fd()) };
self.read_cmd(&file_fd).unwrap();
return Ok(());
continue;
}
// Accept, first.
@ -601,8 +521,7 @@ impl Daemon {
self.fd
)
})?;
return Ok(());
continue;
},
};
@ -615,65 +534,21 @@ impl Daemon {
},
other_token => {
// This must be a stream fd.
let fd = self.fd_for_token(other_token).unwrap_or_else(|| {
unreachable!("tried to get fd for non-existent token? {other_token:?}")
let stream_fd = self.fd_for_token(other_token).unwrap_or_else(|| {
unreachable!("tried to get fd for no-existent token? {other_token:?}")
});
let Some(info) = self.fd_info.get(&fd) else {
panic!("Received an event on an unregistered fd {fd}; IO-safety violation?");
};
if event.is_read_closed() {
self.deregister(fd);
return Ok(());
}
match info.kind {
FdKind::Pid(pid) => {
debug!("Reaping child process {pid}");
// SAFETY: `fd` cannot have been closed yet, since that's what we do here.
let pidfd = unsafe { BorrowedFd::borrow_raw(fd) };
let status = rustix::waitid(WaitId::PidFd(pidfd), WaitIdOptions::EXITED)
.unwrap_or_else(|e| {
todo!("waitid() can fail? on pid {pid}: {e}");
})
.unwrap_or_else(|| {
todo!("waitid() returned None? for pid {pid}");
});
debug!("waitid() for pid {pid} returned status: {status:?}");
let is_dead = status.exited() || status.killed() || status.dumped();
if !is_dead {
todo!("Handle process {pid} events that aren't death: {status:?}");
}
let Some(exit_code) = status.exit_status() else {
unreachable!("Process {pid} died with no exit code at all? {status:?}");
};
debug!("Child process {pid} exited with code {exit_code}");
// Close the pidfd.
self.deregister(fd);
},
//FdKind::ChildStdout => {
// warn!("got stdout");
// todo!();
//},
//FdKind::ChildStderr => {
// warn!("got stderr");
// // SAFETY: oh boy.
// let stderr = unsafe { BorrowedFd::borrow_raw(fd) };
// self.proxy_stdio(&stderr).unwrap();
//},
FdKind::SockStream => {
self.deregister(stream_fd);
} else {
// SAFETY: oh boy.
let stream_fd = unsafe { BorrowedFd::borrow_raw(fd) };
let stream_fd = unsafe { BorrowedFd::borrow_raw(stream_fd) };
self.read_cmd(&stream_fd).unwrap();
},
kind => todo!("{kind:?}"),
};
}
},
}
Ok(())
}
}
}
}

59
src/daemon/api.rs
View file

@ -1,59 +0,0 @@
use std::ops::Deref;
use crate::prelude::*;
use serde::{Deserialize, Serialize};
mod impls;
/// Unfortunately, empty-string identifiers are valid Nix...
///
/// This type does not provide a [`Default`] impl, however.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[derive(Deserialize, Serialize)]
#[serde(untagged)]
pub enum ConvenientAttrPath {
Dotted(Box<str>),
Split(Box<[Box<str>]>),
}
impl ConvenientAttrPath {
pub fn clone_from_dotted(s: &str) -> Self {
Self::Dotted(Box::from(s))
}
pub fn clone_from_split(s: &[&str]) -> Self {
Self::from_str_iter(s.iter().map(Deref::deref))
}
pub fn from_str_iter<'i, I>(iter: I) -> Self
where
I: IntoIterator<Item = &'i str>,
{
let iter = iter.into_iter();
let boxed = iter.map(Box::from);
Self::Split(Box::from_iter(boxed))
}
pub fn to_nix_decl(&self) -> Box<str> {
use ConvenientAttrPath::*;
match self {
Dotted(s) => s.clone(),
Split(path) => {
// FIXME: quote if necessary
path.join(".").into_boxed_str()
},
}
}
}
#[derive(Debug, Clone, PartialEq)]
#[derive(serde::Deserialize, serde::Serialize)]
#[serde(tag = "action", content = "args", rename_all = "snake_case")]
// FIXME: rename to not confuse with the clap argument type.
pub enum DaemonCmd {
Append {
name: ConvenientAttrPath,
value: Box<str>,
},
}

27
src/daemon/api/impls.rs
View file

@ -1,27 +0,0 @@
use super::ConvenientAttrPath;
impl<'i> FromIterator<&'i str> for ConvenientAttrPath {
fn from_iter<I>(iter: I) -> Self
where
I: IntoIterator<Item = &'i str>,
{
Self::from_str_iter(iter)
}
}
impl FromIterator<Box<str>> for ConvenientAttrPath {
fn from_iter<I>(iter: I) -> Self
where
I: IntoIterator<Item = Box<str>>,
{
Self::Split(Box::from_iter(iter))
}
}
impl FromIterator<String> for ConvenientAttrPath {
fn from_iter<I>(iter: I) -> Self
where
I: IntoIterator<Item = String>,
{
let iter = iter.into_iter();
Self::Split(Box::from_iter(iter.map(String::into_boxed_str)))
}
}

17
src/daemon_tokfd.rs
View file

@ -3,7 +3,6 @@ use std::{os::fd::RawFd, sync::OnceLock};
use circular_buffer::CircularBuffer;
use iddqd::{BiHashItem, IdOrdItem};
use mio::Token;
use rustix::process::Pid;
use crate::prelude::*;
@ -77,11 +76,11 @@ impl FdInfo {
impl IdOrdItem for FdInfo {
type Key<'a> = &'a RawFd;
iddqd::id_upcast!();
fn key(&self) -> &RawFd {
&self.fd
}
iddqd::id_upcast!();
}
#[derive(Debug)]
@ -106,16 +105,13 @@ impl<'a> Display for FdInfoDisplay<'a> {
}
#[derive(Copy)]
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[non_exhaustive]
pub enum FdKind {
File,
Socket,
SockStream,
Poller,
ChildStdout,
ChildStderr,
Pid(Pid),
#[default]
Unknown,
}
@ -128,9 +124,6 @@ impl FdKind {
Socket => "socket",
SockStream => "socket stream",
Poller => "poller",
ChildStdout => "child stdout",
ChildStderr => "child stderr",
Pid(_) => "pidfd",
Unknown => "«unknown»",
}
}
@ -147,8 +140,6 @@ impl BiHashItem for TokenFd {
type K1<'a> = Token;
type K2<'a> = RawFd;
iddqd::bi_upcast!();
fn key1(&self) -> Token {
self.token
}
@ -156,6 +147,8 @@ impl BiHashItem for TokenFd {
fn key2(&self) -> RawFd {
self.fd
}
iddqd::bi_upcast!();
}
impl From<TokenFd> for (Token, RawFd) {

33
src/lib.rs
View file

@ -55,7 +55,6 @@ mod color;
pub use color::{_CLI_ENABLE_COLOR, SHOULD_COLOR};
mod daemon;
pub use daemon::Daemon;
pub use daemon::api as daemon_api;
mod daemon_io;
pub use daemon_io::OwnedFdWithFlags;
mod daemon_tokfd;
@ -99,22 +98,6 @@ static MK_OVERRIDE_RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?-u)\bmkOverride\s+\((?<priority>[\d-]+)\)").unwrap()
});
pub(crate) fn open_source_file(path: Arc<Path>) -> Result<SourceFile, IoError> {
let mut opts = File::options();
opts.read(true)
.write(true)
.create(false)
.custom_flags(libc::O_CLOEXEC);
SourceFile::open_from(Arc::clone(&path), opts)
.tap_err(|e| error!("couldn't open source file at {}: {e}", path.display()))
}
pub(crate) fn get_line_to_insert() -> SourceLine {
//
todo!();
}
#[tracing::instrument(level = "debug")]
pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynError> {
let filepath = Path::new(&args.file);
@ -126,16 +109,22 @@ pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynEr
filepath.to_path_buf()
};
let source_file = open_source_file(Arc::from(filepath))?;
let mut opts = File::options();
opts.read(true)
.write(true)
.create(false)
.custom_flags(libc::O_CLOEXEC);
let source_file = SourceFile::open_from(Arc::from(filepath), opts)?;
let pri = get_where(source_file.clone())?;
let new_pri = pri - 1;
let new_pri_line = get_next_prio_line(
source_file.clone(),
&append_args.name,
append_args.name,
new_pri,
&append_args.value,
append_args.value,
)?;
debug!("new_pri_line={new_pri_line}");
@ -220,9 +209,9 @@ pub fn get_where(dynamic_nix: SourceFile) -> Result<i64, BoxDynError> {
pub fn get_next_prio_line(
source: SourceFile,
option_name: &str,
option_name: Arc<str>,
new_prio: i64,
new_value: &str,
new_value: Arc<str>,
) -> Result<SourceLine, BoxDynError> {
let source_lines = source.lines()?;
let penultimate = source_lines.get(source_lines.len() - 2);

33
src/source.rs
View file

@ -6,7 +6,6 @@ use std::{
cell::{Ref, RefCell},
hash::Hash,
io::{BufRead, BufReader, BufWriter},
mem::{self, MaybeUninit},
ops::Deref,
ptr,
sync::{Arc, Mutex, OnceLock},
@ -104,28 +103,6 @@ pub struct SourceFile {
lines: Arc<OnceLock<RefCell<Vec<SourceLine>>>>,
}
#[derive(Debug)]
#[repr(transparent)]
pub struct OpaqueDerefSourceLines<'s>(Ref<'s, [SourceLine]>);
impl<'s> Deref for OpaqueDerefSourceLines<'s> {
type Target = [SourceLine];
fn deref(&self) -> &[SourceLine] {
&*self.0
}
}
#[derive(Debug)]
#[repr(transparent)]
pub struct OpaqueDerefSourceLine<'s>(Ref<'s, SourceLine>);
impl<'s> Deref for OpaqueDerefSourceLine<'s> {
type Target = SourceLine;
fn deref(&self) -> &SourceLine {
&*self.0
}
}
impl SourceFile {
/// Panics if `path` is a directory path instead of a file path.
pub fn open_from(path: Arc<Path>, options: OpenOptions) -> Result<Self, IoError> {
@ -182,17 +159,15 @@ impl SourceFile {
Ok(self._lines_slice())
}
pub fn lines(&self) -> Result<OpaqueDerefSourceLines<'_>, IoError> {
let lines = self._lines()?;
Ok(OpaqueDerefSourceLines(lines))
pub fn lines(&self) -> Result<impl Deref<Target = [SourceLine]> + '_, IoError> {
self._lines()
}
pub fn line(&self, line: Line) -> Result<OpaqueDerefSourceLine<'_>, IoError> {
pub fn line(&self, line: Line) -> Result<impl Deref<Target = SourceLine> + '_, IoError> {
let lines_lock = self._lines()?;
let line = Ref::map(lines_lock, |lines| &lines[line.index() as usize]);
Ok(OpaqueDerefSourceLine(line))
Ok(line)
}
/// `lines` but already be initialized.

1
tests/harmonia/test-script.py
View file

@ -80,7 +80,6 @@ machine.wait_for_unit("install-dynix.service")
dynix_out = machine.succeed("dynix --version")
assert "dynix" in dynix_out, f"dynix not in {dynix_out=}"
# Config should have our initial values.
config_toml = get_config_file()
assert int(config_toml['workers']) == 4, f"{config_toml['workers']=} != 4"