diff --git a/Cargo.lock b/Cargo.lock index 5f1595e..64fed08 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -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" diff --git a/Cargo.toml b/Cargo.toml index 38a75c3..7408fb0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -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" diff --git a/package.nix b/package.nix index 8f828c9..fa07871 100644 --- a/package.nix +++ b/package.nix @@ -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 [ diff --git a/rustfmt.toml b/rustfmt.toml index 02c4dd5..d662dc1 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -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 diff --git a/shell.nix b/shell.nix index a1b40ff..39cd49f 100644 --- a/shell.nix +++ b/shell.nix @@ -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; diff --git a/src/daemon.rs b/src/daemon.rs index 6fbbd86..4272486 100644 --- a/src/daemon.rs +++ b/src/daemon.rs @@ -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), + Split(Box<[Box]>), +} + +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, + { + let boxed = iter.map(Box::from); + Self::Split(Box::from_iter(boxed)) + } + + pub fn to_nix_decl(&self) -> Box { + 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(iter: I) -> Self + where + I: IntoIterator, + { + Self::from_str_iter(iter.into_iter()) + } +} + +impl FromIterator> for ConvenientAttrPath { + fn from_iter(iter: I) -> Self + where + I: IntoIterator>, + { + 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, + }, +} const TIMEOUT_NEVER: Option = 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, @@ -187,32 +199,6 @@ impl Daemon { token } - fn register_with_name(&mut self, fd: RawFd, kind: FdKind, name: Box) -> 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 = 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 = 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,166 +453,102 @@ 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(()) => { - trace!( - "mio::Poller::poll() got events: {:?}", - events.iter().size_hint().0, - ); - if events.is_empty() { - unreachable!( - "epoll_wait() with a \"forever\" timeout should never give empty events", + match self.poller.poll(&mut events, TIMEOUT_NEVER) { + Ok(_) => { + trace!( + "mio::Poller::poll() got events: {:?}", + events.iter().size_hint().0, ); - } - - let _ = self.fd_error_pop(self.poller.as_raw_fd()); - }, - Err(e) if e.kind() == IoErrorKind::Interrupted => { - // EINTR is silly. - // Return early, and poll() again. - return Ok(()); - }, - 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?"); - } - warn!("mio Poll::poll() error: {e}"); - self.fd_error_push(self.poller.as_raw_fd(), e) - .tap_err(|e| { - error!("accumulated too many errors for mio::Poll::poll(): {e}") - })?; - }, - } - - for event in events { - self.handle_event(event)?; - } - - Ok(()) - } - - fn handle_event(&mut self, event: &Event) -> Result<(), IoError> { - trace!("Handling event {event:#?}"); - - match event.token() { - DAEMON => { - let is_sock = self.main_fd_info().kind == FdKind::Socket; - if !is_sock { - // 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(()); - } - - // Accept, first. - let flags = SocketFlags::NONBLOCK | SocketFlags::CLOEXEC; - let stream_fd = match rustix::net::accept_with(&self.fd, flags) { - Ok(stream) => { - debug!( - "Accepted connection from socket {:?} as stream {:?}", - self.fd, stream, + if events.is_empty() { + unreachable!( + "epoll_wait() with a \"forever\" timeout should never give empty events", ); - stream - }, - Err(e) => { - error!("accept4 on daemon socket failed: {e}"); - self.fd_error_push(self.fd.as_raw_fd(), e.into()) - .tap_err(|e| { - error!( - "Accumulated too many errors for daemon fd {:?}: {e}", - self.fd - ) - })?; + } - return Ok(()); - }, - }; + let _ = self.fd_error_pop(self.poller.as_raw_fd()); + }, + Err(e) if e.kind() == IoErrorKind::Interrupted => { + // EINTR is silly. + continue; + }, + Err(e) => { + if let Some(Errno::BADF) = e.raw_os_error().map(Errno::from_raw_os_error) { + unreachable!("EBADF on poller fd; IO safety violation?"); + } + warn!("mio Poll::poll() error: {e}"); + self.fd_error_push(self.poller.as_raw_fd(), e) + .tap_err(|e| { + error!("accumulated too many errors for mio::Poll::poll(): {e}") + })?; + }, + } - // Add this stream to our poll interest list. - // NOTE: `stream_fd` is now effectively `ManuallyDrop`. - let stream_fd = stream_fd.into_raw_fd(); - let _token = self.register(stream_fd, FdKind::SockStream); - - // Wait for the next poll to handle. - }, - 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 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:?}"); + for event in &events { + trace!("event is {event:?}"); + match event.token() { + DAEMON => { + let is_sock = self.main_fd_info().kind == FdKind::Socket; + if !is_sock { + // 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(); + continue; } - let Some(exit_code) = status.exit_status() else { - unreachable!("Process {pid} died with no exit code at all? {status:?}"); + + // Accept, first. + let flags = SocketFlags::NONBLOCK | SocketFlags::CLOEXEC; + let stream_fd = match rustix::net::accept_with(&self.fd, flags) { + Ok(stream) => { + debug!( + "Accepted connection from socket {:?} as stream {:?}", + self.fd, stream, + ); + stream + }, + Err(e) => { + error!("accept4 on daemon socket failed: {e}"); + self.fd_error_push(self.fd.as_raw_fd(), e.into()) + .tap_err(|e| { + error!( + "Accumulated too many errors for daemon fd {:?}: {e}", + self.fd + ) + })?; + continue; + }, }; - debug!("Child process {pid} exited with code {exit_code}"); - // Close the pidfd. - self.deregister(fd); + // Add this stream to our poll interest list. + // NOTE: `stream_fd` is now effectively `ManuallyDrop`. + let stream_fd = stream_fd.into_raw_fd(); + let _token = self.register(stream_fd, FdKind::SockStream); + + // Wait for the next poll to handle. }, - //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 => { - // SAFETY: oh boy. - let stream_fd = unsafe { BorrowedFd::borrow_raw(fd) }; - self.read_cmd(&stream_fd).unwrap(); + other_token => { + // This must be a stream fd. + let stream_fd = self.fd_for_token(other_token).unwrap_or_else(|| { + unreachable!("tried to get fd for no-existent token? {other_token:?}") + }); + + if event.is_read_closed() { + self.deregister(stream_fd); + } else { + // SAFETY: oh boy. + let stream_fd = unsafe { BorrowedFd::borrow_raw(stream_fd) }; + self.read_cmd(&stream_fd).unwrap(); + } }, - kind => todo!("{kind:?}"), - }; - }, + } + } } - - Ok(()) } } diff --git a/src/daemon/api.rs b/src/daemon/api.rs deleted file mode 100644 index 077ce0f..0000000 --- a/src/daemon/api.rs +++ /dev/null @@ -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), - Split(Box<[Box]>), -} - -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, - { - let iter = iter.into_iter(); - let boxed = iter.map(Box::from); - Self::Split(Box::from_iter(boxed)) - } - - pub fn to_nix_decl(&self) -> Box { - 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, - }, -} diff --git a/src/daemon/api/impls.rs b/src/daemon/api/impls.rs deleted file mode 100644 index 41d64b9..0000000 --- a/src/daemon/api/impls.rs +++ /dev/null @@ -1,27 +0,0 @@ -use super::ConvenientAttrPath; - -impl<'i> FromIterator<&'i str> for ConvenientAttrPath { - fn from_iter(iter: I) -> Self - where - I: IntoIterator, - { - Self::from_str_iter(iter) - } -} -impl FromIterator> for ConvenientAttrPath { - fn from_iter(iter: I) -> Self - where - I: IntoIterator>, - { - Self::Split(Box::from_iter(iter)) - } -} -impl FromIterator for ConvenientAttrPath { - fn from_iter(iter: I) -> Self - where - I: IntoIterator, - { - let iter = iter.into_iter(); - Self::Split(Box::from_iter(iter.map(String::into_boxed_str))) - } -} diff --git a/src/daemon_tokfd.rs b/src/daemon_tokfd.rs index cb436c6..e00f5f2 100644 --- a/src/daemon_tokfd.rs +++ b/src/daemon_tokfd.rs @@ -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 for (Token, RawFd) { diff --git a/src/lib.rs b/src/lib.rs index 9475e70..40f983b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -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 = LazyLock::new(|| { Regex::new(r"(?-u)\bmkOverride\s+\((?[\d-]+)\)").unwrap() }); -pub(crate) fn open_source_file(path: Arc) -> Result { - 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, append_args: AppendCmd) -> Result<(), BoxDynError> { let filepath = Path::new(&args.file); @@ -126,16 +109,22 @@ pub fn do_append(args: Arc, 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 { pub fn get_next_prio_line( source: SourceFile, - option_name: &str, + option_name: Arc, new_prio: i64, - new_value: &str, + new_value: Arc, ) -> Result { let source_lines = source.lines()?; let penultimate = source_lines.get(source_lines.len() - 2); diff --git a/src/source.rs b/src/source.rs index 36cd70b..287f72e 100644 --- a/src/source.rs +++ b/src/source.rs @@ -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>>>, } -#[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, options: OpenOptions) -> Result { @@ -182,17 +159,15 @@ impl SourceFile { Ok(self._lines_slice()) } - pub fn lines(&self) -> Result, IoError> { - let lines = self._lines()?; - - Ok(OpaqueDerefSourceLines(lines)) + pub fn lines(&self) -> Result + '_, IoError> { + self._lines() } - pub fn line(&self, line: Line) -> Result, IoError> { + pub fn line(&self, line: Line) -> Result + '_, 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. diff --git a/tests/harmonia/test-script.py b/tests/harmonia/test-script.py index 39d0e5d..c40e130 100644 --- a/tests/harmonia/test-script.py +++ b/tests/harmonia/test-script.py @@ -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"