mod error;
#[cfg(unix)]
mod handover;
mod layout;
mod pidfile;
mod running;
mod signals;
mod socket;
#[cfg(all(test, unix))]
mod tests;
pub use self::error::BootError;
pub use self::layout::DIR_MODE;
pub(crate) use self::layout::init_dirs;
pub use self::pidfile::{Shepherd, daemon_liveness, pidfile};
pub use self::running::RunningDaemon;
pub use self::socket::READY_FD_ENV;
use core::time::Duration;
use std::ffi::OsString;
#[cfg(all(test, windows))]
use std::path::Path;
use std::path::PathBuf;
use std::sync::Arc;
use tokio::sync::{mpsc, watch};
use shep_core::paths::ShepPaths;
#[cfg(unix)]
use self::handover::{HandoverSeam, apps_for_the_roll, rehydrate, successor_handover};
use self::pidfile::PidfileLock;
use self::signals::install_signals;
use self::socket::{DaemonReady, bind_socket, socket_path, write_ready};
use crate::bus::{Bus, new_bus};
use crate::cron::DEFAULT_MAX_CRON_SLEEP;
use crate::dogs::{DogSpec, spawn_dog_watch};
use crate::extras::{Extras, ExtrasReports, spawn_extras_reporter};
use crate::rpc::RpcContext;
use crate::runner::ProcessRunner;
use crate::snapshot::{self, FlockRegistry, spawn_snapshot_writer};
use crate::supervisor::{SupervisorBuilder, SupervisorHandle};
const EXTRAS_REPORT_CAPACITY: usize = 64;
#[derive(Debug, Default)]
pub struct BootOptions {
pub socket: Option<PathBuf>,
pub ready_fd: Option<std::fs::File>,
pub restore: bool,
pub max_cron_sleep: Option<Duration>,
pub notify_socket: Option<OsString>,
pub dogs: Vec<DogSpec>,
pub known_dogs: Vec<String>,
pub boot_first_dogs: Vec<String>,
pub delete_flock_on_shutdown: bool,
pub handover: bool,
pub environment: Option<String>,
}
pub async fn boot<R: ProcessRunner>(
runner: R,
paths: ShepPaths,
mut options: BootOptions,
) -> Result<RunningDaemon, BootError> {
#[cfg(unix)]
crate::handover::record_launch_path();
let delete_flock_on_shutdown = options.delete_flock_on_shutdown;
let (shutdown, shutdown_rx) = watch::channel(false);
let shutdown = Arc::new(shutdown);
#[cfg(unix)]
let (signals, connect_supervisor, connect_handover) =
install_signals(Arc::clone(&shutdown), paths.clone())?;
#[cfg(windows)]
let (signals, connect_supervisor) = install_signals(Arc::clone(&shutdown), paths.clone())?;
init_dirs(&paths)?;
let socket = socket_path(&paths, options.socket.as_deref());
#[cfg(unix)]
let (mut pidfile_lock, listener, inherited) = match successor_handover() {
Some(carried) => {
let (lock, listener, flock) = rehydrate(carried, &paths)?;
(lock, listener, Some(flock))
}
None => (
PidfileLock::acquire(&paths)?,
bind_socket(&paths, &socket)?,
None,
),
};
#[cfg(windows)]
let (mut pidfile_lock, listener) =
(PidfileLock::acquire(&paths)?, bind_socket(&paths, &socket)?);
let pid = std::process::id();
pidfile_lock.record(&paths, pid)?;
if let Some(pipe) = options.ready_fd.take() {
let ready = DaemonReady {
pid,
version: env!("CARGO_PKG_VERSION").to_string(),
};
write_ready(pipe, &ready)?;
}
let events = new_bus();
let dog_watch = spawn_dog_watch(events.subscribe(), events.clone(), paths.barks.clone());
let (breach_tx, breach_rx) = mpsc::channel(EXTRAS_REPORT_CAPACITY);
let (live_tx, live_rx) = mpsc::channel(EXTRAS_REPORT_CAPACITY);
let extras = Extras::real(
ExtrasReports {
breaches: breach_tx,
liveness: live_tx,
},
max_cron_sleep(&options),
);
let stats = Arc::clone(&extras.stats);
let provider_secrets = Arc::new(crate::secrets::ProviderSecrets::load(&paths.secrets_cache));
tracing::debug!(
pushed = ?provider_secrets.pushed(),
"provider namespaces restored from the secrets cache"
);
let mut builder = SupervisorBuilder::new(runner, paths.clone(), events.clone())
.extras(extras)
.provider_secrets(Arc::clone(&provider_secrets));
if let Some(environment) = options.environment.take() {
builder = builder.environment(environment);
}
#[cfg(unix)]
let mut carried_apps = Vec::new();
#[cfg(unix)]
let inherited_flock = inherited.is_some();
#[cfg(unix)]
let supervisor = match inherited {
Some((flock, counters, reloads)) => {
carried_apps.extend(apps_for_the_roll(&flock));
builder
.spawn_adopted(flock, counters, reloads)
.map_err(|source| BootError::Adopt(Box::new(source)))?
}
None => builder.spawn(),
};
#[cfg(windows)]
let supervisor = builder.spawn();
spawn_extras_reporter(breach_rx, live_rx, supervisor.clone());
let _ = connect_supervisor.send(supervisor.clone());
#[cfg(unix)]
let _ = connect_handover.send(options.handover.then(|| HandoverSeam {
supervisor: supervisor.clone(),
fds: crate::handover::DaemonFds {
listener: listener.as_raw_fd(),
pidfile: pidfile_lock.as_raw_fd(),
},
paths: paths.clone(),
}));
let registry = FlockRegistry::new();
#[cfg(unix)]
for app in &carried_apps {
registry.record_config(app);
}
#[cfg(windows)]
let inherited_flock = false;
let (first, rest): (Vec<DogSpec>, Vec<DogSpec>) = options
.dogs
.iter()
.cloned()
.partition(|spec| options.boot_first_dogs.contains(&spec.name));
let dog_names: Vec<String> = options.dogs.iter().map(|dog| dog.name.clone()).collect();
crate::dogs::spawn_enabled_dogs(&first, &paths, &supervisor, &events).await;
if options.restore && !inherited_flock {
restore_flock(
&paths,
®istry,
&supervisor,
&events,
&dog_names,
&options.boot_first_dogs,
)
.await?;
}
crate::dogs::spawn_enabled_dogs(&rest, &paths, &supervisor, &events).await;
let dog_refusals = crate::dogs::DogRefusals::new();
let peer_contacts = crate::dogs::PeerContacts::new();
let silent_dog_watch = crate::dogs::spawn_silent_dog_watch(
supervisor.clone(),
dog_refusals.clone(),
peer_contacts.clone(),
events.clone(),
);
let writer = spawn_snapshot_writer(
paths.snapshot.clone(),
supervisor.clone(),
registry.clone(),
events.subscribe(),
);
let ctx = RpcContext {
supervisor,
events,
registry,
snapshot_path: paths.snapshot.clone(),
dogs_config: paths.dogs_config.clone(),
known_dogs: crate::rpc::KnownDogs::new(options.known_dogs.iter().cloned().collect()),
dog_names,
boot_first_dogs: options.boot_first_dogs.clone(),
paths: paths.clone(),
daemon_version: env!("CARGO_PKG_VERSION").to_string(),
dog_refusals,
peer_contacts,
pid,
shutdown,
stats,
host: crate::host::HostState::real(),
provider_secrets,
};
#[cfg(unix)]
if let Some(target) = options.notify_socket.as_deref()
&& let Err(err) = crate::notify::notify(target)
{
tracing::warn!(
%err,
"readiness could not be reported to $NOTIFY_SOCKET; the flock is up regardless"
);
}
Ok(RunningDaemon {
ctx,
listener,
writer,
dog_watch,
silent_dog_watch,
paths,
socket,
shutdown_rx,
signals,
pidfile_lock,
delete_flock_on_shutdown,
})
}
fn max_cron_sleep(options: &BootOptions) -> Duration {
options.max_cron_sleep.unwrap_or(DEFAULT_MAX_CRON_SLEEP)
}
async fn restore_flock(
paths: &ShepPaths,
registry: &FlockRegistry,
supervisor: &SupervisorHandle,
events: &Bus,
dogs: &[String],
boot_first_dogs: &[String],
) -> Result<(), BootError> {
snapshot::muster(
&paths.snapshot,
registry,
supervisor,
events,
dogs,
boot_first_dogs,
)
.await?;
Ok(())
}
#[cfg(all(test, unix))]
static SIGNAL_TEST_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
#[cfg(all(test, windows))]
fn paths_in(dir: &Path) -> ShepPaths {
ShepPaths::resolve(
&|key| (key == "SHEP_HOME").then(|| dir.to_string_lossy().into_owned()),
Path::new(""),
)
}