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

oh right this was supposed to be http

Browse source
This commit is contained in:
Qyriad 2026-03-30 13:39:56 +02:00
parent 1ca5aa2e97
commit adaa020029
14 changed files with 1187 additions and 1040 deletions
Download patch file Download diff file Expand all files Collapse all files

76
src/args.rs
View file

@ -3,8 +3,9 @@
// SPDX-License-Identifier: EUPL-1.1
use std::{
env,
env, iter,
net::SocketAddr,
ops::Deref,
sync::{Arc, LazyLock},
};
@ -26,31 +27,19 @@ pub struct AppendCmd {
#[derive(Debug, Clone, PartialEq, clap::Parser)]
#[command(long_about = None)]
pub struct DaemonCmd {
/// Read from stdin instead of a Unix socket.
#[arg(long)]
pub stdin: bool,
/// Manually specify the full alternative path to the server socket.
///
/// If not specified and `--stdin` is not specified, defaults to $XDG_RUNTIME_DIR/dynix.sock
#[arg(long)]
#[arg(conflicts_with = "stdin")]
pub socket: Option<PathBuf>,
/// Use a TCP port instead of a Unix socket or stdin. e.g.: 0.0.0.0:42420
#[arg(long)]
#[arg(conflicts_with = "socket")]
#[arg(conflicts_with = "stdin")]
pub tcp: Option<SocketAddr>,
/// Specify the bind address.
#[arg(long, default_value = "0.0.0.0:42420")]
pub bind: SocketAddr,
}
#[derive(Debug, Clone, PartialEq, clap::Subcommand)]
pub enum Subcommand {
Append(AppendCmd),
Daemon(DaemonCmd),
OpenApiDocs,
}
static DEFAULT_PATH: LazyLock<Box<OsStr>> = LazyLock::new(|| {
pub static DEFAULT_PATH: LazyLock<Arc<Path>> = LazyLock::new(|| {
// This has to be in a let binding to keep the storage around.
let nixos_config = env::var_os("NIXOS_CONFIG");
let nixos_config = nixos_config
@ -58,7 +47,7 @@ static DEFAULT_PATH: LazyLock<Box<OsStr>> = LazyLock::new(|| {
.map(Path::new)
.unwrap_or(Path::new("/etc/nixos/configuration.nix"));
nixos_config
let boxed = nixos_config
.parent()
.unwrap_or_else(|| {
error!(
@ -67,11 +56,48 @@ static DEFAULT_PATH: LazyLock<Box<OsStr>> = LazyLock::new(|| {
);
Path::new("/etc/nixos")
})
.join("dynamic.nix")
.into_os_string()
.into_boxed_os_str()
.join("dynamic.nix");
Arc::from(boxed)
});
#[repr(transparent)]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DynamicDotNix(pub Arc<Path>);
impl Default for DynamicDotNix {
fn default() -> Self {
DynamicDotNix(Arc::clone(&*DEFAULT_PATH))
}
}
impl From<&str> for DynamicDotNix {
fn from(s: &str) -> DynamicDotNix {
let path = Path::new(s);
let path: PathBuf = if path.is_relative() && !path.starts_with("./") {
iter::once(OsStr::new("./")).chain(path.iter()).collect()
} else {
path.to_path_buf()
};
DynamicDotNix(Arc::from(path))
}
}
impl Display for DynamicDotNix {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
write!(f, "{}", self.0.display())?;
Ok(())
}
}
impl Deref for DynamicDotNix {
type Target = Arc<Path>;
fn deref(&self) -> &Arc<Path> {
&self.0
}
}
#[derive(Debug, Clone, PartialEq, clap::Parser)]
#[command(version, about, author)]
#[command(arg_required_else_help(true), args_override_self(true))]
@ -82,9 +108,11 @@ pub struct Args {
/// The .nix file with dynamic overrides to modify.
/// [default: $(dirname ${NIXOS_CONFIG-/etc/nixos/configuration.nix})/dynamic.nix]
#[arg(long, global(true), default_value = &**DEFAULT_PATH)]
#[arg(long, global(true))]
#[arg(default_value_t)]
#[arg(hide_default_value(true))]
pub file: Arc<OsStr>,
//#[arg(value_parser = clap::value_parser!(PathBuf))]
pub file: DynamicDotNix,
#[command(subcommand)]
pub subcommand: Subcommand,

878
src/daemon.rs
View file

@ -1,67 +1,42 @@
use std::{
borrow::Cow,
env, io,
net::SocketAddr,
os::fd::{AsFd, BorrowedFd, IntoRawFd, OwnedFd, RawFd},
process::{Command, Stdio},
sync::{
Arc, LazyLock,
atomic::{AtomicUsize, Ordering},
},
time::Duration,
process::{Output, Stdio},
sync::LazyLock,
};
use iddqd::{BiHashMap, IdOrdMap};
use mio::{
Events, Interest, Poll, Token,
event::Event,
net::{TcpListener, UnixListener},
unix::SourceFd,
use axum::{
Json, Router,
extract::State,
http::{self, StatusCode, header::HeaderMap},
routing::post,
};
use tokio::{net::TcpListener, process::Command};
//use utoipa::{OpenApi as _, ToSchema, openapi::OpenApi};
//use utoipa_axum::router::{OpenApiRouter, UtoipaMethodRouterExt};
use rustix::{
buffer::spare_capacity,
net::SocketFlags,
process::{Pid, PidfdFlags, Uid, WaitId, WaitIdOptions},
};
use serde::{Deserialize, Serialize};
mod rustix {
pub use rustix::process::waitid;
pub use rustix::*;
}
//mod rustix_prelude {
// pub use rustix::process::{getuid, pidfd_open, waitid};
//}
use serde_json::StreamDeserializer;
use crate::prelude::*;
use crate::{SourceFile, prelude::*};
pub mod api;
use api::DaemonCmd;
use api::{ConvenientAttrPath, NixLiteral};
use crate::daemon_tokfd::{FdInfo, FdKind};
//pub static UID: LazyLock<Uid> = LazyLock::new(rustix::process::getuid);
use crate::{OwnedFdWithFlags, TokenFd};
//pub static USER_SOCKET_DIR: LazyLock<&'static Path> = LazyLock::new(|| {
// let dir: Box<Path> = env::var_os("XDG_RUNTIME_DIR")
// .map(PathBuf::from)
// .unwrap_or_else(|| ["/", "run", "user", &UID.to_string()].into_iter().collect())
// .into_boxed_path();
//
// Box::leak(dir)
//});
pub static UID: LazyLock<Uid> = LazyLock::new(rustix::process::getuid);
pub static USER_SOCKET_DIR: LazyLock<&'static Path> = LazyLock::new(|| {
let dir: Box<Path> = env::var_os("XDG_RUNTIME_DIR")
.map(PathBuf::from)
.unwrap_or_else(|| ["/", "run", "user", &UID.to_string()].into_iter().collect())
.into_boxed_path();
Box::leak(dir)
});
pub static TMPDIR: LazyLock<&'static Path> = LazyLock::new(|| {
let dir: Box<Path> = env::temp_dir().into_boxed_path();
Box::leak(dir)
});
//pub static TMPDIR: LazyLock<&'static Path> = LazyLock::new(|| {
// let dir: Box<Path> = env::temp_dir().into_boxed_path();
//
// Box::leak(dir)
//});
pub static NIX: LazyLock<&'static Path> = LazyLock::new(|| {
which::which("nix")
@ -71,667 +46,186 @@ pub static NIX: LazyLock<&'static Path> = LazyLock::new(|| {
.unwrap_or(Path::new("/run/current-system/sw/bin/nix"))
});
const TIMEOUT_NEVER: Option<Duration> = None;
pub async fn run(config: Config) {
let addr = config.addr.clone();
let router = Router::new()
.route("/set", post(ep_set_post))
// `.with_state()` has to be last for the type inference to work.
.with_state(config);
//let (router, api): (Router, OpenApi) = OpenApiRouter::with_openapi(ApiDoc::openapi())
// .routes(utoipa_axum::routes!(ep_set_post))
// // `.with_state()` has to be last for the type inference works.
// .with_state(config)
// .split_for_parts();
static NEXT_TOKEN_NUMBER: AtomicUsize = AtomicUsize::new(1);
fn next_token() -> Token {
let tok = NEXT_TOKEN_NUMBER.fetch_add(1, Ordering::SeqCst);
let listener = TcpListener::bind(addr).await.unwrap();
// 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();
}
Token(tok)
axum::serve(listener, router).await.unwrap();
}
#[derive(Debug)]
pub struct Daemon {
config_path: Arc<Path>,
fd: OwnedFdWithFlags,
path: Option<Box<Path>>,
poller: Poll,
fd_info: IdOrdMap<FdInfo>,
// Bijective mapping of [`mio::Token`]s to [`RawFd`]s.
tokfd: BiHashMap<TokenFd>,
#[derive(Debug, Clone)]
pub struct Config {
pub config_file: SourceFile,
pub addr: SocketAddr,
pub token: Option<String>,
}
/// `tokfd` handling.
impl Daemon {
fn fd_error_pop(&mut self, fd: RawFd) -> Option<IoError> {
let mut info = self.fd_info.get_mut(&fd).unwrap_or_else(|| {
if let Ok(name) = FdInfo::guess_name(fd) {
panic!(
"tried to pop error for unknown fd {fd} ({})",
name.to_string_lossy(),
);
}
panic!("tried to pop error for unknown fd {fd}")
});
info.error_buffer.pop_front().tap_some(|e| {
trace!("Popping error for {}: {e}", info.display());
})
}
fn fd_error_push(&mut self, fd: RawFd, error: IoError) -> Result<(), IoError> {
let mut info = self
.fd_info
.get_mut(&fd)
.unwrap_or_else(|| panic!("tried to push error for unknown fd {fd}"));
trace!("Pushing error for {}: {}", info.display(), error);
info.error_buffer.try_push_back(error)
}
fn main_fd_info(&self) -> &FdInfo {
self.fd_info.get(&self.fd.as_raw_fd()).unwrap_or_else(|| {
unreachable!(
"Main daemon fd {:?} was not registered with fd_info",
self.fd,
)
})
}
fn register(&mut self, fd: RawFd, kind: FdKind) -> Token {
let token = next_token();
debug!(
"Registering new {} FdInfo for {fd} with token {token:?}",
kind.name_str(),
);
self.fd_info.insert_unique(FdInfo::new(fd, kind)).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
}
#[expect(dead_code)]
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
.remove(&fd)
.unwrap_or_else(|| unreachable!("tried to unregister unknown fd {fd}"));
debug!("Unregistering fd {}; calling close()", info.display());
unsafe { rustix::io::close(fd) };
let res = unsafe { libc::fcntl(fd, libc::F_GETFD, 0) };
debug_assert_eq!(res, -1);
debug_assert_eq!(
IoError::last_os_error().raw_os_error(),
Some(Errno::BADF.raw_os_error()),
);
self.tokfd.remove2(&fd).unwrap_or_else(|| todo!());
}
fn fd_for_token(&self, token: Token) -> Option<RawFd> {
self.tokfd
.get1(&token)
.map(|TokenFd { fd, .. }| fd)
.copied()
}
/// Not currently used, but here for completeness.
#[expect(dead_code)]
fn token_for_fd(&self, fd: RawFd) -> Option<Token> {
self.tokfd
.get2(&fd)
.map(|TokenFd { token, .. }| token)
.copied()
}
#[derive(Debug, Clone, PartialEq, PartialOrd)]
#[derive(Deserialize, Serialize)]
//#[derive(ToSchema)]
pub struct SetParams {
pub name: ConvenientAttrPath,
pub value: NixLiteral,
}
impl Daemon {
pub fn new(
config_path: Arc<Path>,
fd: OwnedFd,
kind: FdKind,
name: Option<Box<OsStr>>,
) -> Self {
let mut fd_info: IdOrdMap<FdInfo> = Default::default();
// Supposedly, the only possible ways this can fail are EMFILE, ENFILE, and ENOMEM.
// If any of those are the case, we're screwed anyway.
let poller = Poll::new().unwrap_or_else(|e| panic!("can't create new mio::Poll: {e}"));
// Make sure we register the poller in `fd_info`, so we can keep track of its errors.
fd_info
.insert_unique(FdInfo::new(poller.as_raw_fd(), FdKind::Poller))
.unwrap_or_else(|e| unreachable!("{e}"));
let fd = OwnedFdWithFlags::new_with_fallback(fd);
fd_info
.insert_unique(FdInfo::new(fd.as_raw_fd(), kind))
.unwrap_or_else(|e| unreachable!("{e}"));
if let Some(name) = &name {
info!("opened daemon to {}", name.to_string_lossy());
} else {
debug!("opened daemon to {name:?} (fd {fd:?})");
}
let path = name
.as_ref()
.map(PathBuf::from)
.map(PathBuf::into_boxed_path);
Self {
config_path,
fd,
path,
poller,
fd_info,
tokfd: Default::default(),
}
}
pub fn from_tcp_socket_addr(config_path: Arc<Path>, addr: SocketAddr) -> Result<Self, IoError> {
let listener = TcpListener::bind(addr.clone())
.inspect_err(|e| error!("failed to bind to '{addr}': {e}"))?;
let listener_owned_fd = OwnedFd::from(listener);
// FIXME: should we KEEP_ALIVE?
rustix::net::sockopt::set_socket_keepalive(&listener_owned_fd, true).unwrap();
let name = OsString::from(addr.to_string()).into_boxed_os_str();
Ok(Self::new(
config_path,
listener_owned_fd,
FdKind::Socket,
Some(name),
))
}
pub fn from_unix_socket_path(config_path: Arc<Path>, path: &Path) -> Result<Self, IoError> {
// We unconditionally unlink() `path` before binding, but completely ignore the result.
let _ = rustix::fs::unlink(path);
let listener = UnixListener::bind(path)
.tap_err(|e| error!("failed to bind AF_UNIX socket at {}: {e}", path.display()))?;
let listener_owned_fd = OwnedFd::from(listener);
// FIXME: should we KEEP_ALIVE?
rustix::net::sockopt::set_socket_keepalive(&listener_owned_fd, true).unwrap();
let path: Box<OsStr> = path.to_path_buf().into_boxed_path().into_boxed_os_str();
Ok(Self::new(
config_path,
listener_owned_fd,
FdKind::Socket,
Some(path),
))
}
pub fn open_default_socket(config_path: Arc<Path>) -> Result<Self, IoError> {
use IoErrorKind::*;
let preferred = USER_SOCKET_DIR.join("dynix.sock").into_boxed_path();
let constructed = match Self::from_unix_socket_path(config_path.clone(), &preferred) {
Ok(v) => v,
Err(e) if e.kind() == Unsupported => {
//
return Err(e);
},
Err(e) => {
warn!(
"failed binding AF_UNIX socket at {}: {e}; trying elsewhere",
preferred.display(),
);
let fallback = TMPDIR.join("dynix.sock").into_boxed_path();
Self::from_unix_socket_path(config_path, &fallback).tap_err(|e| {
error!(
"failed binding AF_UNIX socket at {}: {e}",
fallback.display(),
)
})?
},
};
Ok(constructed)
}
/// This panics if stdin cannot be opened.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[derive(Deserialize, Serialize)]
//#[derive(ToSchema)]
pub struct SetResponse {
/// Will be 0 if everything is okay.
///
/// If you want to handle that error, use [`Daemon::from_raw_parts()`].
pub fn from_stdin(config_path: Arc<Path>) -> Self {
let stdin = io::stdin();
let fd = stdin
.as_fd()
.try_clone_to_owned()
.expect("dynix daemon could not open stdin; try a Unix socket?");
Self::new(config_path, fd, FdKind::File, None)
}
//pub unsafe fn from_raw_parts(fd: OwnedFd) -> Self {
// Self {
// fd: OwnedFdWithFlags::new_with_fallback(fd),
// }
//}
pub fn fd(&self) -> BorrowedFd<'_> {
self.fd.as_fd()
}
/// Will be -1 for an error with no code.
pub status: i64,
pub msg: Option<String>,
}
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(pid) => format!("stdout[{pid}]"),
FdKind::ChildStderr(pid) => format!("stderr[{pid}]"),
other => unreachable!("child stdio cannot have kind {other:?}"),
#[axum::debug_handler]
//#[utoipa::path(
// post,
// path = "/set",
// responses(
// (status = 200, description = "Request was valid", body = SetResponse)
// ),
//)]
async fn ep_set_post(
State(config): State<Config>,
headers: HeaderMap,
Json(SetParams { name, value }): Json<SetParams>,
) -> Result<Json<SetResponse>, StatusCode> {
debug!("POST /set with name={name:?}, value={value:?}");
if let Some(token) = &config.token {
let Some(auth) = headers.get(http::header::AUTHORIZATION) else {
// FIXME: technically RFC9110 requires us to respond with a
// `WWW-Authenticate` header.
error!("token specified in config but not provided in request");
return Err(StatusCode::UNAUTHORIZED);
};
// 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() {
info!("[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);
let _count = rustix::io::read(fd, spare_capacity(&mut cmd_buffer))
.tap_err(|e| error!("read() on daemon fd {fd:?} failed: {e}"))?;
// The buffer might have existing data from the last read.
let deserializer = serde_json::Deserializer::from_slice(&cmd_buffer);
let stream: StreamDeserializer<_, DaemonCmd> = deserializer.into_iter();
for cmd in stream {
let cmd = match cmd {
Ok(cmd) => cmd,
Err(e) if e.is_eof() => {
warn!("Got EOF before a valid command");
debug!("command buffer was: {:?}", cmd_buffer.as_bstr());
return Ok(());
},
Err(e) => {
warn!("error deserializing command: {e}");
debug!("command buffer was: {:?}", cmd_buffer.as_bstr());
// Don't propagate the error unless we have too many.
self.fd_error_push(fd.as_raw_fd(), e.into()).tap_err(|e| {
error!("Accumulated too many errors for daemon fd {fd:?}: {e}")
})?;
return Ok(());
},
};
debug!("got cmd: {cmd:?}");
let _ = rustix::io::write(fd, b"");
info!("dispatching command {cmd:?}");
self.dispatch_cmd(cmd).unwrap_or_else(|e| todo!("{e}"));
}
Ok(())
}
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 pri = crate::get_where(source_file.clone()).unwrap_or_else(|e| todo!("{e}"));
let new_pri = pri - 1;
// 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.to_nix_source(),
)
.unwrap_or_else(|e| panic!("someone is holding a reference to source.lines(): {e}"));
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}");
// })?;
let expr = "(import <nixpkgs/nixos> { }).config.dynamicism.applyDynamicConfiguration { }";
let child = Command::new(*NIX)
.arg("run")
.arg("--show-trace")
.arg("--log-format")
.arg("raw-with-logs")
.arg("--impure")
.arg("-E")
.arg(expr)
.tap(|cmd| {
if !tracing::enabled!(Level::INFO) {
return;
}
let args: Vec<Cow<'_, str>> = cmd.get_args().map(OsStr::to_string_lossy).collect();
let separated = args.join(" ");
info!("Spawning subprocess: [{separated}]");
})
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.inspect_err(|e| error!("failed to spawn `nix run` 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(pid));
let _token = self.register(stderr.into_raw_fd(), FdKind::ChildStderr(pid));
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(())
}
pub(crate) fn enter_loop(&mut self) -> Result<Option<()>, IoError> {
let raw_fd = self.fd.as_raw_fd();
if cfg!(debug_assertions) {
assert!(
self.fd_info.contains_key(&raw_fd),
"we should know about daemon fd {raw_fd}",
);
assert!(
self.fd_info.contains_key(&self.poller.as_raw_fd()),
"we should know about poller fd {}",
self.poller.as_raw_fd(),
);
}
let mut daemon_source = SourceFd(&raw_fd);
self.tokfd
.insert_unique(TokenFd {
token: DAEMON,
fd: raw_fd,
})
.unwrap();
self.poller
.registry()
.register(&mut daemon_source, DAEMON, Interest::READABLE)
.unwrap_or_else(|e| unreachable!("registering mio Poll for daemon fd {raw_fd:?}: {e}"));
let mut events = Events::with_capacity(1024);
loop {
if tracing::enabled!(tracing::Level::DEBUG) {
debug!("Daemon loop iteration, with file descriptors: ");
for info in &self.fd_info {
debug!("- {}", info.display());
}
}
let poll_result = self.poller.poll(&mut events, TIMEOUT_NEVER);
self.handle_poll(poll_result, &events)?;
// No need to go through UTF-8 decoding here.
if auth.as_bytes() != token.as_bytes() {
error!("token provided in request does not match configured token");
return Err(StatusCode::UNAUTHORIZED);
}
}
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",
);
}
let file = config.config_file.clone();
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}")
})?;
},
}
let prio = crate::get_where(file.clone());
let new_prio = prio - 1;
for event in events {
self.handle_event(event)?;
}
let opt_name = name.to_nix_decl();
let opt_val = value.to_nix_source();
let new_line = crate::get_next_prio_line(file.clone(), &opt_name, new_prio, &opt_val);
Ok(())
match crate::write_next_prio(file.clone(), new_line) {
Ok(()) => (),
Err(e) => {
error!("Couldn't write next generation to {}: {e}", file.display());
let status = e.raw_os_error().map(i64::from).unwrap_or(-1);
return Ok(Json(SetResponse {
status,
msg: Some(format!("{e}")),
}));
},
};
let child_status = match nix_run_apply(&config).await {
Ok(v) => v,
Err(e) => {
let status = e.raw_os_error().map(i64::from).unwrap_or(-1);
return Ok(Json(SetResponse {
status,
msg: Some(format!("{e}")),
}));
},
};
let Output {
status,
stdout,
stderr,
} = child_status;
if status.code() != Some(0) {
error!(
"Child `nix run` process returned non-zero code {:?}",
status.code(),
);
error!("Child stdout: {}", stdout.as_bstr());
error!("Child stderr: {}", stderr.as_bstr());
}
fn handle_event(&mut self, event: &Event) -> Result<(), IoError> {
trace!("Handling event {event:#?}");
let status = status.code().map(i64::from).unwrap_or(-1);
let msg = format!(
"Stdout: {}\nStderr: {}\n",
stdout.as_bstr(),
stderr.as_bstr()
);
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,
);
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(());
},
};
// 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?");
};
let either_available = event.is_readable() || event.is_writable();
if !either_available {
info!(
"Got EVENT for file descriptor '{}': r={}, w={}",
info.display(),
event.is_readable(),
event.is_writable(),
);
// FIXME: code duplication
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}");
});
trace!("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);
let stream = self
.fd_info
.iter()
.find_map(|info| (info.kind == FdKind::SockStream).then_some(info));
if let Some(stream) = stream {
// SAFETY: fixme.
let stream_fd = unsafe { BorrowedFd::borrow_raw(stream.fd) };
let payload = format!("{{ \"status\": {exit_code} }}\n");
if let Err(e) = rustix::io::write(stream_fd, payload.as_bytes()) {
error!("couldn't write reply to stream fd {stream_fd:?}: {e}");
}
}
},
FdKind::ChildStdout(_pid) => {
// SAFETY: oh boy.
let stdout = unsafe { BorrowedFd::borrow_raw(fd) };
self.proxy_stdio(&stdout)
.unwrap_or_else(|e| error!("failed to proxy child stdout: {e}"));
},
FdKind::ChildStderr(_pid) => {
// SAFETY: oh boy.
let stderr = unsafe { BorrowedFd::borrow_raw(fd) };
self.proxy_stdio(&stderr)
.unwrap_or_else(|e| error!("failed to proxy child stderr: {e}"));
},
FdKind::SockStream => {
// SAFETY: oh boy.
let stream_fd = unsafe { BorrowedFd::borrow_raw(fd) };
self.read_cmd(&stream_fd).unwrap();
},
kind => todo!("{kind:?}"),
};
if event.is_read_closed() {
self.deregister(fd);
return Ok(());
}
},
}
Ok(())
}
Ok(Json(SetResponse {
status,
msg: Some(msg),
}))
}
impl Drop for Daemon {
fn drop(&mut self) {
if let Some(path) = self.path.as_deref() {
let _ = rustix::fs::unlink(path);
}
}
async fn nix_run_apply(config: &Config) -> Result<Output, IoError> {
let configuration_nix = config
.config_file
.path()
.parent()
.unwrap()
.join("configuration.nix");
let configuration_nix = configuration_nix
.to_str()
.expect("specified NixOS config file is not a UTF-8 path");
let expr = format!(
"(import <nixpkgs/nixos> {{ configuration = {}; }})\
.config.dynamicism.applyDynamicConfiguration {{ baseConfiguration = {}; }}",
configuration_nix, configuration_nix,
);
let child = Command::new(*NIX)
.arg("run")
.arg("--show-trace")
.arg("--log-format")
.arg("raw-with-logs")
.arg("--impure")
.arg("-E")
.arg(expr)
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.tap(|cmd| {
if tracing::enabled!(Level::DEBUG) {
let args = cmd
.as_std()
.get_args()
.map(OsStr::to_string_lossy)
.join(" ");
debug!("Spawning command: `nix {args}`");
}
})
.spawn()
.inspect_err(|e| error!("error spawning command: {e}"))?;
let output = child.wait_with_output().await.inspect_err(|e| {
error!("couldn't wait for spawned child process: {e}");
})?;
Ok(output)
}
//#[derive(Copy)]
//#[derive(Debug, Clone, PartialEq)]
//#[derive(utoipa::OpenApi)]
//#[openapi(paths(ep_set_post))]
//pub struct ApiDoc;

7
src/daemon/api.rs
View file

@ -3,6 +3,7 @@ use std::ops::Deref;
use crate::prelude::*;
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;
mod impls;
@ -11,6 +12,7 @@ mod impls;
/// This type does not provide a [`Default`] impl, however.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[derive(Deserialize, Serialize)]
#[derive(ToSchema)]
#[serde(untagged)]
pub enum ConvenientAttrPath {
Dotted(Box<str>),
@ -47,8 +49,9 @@ impl ConvenientAttrPath {
}
}
#[derive(Debug, Clone, PartialEq)]
#[derive(Debug, Clone, PartialEq, PartialOrd)]
#[derive(Deserialize, Serialize)]
#[derive(ToSchema)]
#[serde(untagged)]
pub enum NixLiteral {
String(String),
@ -70,7 +73,7 @@ impl NixLiteral {
#[serde(tag = "action", content = "args", rename_all = "snake_case")]
// FIXME: rename to not confuse with the clap argument type.
pub enum DaemonCmd {
Append {
Set {
name: ConvenientAttrPath,
value: Box<NixLiteral>,
},

184
src/daemon_tokfd.rs
View file

@ -1,184 +0,0 @@
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::*;
const ERROR_BUFFER_LEN: usize = 8;
#[derive(Debug)]
pub struct FdInfo {
pub fd: RawFd,
pub kind: FdKind,
pub name: OnceLock<Box<OsStr>>,
pub error_buffer: CircularBuffer<ERROR_BUFFER_LEN, IoError>,
}
impl FdInfo {
pub fn new<Fd: AsRawFd>(fd: Fd, kind: FdKind) -> Self {
Self {
fd: fd.as_raw_fd(),
kind,
name: Default::default(),
error_buffer: Default::default(),
}
}
pub fn new_with_name<Fd: AsRawFd>(fd: Fd, kind: FdKind, name: Box<OsStr>) -> Self {
Self {
fd: fd.as_raw_fd(),
kind,
name: OnceLock::from(name),
error_buffer: Default::default(),
}
}
}
impl FdInfo {
pub(crate) fn guess_name<Fd: AsRawFd>(fd: Fd) -> Result<Box<OsStr>, IoError> {
let dev_fd_path = Path::new("/dev/fd").join(fd.as_raw_fd().to_string());
fs_err::read_link(dev_fd_path)
.map(PathBuf::into_os_string)
.map(OsString::into_boxed_os_str)
}
pub fn name(&self) -> &OsStr {
if let Some(name) = self.name.get() {
return name;
}
match Self::guess_name(self.fd) {
Ok(name) => {
let prev = self.name.set(name);
debug_assert_eq!(prev, Ok(()));
},
Err(e) => {
warn!(
"can't read link for {} /dev/fd/{}: {e}",
self.kind.name_str(),
self.fd,
);
return OsStr::new("«unknown»");
},
}
self.name.get().unwrap_or_else(|| unreachable!())
}
pub fn display(&self) -> FdInfoDisplay<'_> {
FdInfoDisplay { inner: self }
}
}
impl IdOrdItem for FdInfo {
type Key<'a> = &'a RawFd;
iddqd::id_upcast!();
fn key(&self) -> &RawFd {
&self.fd
}
}
#[derive(Debug)]
pub struct FdInfoDisplay<'a> {
inner: &'a FdInfo,
}
impl<'a> Display for FdInfoDisplay<'a> {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
write!(
f,
"{} fd {} ({})",
self.inner.kind,
self.inner.fd,
self.inner.name().to_string_lossy(),
)?;
if !self.inner.error_buffer.is_empty() {
write!(f, "; with errors: {}", self.inner.error_buffer.len())?;
}
Ok(())
}
}
#[derive(Copy)]
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum FdKind {
File,
Socket,
SockStream,
Poller,
ChildStdout(Pid),
ChildStderr(Pid),
Pid(Pid),
#[default]
Unknown,
}
impl FdKind {
pub fn name_str(self) -> &'static str {
use FdKind::*;
match self {
File => "file",
Socket => "socket",
SockStream => "socket stream",
Poller => "poller",
ChildStdout(_) => "child stdout",
ChildStderr(_) => "child stderr",
Pid(_) => "pidfd",
Unknown => "«unknown»",
}
}
}
impl Display for FdKind {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
use FdKind::*;
let name = self.name_str();
match self {
ChildStdout(pid) | ChildStderr(pid) | Pid(pid) => write!(f, "{name} for {pid}")?,
_ => write!(f, "{name}")?,
};
Ok(())
}
}
#[derive(Copy)]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct TokenFd {
pub token: Token,
pub fd: RawFd,
}
impl BiHashItem for TokenFd {
type K1<'a> = Token;
type K2<'a> = RawFd;
iddqd::bi_upcast!();
fn key1(&self) -> Token {
self.token
}
fn key2(&self) -> RawFd {
self.fd
}
}
impl From<TokenFd> for (Token, RawFd) {
fn from(TokenFd { token, fd }: TokenFd) -> (Token, RawFd) {
(token, fd)
}
}
impl From<(Token, RawFd)> for TokenFd {
fn from((token, fd): (Token, RawFd)) -> TokenFd {
TokenFd { token, fd }
}
}

