use super::Seat;
use super::keeper::Keeper;
use super::socket::{self, Address};
use super::wire::{self, Answer, Request};
use crate::keys::KeySource;
use interprocess::local_socket::traits::Listener as _;
use interprocess::local_socket::{Listener, Stream};
use std::io;
use std::sync::Arc;
use std::time::Duration;
const TICK: Duration = Duration::from_secs(1);
pub fn start_ticking(keeper: Arc<Keeper>) {
std::thread::Builder::new()
.name("agent clock".to_owned())
.spawn(move || {
loop {
std::thread::sleep(TICK);
keeper.tick();
}
})
.expect("the clock thread starts");
}
#[derive(Debug, thiserror::Error)]
pub enum Taken {
#[error("an agent is already running")]
Occupied,
#[error("cannot listen for the command line: {0}")]
Refused(#[from] io::Error),
#[error("cannot listen for the command line: there is no directory to listen in")]
Nowhere,
}
pub fn serve(seat: Seat, keeper: Arc<Keeper>) -> Result<(), Taken> {
let address = Address::of(seat).ok_or(Taken::Nowhere)?;
let listener = socket::listen(&address).map_err(|error| {
if super::client::answers_at(&address) {
Taken::Occupied
} else {
Taken::Refused(error)
}
})?;
std::thread::Builder::new()
.name("agent".to_owned())
.spawn(move || accept(listener, keeper))
.map_err(Taken::Refused)?;
Ok(())
}
pub fn leave(seat: Seat) {
if let Some(address) = Address::of(seat) {
socket::leave(&address);
}
}
fn accept(listener: Listener, keeper: Arc<Keeper>) {
loop {
match listener.accept() {
Ok(stream) => {
let keeper = keeper.clone();
let _ = std::thread::Builder::new()
.name("agent client".to_owned())
.spawn(move || {
let _ = answer(stream, &keeper);
});
}
Err(_) => std::thread::sleep(TICK),
}
}
}
fn answer(stream: Stream, keeper: &Keeper) -> io::Result<()> {
let message = wire::receive(&stream)?;
let request = Request::decode(&message);
let locking = request == Some(Request::Lock);
let answer = respond(request, keeper);
let sent = wire::send(&stream, &answer.encode());
if locking {
keeper.tell();
}
sent
}
fn respond(request: Option<Request>, keeper: &Keeper) -> Answer {
match request {
None => Answer::Unknown,
Some(Request::State) => Answer::of_state(keeper.state()),
Some(Request::Lock) => Answer::LockedNow(keeper.wipe()),
Some(Request::Key(salt)) => match keeper.key_for(&salt) {
Ok(key) => Answer::Key(key),
Err(_) => Answer::Locked,
},
Some(Request::Peek(salt)) => match keeper.peek(&salt) {
Ok(key) => Answer::Key(key),
Err(_) => Answer::Locked,
},
Some(Request::Fresh(opened_with)) => match keeper.fresh(&opened_with) {
Ok(fresh) => Answer::Fresh(fresh),
Err(_) => Answer::Locked,
},
}
}