mod pins;
mod state;
mod store;
mod verify;
use std::collections::{BTreeMap, BTreeSet, HashMap};
use std::future::Future;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime};
use bollard::models::{Mount, MountType};
use futures_util::StreamExt;
use tokio::sync::watch;
use tracing::{info, warn};
use self::pins::{MAX_DEPTH, Pin};
use self::state::{Refresher, Wanted};
use self::store::{Action, ArchiveStore, Key, Staged};
use crate::api;
use crate::config::Config;
use crate::github::{self, Error};
use crate::sync::lock;
pub const MOUNT: &str = "/opt/runnerd/actions";
pub const LABEL: &str = "runnerd.action-archives";
pub const ENV: &str = "ACTIONS_RUNNER_ACTION_ARCHIVE_CACHE";
const REFRESH: Duration = Duration::from_secs(600);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Limits {
pub(crate) archive: u64,
pub(crate) bytes: u64,
pub(crate) requests: u32,
pub(crate) store: u64,
}
const LIMITS: Limits = Limits {
archive: 256 << 20,
bytes: 2 << 30,
requests: 1000,
store: 8 << 30,
};
const RESERVE: u64 = 1000;
const DOWNLOADS: usize = 3;
const ATTEMPTS: [Duration; 3] = [
Duration::ZERO,
Duration::from_secs(5),
Duration::from_secs(20),
];
const PIN_FILES: usize = 300;
const PIN_FILE_BYTES: u64 = 1 << 20;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ActionRepository {
pub full_name: String,
pub public: bool,
pub default_branch: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Tree {
pub truncated: bool,
pub files: Vec<TreeFile>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TreeFile {
pub path: String,
pub blob: String,
pub size: u64,
}
pub trait Source: Send + Sync {
fn action_repository(
&self,
repository: &str,
) -> impl Future<Output = Result<ActionRepository, Error>> + Send;
fn branch_head(
&self,
repository: &str,
branch: &str,
) -> impl Future<Output = Result<String, Error>> + Send;
fn tree(
&self,
repository: &str,
commit: &str,
) -> impl Future<Output = Result<Tree, Error>> + Send;
fn blob(
&self,
repository: &str,
blob: &str,
limit: u64,
) -> impl Future<Output = Result<Vec<u8>, Error>> + Send;
fn tarball(
&self,
repository: &str,
commit: &str,
to: &Path,
limit: u64,
received: &AtomicU64,
) -> impl Future<Output = Result<u64, Error>> + Send;
fn spare_requests(&self) -> Option<u64>;
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Settings {
pub enabled: bool,
pub keep: Duration,
pub repositories: Vec<String>,
}
impl Settings {
pub fn of(config: &Config) -> Settings {
Settings {
enabled: config.caches.actions.enabled,
keep: config.caches.actions.keep,
repositories: config.repository_names(),
}
}
}
#[derive(Debug)]
pub struct Link {
directory: Option<PathBuf>,
settings: watch::Sender<Settings>,
status: watch::Sender<Option<api::ActionArchives>>,
ready: watch::Sender<Option<RunnerArchives>>,
readers: watch::Sender<Option<BTreeSet<String>>>,
packages: Packages,
}
#[derive(Debug, Clone)]
pub struct Packages(watch::Sender<BTreeSet<String>>);
impl Packages {
pub fn read(&self, lines: &[String]) {
let found = crate::record::immutable_packages(lines);
if found.is_empty() {
return;
}
self.0.send_if_modified(|known| {
let before = known.len();
known.extend(found.iter().map(|name| name.to_ascii_lowercase()));
known.len() != before
});
}
}
impl Link {
pub fn new(directory: Option<PathBuf>, config: &Config) -> Link {
Link {
directory,
settings: watch::Sender::new(Settings::of(config)),
status: watch::Sender::new(None),
ready: watch::Sender::new(None),
readers: watch::Sender::new(None),
packages: Packages(watch::Sender::new(BTreeSet::new())),
}
}
pub fn start<S: Source + 'static>(&self, source: Arc<S>) -> Option<Running> {
let directory = self.directory.clone()?;
let task = tokio::spawn(run(
source,
directory,
self.settings.subscribe(),
Published {
status: self.status.clone(),
ready: self.ready.clone(),
readers: self.readers.subscribe(),
packages: self.packages.0.subscribe(),
},
));
Some(Running(Some(task)))
}
pub fn reload(&self, config: &Config) {
if !config.caches.actions.enabled {
self.ready.send_replace(None);
}
self.settings.send_if_modified(|settings| {
let new = Settings::of(config);
let changed = *settings != new;
*settings = new;
changed
});
}
pub fn adopted<S: std::hash::BuildHasher>(
&self,
runner: &str,
labels: &HashMap<String, String, S>,
) {
if !labels.contains_key(LABEL) {
return;
}
self.readers.send_if_modified(|readers| {
readers
.get_or_insert_with(BTreeSet::new)
.insert(runner.to_owned())
});
}
pub fn recovered(&self) {
self.readers.send_if_modified(|readers| {
let first = readers.is_none();
readers.get_or_insert_with(BTreeSet::new);
first
});
}
pub fn released(&self, runner: &str) {
self.readers.send_if_modified(|readers| {
readers
.as_mut()
.is_some_and(|readers| readers.remove(runner))
});
}
pub fn packages(&self) -> Packages {
self.packages.clone()
}
pub fn status(&self) -> Option<api::ActionArchives> {
if !self.settings.borrow().enabled {
return None;
}
let readers = self.readers.borrow().clone().unwrap_or_default();
match self.status.borrow().clone() {
Some(mut status) => {
status.failures.retain(|failure| {
failure.kind != api::ArchiveFailureKind::Exposed
|| readers.contains(&failure.subject)
});
Some(status)
}
None if !readers.is_empty() => Some(api::ActionArchives {
unchecked: readers.len() as u64,
..api::ActionArchives::default()
}),
None => None,
}
}
#[cfg(test)]
pub(crate) fn ready_changes(&self) -> watch::Receiver<Option<RunnerArchives>> {
self.ready.subscribe()
}
pub fn runner(&self) -> Option<RunnerArchives> {
if !self.settings.borrow().enabled {
return None;
}
self.ready.borrow().clone()
}
}
impl RunnerArchives {
fn of(archives: &Path) -> RunnerArchives {
RunnerArchives {
mount: Mount {
target: Some(MOUNT.to_owned()),
source: Some(archives.to_string_lossy().into_owned()),
typ: Some(MountType::BIND),
read_only: Some(true),
..Default::default()
},
env: format!("{ENV}={MOUNT}"),
}
}
}
struct Published {
status: watch::Sender<Option<api::ActionArchives>>,
ready: watch::Sender<Option<RunnerArchives>>,
readers: watch::Receiver<Option<BTreeSet<String>>>,
packages: watch::Receiver<BTreeSet<String>>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct RunnerArchives {
pub mount: Mount,
pub env: String,
}
#[derive(Debug)]
pub struct Running(Option<tokio::task::JoinHandle<()>>);
impl Running {
pub async fn stop(mut self) {
if let Some(task) = self.0.take() {
task.abort();
let _ = task.await;
}
}
}
impl Drop for Running {
fn drop(&mut self) {
if let Some(task) = &self.0 {
task.abort();
}
}
}
#[cfg(test)]
pub(crate) fn keep(
directory: &Path,
repository: &str,
sha: &str,
bytes: &[u8],
) -> std::io::Result<()> {
let mut store = ArchiveStore::open(directory)?;
let file = store.staging_file()?;
std::fs::write(&file, bytes)?;
let (sha256, size) = verify::hash_file(&file)?;
let key = Key {
repository: repository.to_owned(),
sha: sha.to_owned(),
};
let staged = Staged {
file,
sha256,
size,
uses: BTreeMap::new(),
unread: BTreeSet::new(),
actions: BTreeSet::new(),
};
store.publish(key, staged, unix_now())
}
fn unix_now() -> u64 {
SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap_or_default()
.as_secs()
}
async fn run<S: Source + 'static>(
source: Arc<S>,
directory: PathBuf,
mut settings: watch::Receiver<Settings>,
mut published: Published,
) {
let mut archives = Archives::new(directory.clone());
let view = RunnerArchives::of(&directory.join(store::ARCHIVES));
if published.readers.wait_for(Option::is_some).await.is_err() {
return;
}
let mut first = true;
loop {
let now = settings.borrow_and_update().clone();
if now.enabled {
published.ready.send_replace(None);
let packages = published.packages.borrow_and_update().clone();
github::REQUESTS
.scope(std::cell::Cell::new(0), async {
let mut round = archives.round();
let checked = archives.check(unix_now()).await;
if first {
let readers = published.readers.borrow().clone().unwrap_or_default();
archives.exposed(&readers, checked, unix_now());
first = false;
}
archives.packages(&packages, unix_now()).await;
archives.vet(&*source, &mut round, unix_now()).await;
published
.ready
.send_replace(checked.good().then(|| view.clone()));
published.status.send_replace(Some(archives.status()));
archives
.update(&*source, &mut round, &now, unix_now())
.await;
})
.await;
published.status.send_replace(Some(archives.status()));
} else {
published.ready.send_replace(None);
}
loop {
tokio::select! {
() = tokio::time::sleep(REFRESH) => break,
changed = settings.changed() => if changed.is_err() { return } else { break },
changed = published.packages.changed() => {
if changed.is_err() {
return;
}
let packages = published.packages.borrow_and_update().clone();
if settings.borrow().enabled {
archives.packages(&packages, unix_now()).await;
published.status.send_replace(Some(archives.status()));
}
}
}
}
}
}
#[derive(Debug)]
pub(crate) struct Archives {
directory: PathBuf,
store: Option<Arc<Mutex<ArchiveStore>>>,
refresher: Refresher,
limits: Limits,
}
#[derive(Debug)]
pub(crate) struct Round {
meter: Meter,
names: Names,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Checked {
Good,
Moved,
Bad,
}
impl Checked {
pub(crate) fn good(self) -> bool {
self != Checked::Bad
}
}
impl Archives {
pub(crate) fn new(directory: PathBuf) -> Archives {
Archives {
directory,
store: None,
refresher: Refresher::default(),
limits: LIMITS,
}
}
#[cfg(test)]
pub(crate) fn with_limits(mut self, limits: Limits) -> Archives {
self.limits = limits;
self
}
pub(crate) fn round(&self) -> Round {
Round {
meter: Meter::new(self.limits),
names: Names::default(),
}
}
pub(crate) fn status(&self) -> api::ActionArchives {
let (entries, bytes) = self
.store
.as_ref()
.map_or((0, 0), |store| lock(store).size());
self.refresher.status(entries, bytes)
}
#[cfg(test)]
pub(crate) async fn refresh<S: Source>(&mut self, source: &S, settings: &Settings, now: u64) {
github::REQUESTS
.scope(std::cell::Cell::new(0), async {
let mut round = self.round();
self.check(now).await;
self.vet(source, &mut round, now).await;
self.update(source, &mut round, settings, now).await;
})
.await;
}
#[cfg(test)]
pub(crate) async fn refill<S: Source>(&mut self, source: &S, settings: &Settings, now: u64) {
github::REQUESTS
.scope(std::cell::Cell::new(0), async {
let mut round = self.round();
self.update(source, &mut round, settings, now).await;
})
.await;
}
fn subject(&self) -> String {
self.directory.display().to_string()
}
pub(crate) fn exposed(&mut self, readers: &BTreeSet<String>, checked: Checked, now: u64) {
if readers.is_empty() {
return;
}
if checked == Checked::Good {
info!(
"{} runners a restart adopted read the action archives; the first check found every one good",
readers.len()
);
return;
}
for reader in readers {
warn!(
"{reader} kept running across the restart with the action archives mounted, and the first check found \
one changed or could not read one: its job may have read it"
);
self.refresher
.fail(reader, api::ArchiveFailureKind::Exposed, now);
}
}
pub(crate) async fn packages(&mut self, packages: &BTreeSet<String>, now: u64) {
let Some(store) = self.store.clone() else {
return;
};
for package in packages {
let noted = {
let store = store.clone();
let package = package.clone();
tokio::task::spawn_blocking(move || lock(&store).packaged(&package)).await
};
match noted {
Ok(Ok(withdrawn)) => {
for key in &withdrawn.removed {
info!(
"action archive {} removed: a job resolved its repository as an immutable package",
key.label()
);
}
if withdrawn.new {
self.refresher
.fail(package, api::ArchiveFailureKind::Package, now);
}
}
Ok(Err(error)) => {
warn!("cannot remove the action archives of the package {package}: {error}");
self.refresher
.fail(&self.subject(), api::ArchiveFailureKind::Store, now);
}
Err(_) => {}
}
}
}
pub(crate) async fn update<S: Source>(
&mut self,
source: &S,
round: &mut Round,
settings: &Settings,
now: u64,
) {
let Some(store) = self.store.clone() else {
return;
};
let mut directs: BTreeMap<String, Option<Direct>> = BTreeMap::new();
for repository in &settings.repositories {
let direct = self.read_pins(source, round, &store, repository, now).await;
directs.insert(repository.clone(), direct);
}
let mut tried: BTreeSet<Key> = BTreeSet::new();
let mut deferred: BTreeSet<Key> = BTreeSet::new();
for _ in 0..=MAX_DEPTH {
let mut wanted = BTreeSet::new();
for direct in directs.values().flatten() {
let reach = closure(source, round, &store, &direct.wanted).await;
wanted.extend(reach.missing);
}
let missing: Vec<Key> = wanted.difference(&tried).cloned().collect();
if missing.is_empty() {
break;
}
tried.extend(missing.iter().cloned());
deferred.extend(self.fetch_all(source, round, &store, missing, now).await);
}
let mut whole = BTreeMap::new();
let mut pinned = BTreeSet::new();
let mut unsupported = BTreeMap::new();
let mut refused = BTreeSet::new();
for (repository, direct) in &directs {
let (complete, waiting) = match direct {
Some(direct) => {
let reach = closure(source, round, &store, &direct.wanted).await;
unsupported.extend(reach.unsupported);
refused.extend(reach.refused);
pinned.extend(reach.keys.iter().cloned());
let read = direct.known && reach.answered;
let complete = read && reach.missing.is_empty();
let waiting = read && reach.missing.is_subset(&deferred);
if complete {
whole.insert(repository.clone(), reach.keys);
}
(complete, waiting)
}
None => (false, false),
};
if complete || waiting {
self.refresher
.succeed_kind(repository, api::ArchiveFailureKind::Held);
}
if !complete {
pinned.extend(lock(&store).reached(repository));
if !waiting {
info!(
"{repository}: not all its pins are known; the archives it last reached are kept"
);
self.refresher
.fail(repository, api::ArchiveFailureKind::Held, now);
}
}
}
for (subject, kind) in &unsupported {
self.refresher.fail(subject, *kind, now);
}
let retained = {
let store = store.clone();
let keep = settings.keep;
let served = settings.repositories.clone();
let pinned = pinned.clone();
tokio::task::spawn_blocking(move || {
let mut store = lock(&store);
store.record(whole, &served)?;
store.retain(&pinned, keep, now)
})
.await
};
match retained {
Ok(Ok(removed)) => {
for key in removed {
info!(
"action archive {} removed: no repository pinned it for {}",
key.label(),
api::duration(settings.keep.as_secs())
);
}
}
Ok(Err(error)) => {
warn!("cannot remove action archives no longer pinned: {error}");
self.refresher
.fail(&self.subject(), api::ArchiveFailureKind::Store, now);
}
Err(_) => {}
}
let mut subjects: BTreeSet<String> = pinned.iter().map(Key::label).collect();
subjects.extend(unsupported.into_keys());
subjects.extend(refused);
self.refresher
.finish(&settings.repositories, &subjects, &self.subject(), now);
}
pub(crate) async fn check(&mut self, now: u64) -> Checked {
let subject = self.subject();
let store = match self.open().await {
Ok(store) => store,
Err(error) => {
warn!("no action archives: cannot open {subject}: {error}");
self.refresher
.fail(&subject, api::ArchiveFailureKind::Store, now);
return Checked::Bad;
}
};
for package in lock(&store).packages() {
self.refresher
.fail(&package, api::ArchiveFailureKind::Package, now);
}
let checked = match tokio::task::spawn_blocking(move || lock(&store).check(now)).await {
Ok(Ok(checked)) => checked,
Ok(Err(error)) => {
warn!("cannot check the action archives: {error}");
self.refresher
.fail(&subject, api::ArchiveFailureKind::Store, now);
return Checked::Bad;
}
Err(_) => return Checked::Bad,
};
for key in &checked.changed {
self.refresher
.fail(&key.label(), api::ArchiveFailureKind::Quarantined, now);
}
for stranger in &checked.strangers {
warn!("action archive {stranger} is not in the index; moved to quarantine");
}
for error in &checked.errors {
warn!("cannot check the action archive {error}; runners get no archives until it is");
}
if !checked.clean() {
self.refresher
.fail(&subject, api::ArchiveFailureKind::Store, now);
return Checked::Bad;
}
self.refresher.succeed(&subject);
if checked.changed.is_empty() && checked.strangers.is_empty() {
Checked::Good
} else {
Checked::Moved
}
}
pub(crate) async fn vet<S: Source>(&mut self, source: &S, round: &mut Round, now: u64) {
let Some(store) = self.store.clone() else {
return;
};
let repositories = lock(&store).repositories();
let mut hidden = Vec::new();
for repository in repositories {
if let Ok(None) = round
.names
.public(source, &round.meter, &store, &repository)
.await
{
hidden.push(repository);
}
}
if hidden.is_empty() {
return;
}
let withdrawn = {
let store = store.clone();
tokio::task::spawn_blocking(move || lock(&store).withdraw(&hidden)).await
};
match withdrawn {
Ok(Ok(keys)) => {
for key in keys {
info!(
"action archive {} removed: its repository is not public",
key.label()
);
}
}
Ok(Err(error)) => {
warn!("cannot remove action archives no longer public: {error}");
self.refresher
.fail(&self.subject(), api::ArchiveFailureKind::Store, now);
}
Err(_) => {}
}
}
async fn open(&mut self) -> std::io::Result<Arc<Mutex<ArchiveStore>>> {
if let Some(store) = &self.store {
return Ok(store.clone());
}
let directory = self.directory.clone();
let store = tokio::task::spawn_blocking(move || ArchiveStore::open(&directory))
.await
.map_err(std::io::Error::other)??;
let store = Arc::new(Mutex::new(store));
self.store = Some(store.clone());
Ok(store)
}
async fn read_pins<S: Source>(
&mut self,
source: &S,
round: &mut Round,
store: &Arc<Mutex<ArchiveStore>>,
repository: &str,
now: u64,
) -> Option<Direct> {
let last = lock(store).scan(repository).cloned();
let (scan, known) = match scan_of(source, &round.meter, repository, last.as_ref()).await {
Ok(scan) => {
self.refresher.succeed(repository);
if last.as_ref() != Some(&scan) {
let saved = {
let store = store.clone();
let repository = repository.to_owned();
let scan = scan.clone();
tokio::task::spawn_blocking(move || lock(&store).scanned(&repository, scan))
.await
};
if let Ok(Err(error)) = saved {
warn!("cannot keep {repository}'s pins: {error}");
self.refresher
.fail(&self.subject(), api::ArchiveFailureKind::Store, now);
}
}
(scan, true)
}
Err(error) => {
warn!(
"{repository}: cannot read the actions it pins; keeping the last read and every archive they \
reached: {}",
error.brief()
);
self.refresher
.fail(repository, api::ArchiveFailureKind::Pins, now);
(last?, false)
}
};
let mut direct = Direct {
wanted: BTreeSet::new(),
known,
};
for pin in scan.pins {
match round
.names
.public(source, &round.meter, store, &pin.repository)
.await
{
Ok(Some(name)) => {
direct.wanted.insert(Wanted {
key: Key {
repository: name,
sha: pin.sha,
},
path: pin.path,
});
}
Ok(None) => {}
Err(error) => {
warn!(
"cannot read {}, which {repository} pins: {}",
pin.repository,
error.brief()
);
direct.known = false;
}
}
}
Some(direct)
}
async fn fetch_all<S: Source>(
&mut self,
source: &S,
round: &Round,
store: &Arc<Mutex<ArchiveStore>>,
missing: Vec<Key>,
now: u64,
) -> BTreeSet<Key> {
let mut deferred = BTreeSet::new();
let meter = &round.meter;
let results: Vec<(Key, Result<u64, Fetch>)> = futures_util::stream::iter(missing)
.map(|key| async move {
let result = fetch(source, meter, store, &key, now).await;
(key, result)
})
.buffer_unordered(DOWNLOADS)
.collect()
.await;
for (key, result) in results {
let label = key.label();
match result {
Ok(_) => self.refresher.succeed(&label),
Err(Fetch::Deferred) => {
deferred.insert(key);
}
Err(Fetch::Full) => {
deferred.insert(key);
warn!(
"the action archives are at their size cap; {label} waits for room, and jobs download it \
themselves"
);
self.refresher
.fail(&self.subject(), api::ArchiveFailureKind::Full, now);
}
Err(Fetch::Download(error)) => {
warn!(
"cannot download the action archive {label}; jobs download it themselves: {}",
error.brief()
);
self.refresher
.fail(&label, api::ArchiveFailureKind::Download, now);
}
Err(Fetch::Gone) => {
warn!(
"the action archive {label} is not there to anyone; it is not asked for again while pinned"
);
self.refusal(store, key, now).await;
self.refresher
.fail(&label, api::ArchiveFailureKind::Download, now);
}
Err(Fetch::Rejected(why)) => {
warn!(
"the action archive {label} {why}; not kept, jobs download it themselves"
);
self.refusal(store, key, now).await;
self.refresher
.fail(&label, api::ArchiveFailureKind::Rejected, now);
}
Err(Fetch::Store(error)) => {
warn!("cannot keep the action archive {label}: {error}");
self.refresher
.fail(&self.subject(), api::ArchiveFailureKind::Store, now);
}
}
}
deferred
}
async fn refusal(&mut self, store: &Arc<Mutex<ArchiveStore>>, key: Key, now: u64) {
let store = store.clone();
if let Ok(Err(error)) = tokio::task::spawn_blocking(move || lock(&store).refuse(key)).await
{
warn!("cannot keep a refused action archive's note: {error}");
self.refresher
.fail(&self.subject(), api::ArchiveFailureKind::Store, now);
}
}
}
#[derive(Debug)]
struct Direct {
wanted: BTreeSet<Wanted>,
known: bool,
}
async fn scan_of<S: Source>(
source: &S,
meter: &Meter,
repository: &str,
last: Option<&store::Scan>,
) -> Result<store::Scan, PinsError> {
meter.ask(source)?;
let details = source.action_repository(repository).await?;
meter.ask(source)?;
let head = source
.branch_head(repository, &details.default_branch)
.await?;
if let Some(last) = last.filter(|last| last.head == head) {
return Ok(last.clone());
}
meter.ask(source)?;
let tree = source.tree(repository, &head).await?;
if tree.truncated {
return Err(PinsError::Truncated);
}
let files: Vec<&TreeFile> = tree
.files
.iter()
.filter(|file| pins::read_for_pins(&file.path))
.collect();
if files.len() > PIN_FILES {
return Err(PinsError::Files(files.len()));
}
let mut pins: BTreeSet<Pin> = BTreeSet::new();
for file in files {
if file.size > PIN_FILE_BYTES {
return Err(PinsError::Large(file.path.clone()));
}
meter.ask(source)?;
let bytes = source.blob(repository, &file.blob, PIN_FILE_BYTES).await?;
let found = pins::file_pins(&file.path, &bytes).map_err(|why| PinsError::Unreadable {
path: file.path.clone(),
why,
})?;
pins.extend(found);
}
Ok(store::Scan { head, pins })
}
#[derive(Debug, Default)]
struct Reach {
keys: BTreeSet<Key>,
missing: BTreeSet<Key>,
unsupported: BTreeMap<String, api::ArchiveFailureKind>,
refused: BTreeSet<String>,
answered: bool,
}
async fn closure<S: Source>(
source: &S,
round: &mut Round,
store: &Arc<Mutex<ArchiveStore>>,
direct: &BTreeSet<Wanted>,
) -> Reach {
let mut reach = Reach {
answered: true,
..Reach::default()
};
let mut seen: BTreeSet<Wanted> = BTreeSet::new();
let mut level: BTreeSet<Wanted> = direct.clone();
for depth in 0..=MAX_DEPTH {
let mut next = BTreeSet::new();
for wanted in &level {
if !seen.insert(wanted.clone()) {
continue;
}
let (refused, action) = {
let store = lock(store);
(
store.refused(&wanted.key),
store.action(&wanted.key, &wanted.path),
)
};
let subject = wanted.subject();
let nested = match action {
Action::Missing if refused => {
reach.keys.insert(wanted.key.clone());
reach.refused.insert(wanted.key.label());
continue;
}
Action::Missing => {
reach.keys.insert(wanted.key.clone());
reach.missing.insert(wanted.key.clone());
continue;
}
Action::NoFile => {
reach.keys.insert(wanted.key.clone());
reach
.unsupported
.insert(subject, api::ArchiveFailureKind::NotAction);
continue;
}
Action::Unread => {
reach.keys.insert(wanted.key.clone());
reach
.unsupported
.insert(subject, api::ArchiveFailureKind::Unreadable);
continue;
}
Action::Pins(nested) => {
reach.keys.insert(wanted.key.clone());
nested
}
};
if depth == MAX_DEPTH {
continue;
}
for pin in nested {
match round
.names
.public(source, &round.meter, store, &pin.repository)
.await
{
Ok(Some(name)) => {
next.insert(Wanted {
key: Key {
repository: name,
sha: pin.sha,
},
path: pin.path,
});
}
Ok(None) => {}
Err(error) => {
reach.answered = false;
warn!(
"cannot read {}, which {} pins: {}",
pin.repository,
wanted.key.label(),
error.brief()
);
}
}
}
}
if next.is_empty() {
break;
}
level = next;
}
reach
}
#[derive(Debug)]
enum Fetch {
Download(Error),
Gone,
Rejected(String),
Store(std::io::Error),
Deferred,
Full,
}
#[derive(Debug)]
struct Meter {
limits: Limits,
bytes: Arc<Mutex<Bytes>>,
}
#[derive(Debug)]
struct Bytes {
left: u64,
in_flight: u64,
}
enum Refused {
Spent,
Full,
}
struct InFlight {
bytes: Arc<Mutex<Bytes>>,
archive: u64,
}
impl Drop for InFlight {
fn drop(&mut self) {
let mut bytes = lock(&self.bytes);
bytes.in_flight = bytes.in_flight.saturating_sub(self.archive);
}
}
impl Meter {
fn new(limits: Limits) -> Meter {
Meter {
limits,
bytes: Arc::new(Mutex::new(Bytes {
left: limits.bytes,
in_flight: 0,
})),
}
}
fn ask<S: Source>(&self, source: &S) -> Result<(), Error> {
if source.spare_requests().is_some_and(|spare| spare < RESERVE) {
return Err(Error::Held(
"what is left of GitHub's rate limit is kept for runners",
));
}
if github::requests_sent() + 2 > u64::from(self.limits.requests) {
return Err(Error::Held("this refresh's requests to GitHub are spent"));
}
Ok(())
}
fn reserve(&self, store: &ArchiveStore) -> Result<InFlight, Refused> {
let held = store.size().1;
let mut bytes = lock(&self.bytes);
if held + bytes.in_flight + self.limits.archive > self.limits.store {
return Err(Refused::Full);
}
if bytes.left < self.limits.archive {
return Err(Refused::Spent);
}
bytes.left -= self.limits.archive;
bytes.in_flight += self.limits.archive;
Ok(InFlight {
bytes: self.bytes.clone(),
archive: self.limits.archive,
})
}
fn spend(&self, received: u64) {
lock(&self.bytes).left += self.limits.archive - received.min(self.limits.archive);
}
}
async fn fetch<S: Source>(
source: &S,
meter: &Meter,
store: &Arc<Mutex<ArchiveStore>>,
key: &Key,
now: u64,
) -> Result<u64, Fetch> {
let file = lock(store).staging_file().map_err(Fetch::Store)?;
let mut last = None;
let mut place = None;
for wait in ATTEMPTS {
tokio::time::sleep(wait).await;
drop(place.take());
let reserved = meter.reserve(&lock(store));
place = Some(match reserved {
Ok(place) => place,
Err(Refused::Full) => return Err(Fetch::Full),
Err(Refused::Spent) => return Err(Fetch::Deferred),
});
let received = AtomicU64::new(0);
let result = source
.tarball(
&key.repository,
&key.sha,
&file,
meter.limits.archive,
&received,
)
.await;
meter.spend(received.load(Ordering::Relaxed));
match result {
Ok(_) => {
last = None;
break;
}
Err(error) => {
let _ = tokio::fs::remove_file(&file).await;
if matches!(error, Error::RateLimited { .. } | Error::Held(_)) {
return Err(Fetch::Deferred);
}
if error.is_gone() {
return Err(Fetch::Gone);
}
last = Some(error);
}
}
}
if let Some(error) = last {
return Err(Fetch::Download(error));
}
let published = {
let store = store.clone();
let key = key.clone();
let file = file.clone();
tokio::task::spawn_blocking(move || -> Result<u64, Fetch> {
let verified = verify::verify(&file, &key.sha, verify::BUDGET)
.map_err(|rejected| Fetch::Rejected(format!("failed its check: {rejected}")))?;
let size = verified.size;
let mut uses: BTreeMap<String, Vec<Pin>> = BTreeMap::new();
let mut unread = BTreeSet::new();
let actions: BTreeSet<String> = verified.actions.keys().cloned().collect();
for (dir, action) in &verified.actions {
match action.bytes.as_deref().map(pins::action_file_pins) {
Some(Ok(found)) if found.is_empty() => {}
Some(Ok(found)) => {
uses.insert(dir.clone(), found);
}
Some(Err(_)) | None => {
unread.insert(dir.clone());
}
}
}
let staged = Staged {
file: file.clone(),
sha256: verified.sha256,
size,
uses,
unread,
actions,
};
let mut store = lock(&store);
store.publish(key, staged, now).map_err(Fetch::Store)?;
drop(place);
drop(store);
Ok(size)
})
.await
};
let result = match published {
Ok(result) => result,
Err(error) => Err(Fetch::Store(std::io::Error::other(error))),
};
if result.is_err() {
let _ = tokio::fs::remove_file(&file).await;
}
result
}
#[derive(Debug, thiserror::Error)]
enum PinsError {
#[error(transparent)]
Github(#[from] Error),
#[error("GitHub cut its tree short")]
Truncated,
#[error("it has {0} workflows and action files, more than are read")]
Files(usize),
#[error("{0} is larger than is read")]
Large(String),
#[error("{path}: {why}")]
Unreadable { path: String, why: pins::Unreadable },
}
impl PinsError {
fn brief(&self) -> String {
match self {
PinsError::Github(error) => error.brief(),
PinsError::Truncated
| PinsError::Files(_)
| PinsError::Large(_)
| PinsError::Unreadable { .. } => self.to_string(),
}
}
}
#[derive(Debug, Default)]
struct Names(HashMap<String, Option<String>>);
impl Names {
async fn public<S: Source>(
&mut self,
source: &S,
meter: &Meter,
store: &Arc<Mutex<ArchiveStore>>,
repository: &str,
) -> Result<Option<String>, Error> {
let asked = repository.to_ascii_lowercase();
if let Some(name) = self.0.get(&asked) {
return Ok(name.clone());
}
if lock(store).package(&asked) {
self.0.insert(asked, None);
return Ok(None);
}
meter.ask(source)?;
let name = match source.action_repository(repository).await {
Ok(found) => (found.public
&& pins::repository(&found.full_name)
&& !lock(store).package(&found.full_name))
.then_some(found.full_name),
Err(error) if error.is_gone() => None,
Err(error) => return Err(error),
};
self.0.insert(asked, name.clone());
Ok(name)
}
}
#[cfg(test)]
mod tests;