58
src/lib.rs
View file

@ -7,7 +7,7 @@ use std::{
sync::{Arc, LazyLock},
};
pub(crate) mod prelude {
pub mod prelude {
#![allow(unused_imports)]
pub use std::{
@ -54,12 +54,9 @@ mod boxext;
mod color;
pub use color::{_CLI_ENABLE_COLOR, SHOULD_COLOR};
mod daemon;
pub use daemon::Daemon;
//pub use daemon::ApiDoc;
pub use daemon::api as daemon_api;
mod daemon_io;
pub use daemon_io::OwnedFdWithFlags;
mod daemon_tokfd;
pub(crate) use daemon_tokfd::TokenFd;
pub mod line;
pub use line::Line;
mod nixcmd;
@ -117,7 +114,7 @@ pub(crate) fn get_line_to_insert() -> SourceLine {
#[tracing::instrument(level = "debug")]
pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynError> {
let filepath = Path::new(&args.file);
let filepath = &args.file;
let filepath: PathBuf = if filepath.is_relative() && !filepath.starts_with("./") {
iter::once(OsStr::new("./"))
.chain(filepath.iter())
@ -127,7 +124,7 @@ pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynEr
};
let source_file = open_source_file(Arc::from(filepath))?;
let pri = get_where(source_file.clone())?;
let pri = get_where(source_file.clone());
let new_pri = pri - 1;
@ -136,7 +133,7 @@ pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynEr
&append_args.name,
new_pri,
&append_args.value,
)?;
);
debug!("new_pri_line={new_pri_line}");
@ -147,32 +144,23 @@ pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynEr
//#[tracing::instrument(level = "debug")]
pub fn do_daemon(args: Arc<Args>, daemon_args: DaemonCmd) -> Result<(), BoxDynError> {
let config_file = Path::new(&args.file);
let config_file: PathBuf = if config_file.is_relative() && !config_file.starts_with("./") {
iter::once(OsStr::new("./"))
.chain(config_file.iter())
.collect()
} else {
config_file.to_path_buf()
};
let config_file: Arc<Path> = Arc::from(config_file);
let config_file: Arc<Path> = Arc::clone(&args.file);
// FIXME: make configurable?
let _ = rustix::process::umask(Mode::from_bits_retain(0o600).complement());
let mut daemon = match daemon_args {
DaemonCmd { stdin: true, .. } => Daemon::from_stdin(config_file),
DaemonCmd { tcp: Some(tcp), .. } => Daemon::from_tcp_socket_addr(config_file, tcp)?,
DaemonCmd { socket: None, .. } => Daemon::open_default_socket(config_file)?,
DaemonCmd {
socket: Some(socket),
..
} => Daemon::from_unix_socket_path(config_file, &socket)?,
let rt = tokio::runtime::Runtime::new().expect("couldn't start tokio runtime");
let config = daemon::Config {
config_file: SourceFile::new(config_file).unwrap(),
addr: daemon_args.bind,
// FIXME
token: None,
};
daemon.enter_loop().unwrap();
info!("daemon has exited");
rt.block_on(async move {
daemon::run(config).await;
});
Ok(())
}
@ -207,8 +195,8 @@ fn maybe_extract_prio_from_line(line: &SourceLine) -> Option<i64> {
})
}
pub fn get_where(dynamic_nix: SourceFile) -> Result<i64, BoxDynError> {
let lines = dynamic_nix.lines()?;
pub fn get_where(dynamic_nix: SourceFile) -> i64 {
let lines = dynamic_nix.lines();
let prio = lines
.iter()
.filter_map(maybe_extract_prio_from_line)
@ -216,7 +204,7 @@ pub fn get_where(dynamic_nix: SourceFile) -> Result<i64, BoxDynError> {
.next() // Priorities with lower integer values are "stronger" priorities.
.unwrap_or(0);
Ok(prio)
prio
}
pub fn get_next_prio_line(
@ -224,8 +212,8 @@ pub fn get_next_prio_line(
option_name: &str,
new_prio: i64,
new_value: &str,
) -> Result<SourceLine, BoxDynError> {
let source_lines = source.lines()?;
) -> SourceLine {
let source_lines = source.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(" ];"));
@ -243,10 +231,10 @@ pub fn get_next_prio_line(
)),
};
Ok(new_line)
new_line
}
pub fn write_next_prio(mut source: SourceFile, new_line: SourceLine) -> Result<(), BoxDynError> {
pub fn write_next_prio(mut source: SourceFile, new_line: SourceLine) -> Result<(), IoError> {
let new_mod_start = SourceLine {
line: new_line.line.prev(),
path: source.path(),

25
src/line.rs
View file

@ -37,8 +37,33 @@ impl Line {
self.0
}
#[cfg(target_pointer_width = "64")]
pub const fn index_usize(self) -> usize {
self.0 as usize
}
/// 1-indexed
pub const fn linenr(self) -> u64 {
self.0 + 1
}
}
/// [Alternate](Formatter::alternate) flag capitalizes "line".
///
/// ```
/// # use dynix::Line;
/// let line = Line::from_index(22);
/// assert_eq!(format!("{line}"), "line 23");
/// assert_eq!(format!("{line:#}"), "Line 23");
/// ```
impl Display for Line {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
if f.alternate() {
write!(f, "Line {}", self.linenr())?;
} else {
write!(f, "line {}", self.linenr())?;
}
Ok(())
}
}

5
src/main.rs
View file

@ -11,6 +11,7 @@ use clap::{ColorChoice, Parser as _};
use tracing_human_layer::HumanLayer;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::{EnvFilter, layer::SubscriberExt};
use utoipa::OpenApi as _;
fn main_wrapped() -> Result<(), Box<dyn StdError + Send + Sync + 'static>> {
// Default RUST_LOG to warn if it's not specified.
@ -43,6 +44,10 @@ fn main_wrapped() -> Result<(), Box<dyn StdError + Send + Sync + 'static>> {
match &args.subcommand {
Append(append_args) => dynix::do_append(args.clone(), append_args.clone())?,
Daemon(daemon_args) => dynix::do_daemon(args.clone(), daemon_args.clone())?,
OpenApiDocs => {
//let api = dynix::ApiDoc::openapi();
//dbg!(api);
},
};
}

184
src/source.rs
View file

@ -3,12 +3,10 @@
// SPDX-License-Identifier: EUPL-1.1
use std::{
cell::{Ref, RefCell},
hash::Hash,
io::{BufRead, BufReader, BufWriter},
ops::Deref,
ptr,
sync::{Arc, Mutex, OnceLock},
sync::{Arc, LazyLock},
};
use crate::Line;
@ -18,6 +16,17 @@ use crate::prelude::*;
use fs_err::OpenOptions;
use itertools::Itertools;
// parking_lot's RwLock has RwLockReadGuard::map() in stable Rust.
use parking_lot::{MappedRwLockReadGuard, RwLock, RwLockReadGuard};
pub(crate) static DEFAULT_OPEN_OPTIONS: LazyLock<OpenOptions> = LazyLock::new(|| {
let mut opts = fs_err::OpenOptions::new();
opts.read(true)
.write(true)
.create(false)
.custom_flags(libc::O_CLOEXEC);
opts
});
pub fn replace_file<'a>(
path: &Path,
@ -97,35 +106,17 @@ impl Display for SourceLine {
#[derive(Debug, Clone)]
pub struct SourceFile {
path: Arc<Path>,
file: Arc<Mutex<File>>,
/// References to `SourceFile` do not prevent mutating `lines`.
/// Also `lines` is lazily initialized.
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
}
lines: Arc<RwLock<Vec<SourceLine>>>,
}
impl SourceFile {
pub fn new<P>(path: P) -> Result<Self, IoError>
where
P: Into<Arc<Path>>,
{
Self::open_from(path.into(), DEFAULT_OPEN_OPTIONS.clone())
}
/// Panics if `path` is a directory path instead of a file path.
pub fn open_from(path: Arc<Path>, options: OpenOptions) -> Result<Self, IoError> {
trace!(
@ -135,69 +126,43 @@ impl SourceFile {
);
assert!(path.file_name().is_some());
let file = Arc::new(Mutex::new(options.open(&*path)?));
Ok(Self {
path,
file,
lines: Default::default(),
})
}
pub fn buf_reader(&mut self) -> Result<BufReader<&mut File>, IoError> {
let file_mut = Arc::get_mut(&mut self.file)
.unwrap_or_else(|| panic!("'File' for {} has existing handle", self.path.display()))
.get_mut()
.unwrap_or_else(|e| {
panic!("'File' for {} was mutex-poisoned: {e}", self.path.display())
});
let reader = BufReader::new(file_mut);
Ok(reader)
}
fn _lines(&self) -> Result<Ref<'_, [SourceLine]>, IoError> {
if let Some(lines) = self.lines.get() {
let as_slice = Ref::map(lines.borrow(), |lines| lines.as_slice());
return Ok(as_slice);
}
let lines = BufReader::new(&*self.file.lock().unwrap())
let mut file = options
.open(&*path)
.inspect_err(|e| error!("Failed to open path at {}: {e}", path.display()))?;
trace!("File opened to {file:?} ({})", file.as_raw_fd());
let reader = BufReader::new(&mut file);
let lines = reader
.lines()
.enumerate()
.map(|(index, line_res)| {
line_res.map(|line| SourceLine {
line: Line::from_index(index as u64),
path: Arc::clone(&self.path),
text: Arc::from(line),
})
let line = Line::from_index(index as u64);
line_res
.map(|contents| SourceLine {
line,
path: Arc::clone(&path),
text: Arc::from(contents),
})
.inspect_err(|e| {
error!("Failed to read line {line} of {}: {e}", path.display());
})
})
.collect::<Result<Vec<SourceLine>, IoError>>()?;
// Mutex should have dropped by now.
debug_assert!(self.file.try_lock().is_ok());
.collect::<Result<Vec<SourceLine>, IoError>>()
.inspect_err(|e| {
error!("Failed to read source file at {}: {e}", path.display());
})?;
self.lines.set(RefCell::new(lines)).unwrap();
let lines = Arc::new(RwLock::new(lines));
Ok(self._lines_slice())
Ok(Self { path, lines })
}
pub fn lines(&self) -> Result<OpaqueDerefSourceLines<'_>, IoError> {
let lines = self._lines()?;
Ok(OpaqueDerefSourceLines(lines))
pub fn lines(&self) -> _detail::OpaqueSourceLines<'_> {
_detail::OpaqueSourceLines(self._lines())
}
pub fn line(&self, line: Line) -> Result<OpaqueDerefSourceLine<'_>, IoError> {
let lines_lock = self._lines()?;
let line = Ref::map(lines_lock, |lines| &lines[line.index() as usize]);
Ok(OpaqueDerefSourceLine(line))
}
/// `lines` but already be initialized.
fn _lines_slice(&self) -> Ref<'_, [SourceLine]> {
debug_assert!(self.lines.get().is_some());
Ref::map(self.lines.get().unwrap().borrow(), |lines| lines.as_slice())
/// Panics if `line` is out of range.
pub fn line(&self, line: Line) -> _detail::OpaqueSourceLine<'_> {
_detail::OpaqueSourceLine(self._line(line))
}
/// With debug assertions, panics if `lines` are not contiguous.
@ -210,7 +175,7 @@ impl SourceFile {
debug_assert!(new_lines.is_sorted_by(|lhs, rhs| lhs.line.next() == rhs.line));
let path = self.path();
let cur_lines = self.lines()?;
let cur_lines = self.lines();
let first_half = cur_lines
.iter()
.take(num_lines_before_new)
@ -236,7 +201,9 @@ impl SourceFile {
debug_assert!(final_lines.is_sorted_by(|lhs, rhs| lhs.line.next() == rhs.line));
debug_assert_eq!(cur_lines.len() + new_lines.len(), final_lines.len());
// Stop locking self.lines or we won't be able to write to it.
drop(cur_lines);
debug_assert!(!self.lines.is_locked());
let data = final_lines
.iter()
@ -244,8 +211,11 @@ impl SourceFile {
.pipe(|iterator| Itertools::intersperse(iterator, b"\n"));
replace_file(&path, data)?;
debug_assert_ne!(self.lines.read().len(), final_lines.len());
// Finally, update state.
self.lines.get().unwrap().replace(final_lines);
let mut lines_guard = self.lines.write();
*lines_guard = final_lines;
Ok(())
}
@ -253,6 +223,22 @@ impl SourceFile {
pub fn path(&self) -> Arc<Path> {
Arc::clone(&self.path)
}
pub fn display(&self) -> std::path::Display<'_> {
self.path.display()
}
}
impl SourceFile {
fn _lines(&self) -> MappedRwLockReadGuard<'_, [SourceLine]> {
let lines = RwLock::read(&self.lines);
RwLockReadGuard::map(lines, Vec::as_slice)
}
fn _line(&self, line: Line) -> MappedRwLockReadGuard<'_, SourceLine> {
let lines = self._lines();
MappedRwLockReadGuard::map(lines, |lines| lines.get(line.index() as usize).unwrap())
}
}
impl PartialEq for SourceFile {
@ -260,3 +246,33 @@ impl PartialEq for SourceFile {
*self.path == *other.path
}
}
/// Types in this module are conceptually opaque, but their concrete implementations
/// are provided because opaque types in Rust are difficult to work with.
pub mod _detail {
use std::ops::Deref;
use super::*;
#[derive(Debug)]
#[repr(transparent)]
pub struct OpaqueSourceLines<'s>(pub(crate) MappedRwLockReadGuard<'s, [SourceLine]>);
impl<'s> Deref for OpaqueSourceLines<'s> {
type Target = [SourceLine];
fn deref(&self) -> &[SourceLine] {
&*self.0
}
}
#[derive(Debug)]
#[repr(transparent)]
pub struct OpaqueSourceLine<'s>(pub(crate) MappedRwLockReadGuard<'s, SourceLine>);
impl<'s> Deref for OpaqueSourceLine<'s> {
type Target = SourceLine;
fn deref(&self) -> &SourceLine {
&*self.0
}
}
}