use std::fs::File;
use std::fs::OpenOptions;
use std::io::Write;
use std::os::unix::fs::OpenOptionsExt;
use std::path::PathBuf;
use std::sync::Arc;
use anyhow::Context;
use anyhow::Error;
use clap::Parser;
use hermit::Backend;
use tracing::metadata::LevelFilter;
use super::tracing::BoundedWriter;
use super::tracing::LatchedWriter;
use super::tracing::TracingGuard;
use super::tracing::WriteErrorLatch;
use super::tracing::init_file_tracing;
use super::tracing::init_file_tracing_with_evidence;
use super::tracing::init_stderr_tracing;
use super::tracing::init_stderr_tracing_with_evidence;
use super::tracing::log_max_bytes;
const CONTROLLER_TARGET: &str = "hermit::controller";
#[derive(Debug, Parser, Clone)]
pub struct GlobalOpts {
#[clap(short, long, value_name = "LEVEL", env = "HERMIT_LOG")]
pub log: Option<LevelFilter>,
#[clap(long, value_name = "FILE", env = "HERMIT_LOG_FILE")]
pub log_file: Option<PathBuf>,
#[clap(skip)]
pub log_file_handle: Option<Arc<File>>,
#[clap(skip)]
pub(crate) run_evidence_log_handle: Option<Arc<File>>,
#[clap(skip)]
pub(crate) run_evidence_write_error: Option<WriteErrorLatch>,
#[clap(long, value_enum, value_name = "BACKEND")]
pub backend: Option<Backend>,
}
impl GlobalOpts {
pub fn open_log_file(&mut self) -> Result<(), Error> {
if let Some(path) = &self.log_file {
let file = OpenOptions::new()
.create(true)
.truncate(true)
.write(true)
.custom_flags(libc::O_CLOEXEC | libc::O_NOFOLLOW)
.open(path)
.with_context(|| {
format!("cannot open --log-file {} for writing", path.display())
})?;
self.log_file_handle = Some(Arc::new(file));
}
Ok(())
}
pub(crate) fn write_controller_diagnostic(
&self,
message: std::fmt::Arguments<'_>,
) -> Result<(), Error> {
if let Some(handle) = &self.log_file_handle {
use tracing_subscriber::fmt::format::Writer;
use tracing_subscriber::fmt::time::FormatTime;
let mut timestamp = String::new();
tracing_subscriber::fmt::time::SystemTime
.format_time(&mut Writer::new(&mut timestamp))
.map_err(|_| anyhow::anyhow!("cannot format the controller diagnostic time"))?;
writeln!(
&**handle,
"{timestamp} DEBUG {CONTROLLER_TARGET}: {message}"
)
.context("cannot write to the host log file")?;
} else {
let _ = writeln!(detcore::util::RetryingStderr, "{message}");
}
Ok(())
}
pub(crate) fn set_run_evidence_log_handle(
&mut self,
handle: Arc<File>,
write_error: WriteErrorLatch,
) {
self.run_evidence_log_handle = Some(handle);
self.run_evidence_write_error = Some(write_error);
}
fn run_evidence_writer(&self, limit: u64) -> Option<LatchedWriter<BoundedWriter<File>>> {
self.run_evidence_log_handle.as_ref().map(|evidence| {
let evidence = evidence
.try_clone()
.expect("cannot duplicate the private run-evidence descriptor");
let evidence = BoundedWriter::new(evidence, limit);
let write_error = self
.run_evidence_write_error
.as_ref()
.expect("private run-evidence writer is missing its error latch")
.clone();
LatchedWriter::new(evidence, write_error)
})
}
#[must_use = "This function returns a guard that should not be immediately dropped"]
pub fn init_tracing(&self) -> Option<TracingGuard> {
self.init_tracing_for_backend(self.backend.unwrap_or_default())
}
#[must_use = "This function returns a guard that should not be immediately dropped"]
pub fn init_tracing_for_backend(&self, backend: Backend) -> Option<TracingGuard> {
if let Some(handle) = &self.log_file_handle {
let file_writer = handle
.try_clone()
.expect("cannot duplicate the host log file descriptor");
let limit = log_max_bytes().unwrap_or_else(|e| panic!("{e}"));
let file_writer = BoundedWriter::new(file_writer, limit);
if let Some(evidence) = self.run_evidence_writer(limit) {
Some(init_file_tracing_with_evidence(
self.log,
file_writer,
evidence,
))
} else {
Some(init_file_tracing(self.log, file_writer))
}
} else if let Some(path) = &self.log_file {
let file_writer = File::create(path).expect("Failed to open log file");
let limit = log_max_bytes().unwrap_or_else(|e| panic!("{e}"));
let file_writer = BoundedWriter::new(file_writer, limit);
if let Some(evidence) = self.run_evidence_writer(limit) {
Some(init_file_tracing_with_evidence(
self.log,
file_writer,
evidence,
))
} else {
Some(init_file_tracing(self.log, file_writer))
}
} else if self.run_evidence_log_handle.is_some() {
let limit = log_max_bytes().unwrap_or_else(|e| panic!("{e}"));
let evidence = self
.run_evidence_writer(limit)
.expect("run-evidence handle was present");
Some(init_stderr_tracing_with_evidence(
self.log, evidence, backend,
))
} else {
init_stderr_tracing(self.log, backend);
None
}
}
}
#[cfg(test)]
mod tests {
use std::io::Write;
use super::*;
fn log_options(path: PathBuf) -> GlobalOpts {
GlobalOpts {
log: None,
log_file: Some(path),
log_file_handle: None,
run_evidence_log_handle: None,
run_evidence_write_error: None,
backend: None,
}
}
#[test]
fn host_log_open_refuses_a_symlink_without_changing_its_target() {
let directory = tempfile::tempdir().unwrap();
let target = directory.path().join("target.log");
let link = directory.path().join("requested.log");
std::fs::write(&target, b"do not truncate").unwrap();
std::os::unix::fs::symlink(&target, &link).unwrap();
let mut options = log_options(link);
let error = options
.open_log_file()
.expect_err("--log-file must never follow a symlink");
assert!(error.to_string().contains("cannot open --log-file"));
assert_eq!(std::fs::read(target).unwrap(), b"do not truncate");
}
#[test]
fn host_log_open_creates_a_regular_file_and_keeps_the_opened_object() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("requested.log");
let opened_path = directory.path().join("opened.log");
let mut options = log_options(path.clone());
options.open_log_file().unwrap();
assert!(std::fs::metadata(&path).unwrap().is_file());
assert_eq!(std::fs::read(&path).unwrap(), b"");
let cloned_options = options.clone();
drop(options);
std::fs::rename(&path, &opened_path).unwrap();
std::fs::write(&path, b"replacement must not change").unwrap();
cloned_options
.write_controller_diagnostic(format_args!("controller context"))
.unwrap();
let mut held = cloned_options
.log_file_handle
.as_ref()
.unwrap()
.try_clone()
.unwrap();
drop(cloned_options);
held.write_all(b"written through the held descriptor")
.unwrap();
let written = String::from_utf8(std::fs::read(opened_path).unwrap()).unwrap();
let (timestamp, rest) = written.split_once(" DEBUG ").unwrap();
assert!(
regex::Regex::new(r"^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+Z$")
.unwrap()
.is_match(timestamp),
"{written:?}"
);
assert_eq!(
rest,
"hermit::controller: controller context\nwritten through the held descriptor"
);
assert_eq!(
std::fs::read(&path).unwrap(),
b"replacement must not change"
);
let mut read_only_options = log_options(path.clone());
read_only_options.log_file_handle = Some(Arc::new(File::open(&path).unwrap()));
let error = read_only_options
.write_controller_diagnostic(format_args!("must not disappear"))
.unwrap_err();
assert!(
error
.to_string()
.contains("cannot write to the host log file")
);
assert_eq!(std::fs::read(path).unwrap(), b"replacement must not change");
}
#[test]
fn host_log_open_truncates_an_existing_regular_file() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("existing.log");
std::fs::write(&path, b"old log contents that must be truncated").unwrap();
let mut options = log_options(path.clone());
options.open_log_file().unwrap();
assert_eq!(std::fs::read(&path).unwrap(), b"");
let mut held = options
.log_file_handle
.as_ref()
.unwrap()
.try_clone()
.unwrap();
held.write_all(b"new log").unwrap();
assert_eq!(std::fs::read(path).unwrap(), b"new log");
}
}