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::collections::BTreeMap;
use std::ffi::{OsStr, 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;
use shep_core::protocol::DogSource;
#[cfg(unix)]
use self::handover::{HandoverSeam, Rehydrated, 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};
use crate::sweep::LambSweep;
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<DogSpec>,
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,
options: BootOptions,
) -> Result<RunningDaemon, BootError> {
boot_with_sweep(runner, paths, options, None).await
}
pub(crate) async fn boot_with_sweep<R: ProcessRunner>(
runner: R,
paths: ShepPaths,
mut options: BootOptions,
sweep: Option<Arc<dyn LambSweep>>,
) -> 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);
#[cfg(unix)]
let (signals, connect_supervisor, connect_handover) =
install_signals(shutdown.clone(), paths.clone())?;
#[cfg(windows)]
let (signals, connect_supervisor) = install_signals(shutdown.clone(), 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 Rehydrated {
lock,
listener,
flock,
counters,
reloads,
listeners,
} = rehydrate(carried)?;
(lock, listener, Some((flock, counters, reloads, listeners)))
}
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)?;
let dog_defaults = shep_core::dog_defaults::read(&paths.dog_defaults).map_err(|source| {
BootError::DogDefaults {
path: paths.dog_defaults.clone(),
source,
}
})?;
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 mut extras = Extras::real(
ExtrasReports {
breaches: breach_tx,
liveness: live_tx,
},
max_cron_sleep(&options),
);
if let Some(sweep) = sweep {
extras.lamb_sweep = sweep;
}
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 dog_links = runner.dog_links();
#[cfg(unix)]
let dog_link_table = crate::server::DogLinks::default();
#[cfg(unix)]
let inherited_flock = inherited.is_some();
#[cfg(windows)]
let inherited_flock = false;
if options.restore && !inherited_flock {
crate::dogs::leave_held_names(
&mut options.dogs,
&mut options.known_dogs,
&crate::dogs::saved_sheep_names(&paths.snapshot),
);
}
let mut builder = SupervisorBuilder::new(runner, paths.clone(), events.clone())
.extras(extras)
.provider_secrets(Arc::clone(&provider_secrets))
.dog_defaults(dog_defaults)
.dog_binaries(adopted_dog_paths(&options.dogs));
let host_environment = options
.environment
.clone()
.unwrap_or_else(|| crate::supervisor::DEFAULT_ENVIRONMENT.to_string());
if let Some(environment) = options.environment.take() {
builder = builder.environment(environment);
}
#[cfg(unix)]
let mut carried_apps = Vec::new();
#[cfg(unix)]
let supervisor = match inherited {
Some((flock, counters, reloads, listeners)) => {
carried_apps.extend(apps_for_the_roll(&flock));
builder
.adopted_listeners(listeners)
.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(),
dog_links: dog_link_table.clone(),
}));
let registry = FlockRegistry::new();
#[cfg(unix)]
for app in &carried_apps {
registry.record_config(app);
}
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();
let dog_refusals = crate::dogs::DogRefusals::new();
let peer_contacts = crate::dogs::PeerContacts::new();
let ctx = RpcContext {
supervisor: supervisor.clone(),
events: events.clone(),
registry: registry.clone(),
snapshot_path: paths.snapshot.clone(),
dogs_config: paths.dogs_config.clone(),
known_dogs: known_dog_grants(&options),
dog_names: dog_names.clone(),
boot_first_dogs: options.boot_first_dogs.clone(),
paths: paths.clone(),
daemon_version: env!("CARGO_PKG_VERSION").to_string(),
dog_refusals: dog_refusals.clone(),
peer_contacts: peer_contacts.clone(),
pid,
shutdown: shutdown.clone(),
stats,
host: crate::host::HostState::real(),
provider_secrets,
host_environment: host_environment.clone(),
pid_signals: Arc::new(crate::rpc::OsPidSignals),
};
if let Some(links) = dog_links {
tokio::spawn(crate::server::serve_dog_links(
links,
ctx.clone(),
#[cfg(unix)]
dog_link_table,
shutdown.subscribe(),
));
}
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,
options.notify_socket.as_deref(),
)
.await?;
crate::boot_order::extend_start_deadline(
options.notify_socket.as_deref(),
crate::boot_order::STAGE_SLACK,
);
}
crate::dogs::register_dogs_at_rest(&options.known_dogs, &options.dogs, &paths, &supervisor)
.await;
crate::dogs::spawn_enabled_dogs(&rest, &paths, &supervisor, &events).await;
let silent_dog_watch = crate::dogs::spawn_silent_dog_watch(
supervisor.clone(),
dog_refusals.clone(),
peer_contacts.clone(),
events.clone(),
);
drop(crate::secrets_watch::spawn_secrets_watch(
crate::secrets_watch::Watcher::new(
paths.secrets.clone(),
paths.dogs_config.clone(),
host_environment.clone(),
),
events.clone(),
shutdown.subscribe(),
));
let writer = spawn_snapshot_writer(
paths.snapshot.clone(),
supervisor.clone(),
registry.clone(),
events.subscribe(),
);
#[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 known_dog_grants(options: &BootOptions) -> crate::rpc::KnownDogs {
crate::rpc::KnownDogs::with_grants(
options
.known_dogs
.iter()
.chain(&options.dogs)
.map(|spec| (spec.name.clone(), spec.source.grants().cloned())),
)
}
fn adopted_dog_paths(dogs: &[DogSpec]) -> BTreeMap<String, String> {
dogs.iter()
.filter_map(|dog| match &dog.source {
DogSource::Adopted { path, .. } => Some((dog.name.clone(), path.clone())),
_ => None,
})
.collect()
}
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],
notify_socket: Option<&OsStr>,
) -> Result<(), BootError> {
snapshot::muster(
&paths.snapshot,
registry,
supervisor,
events,
dogs,
boot_first_dogs,
notify_socket,
)
.await?;
Ok(())
}
#[cfg(all(test, unix))]
pub(crate) async fn boot_with_idle_sweep<R: ProcessRunner>(
runner: R,
paths: ShepPaths,
options: BootOptions,
) -> Result<RunningDaemon, BootError> {
boot_with_sweep(runner, paths, options, Some(crate::fake::idle_sweep())).await
}
#[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(""),
)
}