use std::path::PathBuf;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use serde::{Deserialize, Serialize};
use spider_cloud_agent::auth::store;
pub const STATE_FILE: &str = "update.json";
pub const LOCK_FILE: &str = "update.lock";
const MAX_STATE_BYTES: u64 = 64 * 1024;
const STALE_LOCK: Duration = Duration::from_secs(15 * 60);
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct State {
#[serde(default)]
pub last_check: u64,
#[serde(default)]
pub staged: Option<Staged>,
#[serde(default)]
pub notice: Option<Notice>,
#[serde(default)]
pub told: Option<String>,
#[serde(default)]
pub outcome: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Staged {
pub version: String,
pub sha256: String,
pub target: PathBuf,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Notice {
pub text: String,
#[serde(default)]
pub warning: bool,
}
pub fn now() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|elapsed| elapsed.as_secs())
.unwrap_or(0)
}
pub fn due(last_check: u64, now: u64, interval: Duration) -> bool {
last_check > now || now - last_check >= interval.as_secs()
}
fn path(name: &str) -> Option<PathBuf> {
store::spider_dir().map(|dir| dir.join(name))
}
pub fn read() -> State {
use std::io::Read;
let Some(path) = path(STATE_FILE) else {
return State::default();
};
let Ok(file) = std::fs::File::open(path) else {
return State::default();
};
let mut text = String::new();
if file
.take(MAX_STATE_BYTES)
.read_to_string(&mut text)
.is_err()
{
return State::default();
}
serde_json::from_str(&text).unwrap_or_default()
}
pub fn write(state: &State) -> std::io::Result<()> {
let text = serde_json::to_vec_pretty(state)
.map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error))?;
store::write_private_file(STATE_FILE, &text).map(|_| ())
}
pub struct Lock {
path: PathBuf,
}
impl Lock {
pub fn try_take() -> Option<Lock> {
let dir = store::ensure_spider_dir().ok()?;
let path = dir.join(LOCK_FILE);
match create(&path) {
Ok(()) => return Some(Lock { path }),
Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {}
Err(_) => return None,
}
let stale = std::fs::metadata(&path)
.and_then(|meta| meta.modified())
.ok()
.and_then(|modified| modified.elapsed().ok())
.is_some_and(|age| age > STALE_LOCK);
if !stale {
return None;
}
std::fs::remove_file(&path).ok()?;
create(&path).ok().map(|()| Lock { path })
}
}
fn create(path: &std::path::Path) -> std::io::Result<()> {
use std::io::Write;
let mut options = std::fs::OpenOptions::new();
options.write(true).create_new(true);
#[cfg(unix)]
{
use std::os::unix::fs::OpenOptionsExt;
options.mode(store::FILE_MODE);
}
let mut file = options.open(path)?;
let _ = writeln!(file, "{}", std::process::id());
Ok(())
}
impl Drop for Lock {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.path);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_throttle_waits_out_the_interval_and_forgives_a_clock_moved_back() {
let day = Duration::from_secs(86_400);
assert!(due(0, 1_000_000, day));
assert!(!due(1_000_000, 1_000_000 + 3_600, day));
assert!(due(1_000_000, 1_000_000 + 86_400, day));
assert!(due(2_000_000, 1_000_000, day));
}
}