use super::history::{Frame, NamedRun, RunEvent, RunHistory, RunMeta, RunView};
use super::html::{open_in_browser, server_page};
use super::PlotError;
use crate::core::Solution;
use crate::genetic_algorithms_v2::ExecutionInfo;
use crate::nsga3::NSGAIII;
use std::collections::BTreeMap;
use std::sync::atomic::AtomicUsize;
use serde::Serialize;
use std::io::{self, BufRead, BufReader, Read, Write};
use std::net::{SocketAddr, TcpListener, TcpStream};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant};
const PUSH_INTERVAL: Duration = Duration::from_millis(100);
const HEARTBEAT: Duration = Duration::from_secs(15);
const ACCEPT_POLL: Duration = Duration::from_millis(25);
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RunState {
Waiting,
Running,
Stopping,
Stopped,
Done,
Replay,
Paused,
}
impl RunState {
pub fn as_str(self) -> &'static str {
match self {
RunState::Waiting => "waiting",
RunState::Running => "running",
RunState::Stopping => "stopping",
RunState::Stopped => "stopped",
RunState::Done => "done",
RunState::Replay => "replay",
RunState::Paused => "paused",
}
}
}
struct Shared {
history: Mutex<RunHistory>,
state: Mutex<RunState>,
version: AtomicU64,
run_id: AtomicU64,
meta_version: AtomicU64,
comparisons: Mutex<Vec<(String, RunHistory)>>,
compare_version: AtomicU64,
keep_runs: AtomicBool,
paused: AtomicBool,
stop: AtomicBool,
closing: AtomicBool,
host: String,
port: u16,
token: Mutex<Option<String>>,
focus: Mutex<Option<FocusRequest>>,
steering: AtomicBool,
pending_group: Mutex<Option<String>>,
columns: Mutex<Option<Columns>>,
max_points: AtomicUsize,
latest_json: Mutex<(u64, Option<Arc<Vec<u8>>>)>,
}
pub type ColumnFn = Arc<dyn Fn(&[f64]) -> Vec<f64> + Send + Sync>;
#[derive(Clone)]
pub struct Columns {
pub names: Vec<String>,
pub compute: ColumnFn,
}
#[derive(Clone, Debug, PartialEq)]
pub enum FocusRequest {
Focus { aspiration: Vec<f64>, spread: f64 },
Clear,
}
impl FocusRequest {
pub fn event_label(&self) -> String {
match self {
FocusRequest::Focus { spread, .. } => format!("steered to goals ({:.0}% focus)", spread * 100.0),
FocusRequest::Clear => "steering off".to_string(),
}
}
}
impl Shared {
fn history(&self) -> MutexGuard<'_, RunHistory> {
self.history.lock().unwrap_or_else(|e| e.into_inner())
}
fn state(&self) -> RunState {
*self.state.lock().unwrap_or_else(|e| e.into_inner())
}
fn set_state(&self, s: RunState) {
*self.state.lock().unwrap_or_else(|e| e.into_inner()) = s;
}
fn comparisons(&self) -> MutexGuard<'_, Vec<(String, RunHistory)>> {
self.comparisons.lock().unwrap_or_else(|e| e.into_inner())
}
fn token(&self) -> Option<String> {
self.token.lock().unwrap_or_else(|e| e.into_inner()).clone()
}
}
fn is_loopback(host: &str) -> bool {
matches!(host, "127.0.0.1" | "localhost" | "::1" | "[::1]")
}
fn machine_name() -> String {
std::fs::read_to_string("/etc/hostname")
.ok()
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.or_else(|| std::env::var("HOSTNAME").ok())
.or_else(|| std::env::var("COMPUTERNAME").ok())
.unwrap_or_else(|| "localhost".to_string())
}
fn new_token() -> String {
use rand::RngCore;
let mut bytes = [0u8; 16];
rand::thread_rng().fill_bytes(&mut bytes);
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
#[derive(Clone)]
pub struct Dashboard {
inner: Arc<Inner>,
}
struct Inner {
shared: Arc<Shared>,
addr: SocketAddr,
accept: Mutex<Option<JoinHandle<()>>>,
}
impl Drop for Inner {
fn drop(&mut self) {
self.shared.closing.store(true, Ordering::SeqCst);
if let Some(h) = self.accept.lock().unwrap_or_else(|e| e.into_inner()).take() {
let _ = h.join();
}
}
}
impl Dashboard {
pub fn start(meta: RunMeta, host: &str, port: u16) -> io::Result<Self> {
Self::serve(RunHistory::new(meta), RunState::Waiting, host, port)
}
pub fn start_with(history: RunHistory, host: &str, port: u16) -> io::Result<Self> {
Self::serve(history, RunState::Waiting, host, port)
}
pub fn replay(history: RunHistory, host: &str, port: u16) -> io::Result<Self> {
Self::serve(history, RunState::Replay, host, port)
}
fn serve(history: RunHistory, state: RunState, host: &str, port: u16) -> io::Result<Self> {
let listener = TcpListener::bind((host, port))?;
listener.set_nonblocking(true)?;
let addr = listener.local_addr()?;
let shared = Arc::new(Shared {
history: Mutex::new(history),
state: Mutex::new(state),
version: AtomicU64::new(0),
run_id: AtomicU64::new(0),
meta_version: AtomicU64::new(0),
comparisons: Mutex::new(Vec::new()),
compare_version: AtomicU64::new(0),
keep_runs: AtomicBool::new(false),
paused: AtomicBool::new(false),
stop: AtomicBool::new(false),
closing: AtomicBool::new(false),
host: host.to_string(),
port: addr.port(),
token: Mutex::new(if is_loopback(host) { None } else { Some(new_token()) }),
focus: Mutex::new(None),
steering: AtomicBool::new(false),
pending_group: Mutex::new(None),
columns: Mutex::new(None),
max_points: AtomicUsize::new(2000),
latest_json: Mutex::new((u64::MAX, None)),
});
let sh = Arc::clone(&shared);
let accept = thread::Builder::new()
.name("puggles-dashboard".into())
.spawn(move || accept_loop(listener, sh))?;
Ok(Dashboard { inner: Arc::new(Inner { shared, addr, accept: Mutex::new(Some(accept)) }) })
}
pub fn url(&self) -> String {
let a = self.inner.addr;
let host = if a.ip().is_unspecified() {
machine_name() } else if a.is_ipv6() {
format!("[{}]", a.ip())
} else {
a.ip().to_string()
};
let token = self.inner.shared.token().map(|t| format!("?token={t}")).unwrap_or_default();
format!("http://{host}:{}/{token}", a.port())
}
pub fn require_token(&self, token: Option<String>) -> String {
let token = token.unwrap_or_else(new_token);
*self.inner.shared.token.lock().unwrap_or_else(|e| e.into_inner()) = Some(token.clone());
token
}
pub fn token(&self) -> Option<String> {
self.inner.shared.token()
}
pub fn addr(&self) -> SocketAddr {
self.inner.addr
}
pub fn open_browser(&self) -> &Self {
eprintln!("puggles dashboard: {}", self.url());
let _ = open_in_browser(&self.url());
self
}
pub fn record<R: RunView + ?Sized>(&self, ga: &R) -> bool {
self.record_without_hold(ga);
self.hold()
}
pub fn record_without_hold<R: RunView + ?Sized>(&self, ga: &R) {
let frame = Frame::from_run_sampled(ga, self.max_points());
self.record_frame_with_meta(frame, ga.algorithm(), ga.execution());
}
pub fn record_frame_with_meta(&self, mut frame: Frame, algorithm: &str, execution: Option<ExecutionInfo>) {
let sh = &self.inner.shared;
frame.thin_population(sh.max_points.load(Ordering::SeqCst));
let columns = sh.columns.lock().unwrap_or_else(|e| e.into_inner()).clone();
if let Some(c) = columns {
let mut out: BTreeMap<String, Vec<f64>> = c.names.iter().map(|n| (n.clone(), Vec::new())).collect();
for x in &frame.variables {
let values = (c.compute)(x);
for (k, name) in c.names.iter().enumerate() {
out.get_mut(name).expect("named column").push(values.get(k).copied().unwrap_or(f64::NAN));
}
}
frame.extra = Some(out);
}
let meta_changed = {
let mut h = sh.history();
keep_finished_run(sh, &mut h, frame.nfe);
let mut changed = h.update_meta_parts(algorithm, execution);
if h.is_empty() || h.starts_new_run(frame.nfe) {
if let Some(g) = sh.pending_group.lock().unwrap_or_else(|e| e.into_inner()).take() {
h.meta.group = Some(g);
changed = true;
}
}
if sh.keep_runs.load(Ordering::SeqCst) {
let label = Some(format!("run {} · {}", sh.comparisons().len() + 1, algorithm));
if h.meta.run_label != label {
h.meta.run_label = label;
changed = true;
}
}
changed
};
if meta_changed {
sh.meta_version.fetch_add(1, Ordering::SeqCst);
}
self.push_frame(frame, true);
}
pub fn record_solutions(&self, archive: &[Solution], population: &[Solution], nfe: usize) -> bool {
self.record_frame(Frame::from_solutions(archive, population, nfe))
}
pub fn record_frame(&self, frame: Frame) -> bool {
self.push_frame(frame, false);
self.hold()
}
pub fn record_frame_without_hold(&self, frame: Frame) {
self.push_frame(frame, false);
}
pub fn hold(&self) -> bool {
loop {
if let Some(keep_going) = self.hold_for(Duration::from_secs(3600)) {
return keep_going;
}
}
}
pub fn hold_for(&self, max: Duration) -> Option<bool> {
let sh = &self.inner.shared;
let started = Instant::now();
loop {
let stop = sh.stop.load(Ordering::SeqCst);
if stop || !sh.paused.load(Ordering::SeqCst) || sh.closing.load(Ordering::SeqCst) {
if !stop {
sh.set_state(RunState::Running);
}
return Some(!stop);
}
sh.set_state(RunState::Paused);
let left = max.saturating_sub(started.elapsed());
if left.is_zero() {
return None;
}
thread::sleep(left.min(Duration::from_millis(50)));
}
}
fn push_frame(&self, frame: Frame, finished_run_kept: bool) {
let sh = &self.inner.shared;
let new_run = {
let mut h = sh.history();
if !finished_run_kept {
keep_finished_run(sh, &mut h, frame.nfe);
}
h.record_frame(frame)
};
if new_run {
sh.run_id.fetch_add(1, Ordering::SeqCst);
sh.stop.store(false, Ordering::SeqCst);
}
sh.version.fetch_add(1, Ordering::SeqCst);
}
pub fn pause(&self) {
set_paused(&self.inner.shared, true);
}
pub fn resume(&self) {
set_paused(&self.inner.shared, false);
}
pub fn is_paused(&self) -> bool {
self.inner.shared.paused.load(Ordering::SeqCst)
}
pub fn compare_with(&self, name: impl Into<String>, history: RunHistory) {
let sh = &self.inner.shared;
sh.comparisons().push((name.into(), history));
sh.compare_version.fetch_add(1, Ordering::SeqCst);
}
pub fn keep_runs(&self, on: bool) -> &Self {
self.inner.shared.keep_runs.store(on, Ordering::SeqCst);
self
}
pub fn comparisons(&self) -> Vec<(String, RunHistory)> {
self.inner.shared.comparisons().clone()
}
pub fn set_group(&self, group: impl Into<String>) {
*self.inner.shared.pending_group.lock().unwrap_or_else(|e| e.into_inner()) = Some(group.into());
}
pub fn set_columns(&self, names: Vec<String>, compute: impl Fn(&[f64]) -> Vec<f64> + Send + Sync + 'static) {
*self.inner.shared.columns.lock().unwrap_or_else(|e| e.into_inner()) = Some(Columns { names, compute: Arc::new(compute) });
}
pub fn set_max_points(&self, max: usize) {
self.inner.shared.max_points.store(max, Ordering::SeqCst);
}
#[cfg(test)]
pub(crate) fn queue_focus(&self, request: FocusRequest) {
*self.inner.shared.focus.lock().unwrap_or_else(|e| e.into_inner()) = Some(request);
}
pub fn take_focus_request(&self) -> Option<FocusRequest> {
self.mark_steerable();
self.inner.shared.focus.lock().unwrap_or_else(|e| e.into_inner()).take()
}
pub fn apply_focus(&self, ga: &mut NSGAIII) {
let Some(request) = self.take_focus_request() else { return };
match &request {
FocusRequest::Focus { aspiration, spread } => ga.focus_on(aspiration, *spread),
FocusRequest::Clear => ga.clear_focus(),
}
self.add_event(ga.get_nfe(), request.event_label());
}
pub fn add_event(&self, nfe: usize, label: impl Into<String>) {
let sh = &self.inner.shared;
sh.history().meta.events.push(RunEvent { nfe, label: label.into() });
sh.meta_version.fetch_add(1, Ordering::SeqCst);
}
fn mark_steerable(&self) {
let sh = &self.inner.shared;
let mut h = sh.history();
if h.meta.steerable != Some(true) {
h.meta.steerable = Some(true);
sh.meta_version.fetch_add(1, Ordering::SeqCst);
}
}
pub fn finish(&self) {
let sh = &self.inner.shared;
sh.set_state(if sh.stop.load(Ordering::SeqCst) { RunState::Stopped } else { RunState::Done });
}
pub fn request_stop(&self) {
request_stop(&self.inner.shared);
}
pub fn state(&self) -> RunState {
self.inner.shared.state()
}
pub fn history(&self) -> RunHistory {
self.inner.shared.history().clone()
}
pub fn frame_count(&self) -> usize {
self.inner.shared.history().len()
}
pub fn latest_nfe(&self) -> Option<usize> {
self.inner.shared.history().latest().map(|f| f.nfe)
}
pub fn meta(&self) -> RunMeta {
self.inner.shared.history().meta.clone()
}
pub fn max_points(&self) -> usize {
self.inner.shared.max_points.load(Ordering::SeqCst)
}
pub fn to_json(&self) -> String {
self.inner.shared.history().to_json()
}
pub fn save_json(&self, path: impl AsRef<Path>) -> Result<PathBuf, PlotError> {
self.inner.shared.history().save_json(path)
}
pub fn save_html(&self, path: impl AsRef<Path>) -> Result<PathBuf, PlotError> {
std::fs::write(path.as_ref(), self.to_html())?;
Ok(path.as_ref().to_path_buf())
}
pub fn to_html(&self) -> String {
let sh = &self.inner.shared;
sh.history().to_html_compared(&sh.comparisons())
}
pub fn wait(&self) {
while !self.is_closed() {
thread::sleep(Duration::from_millis(200));
}
}
pub fn close(&self) {
self.inner.shared.closing.store(true, Ordering::SeqCst);
}
pub fn is_closed(&self) -> bool {
self.inner.shared.closing.load(Ordering::SeqCst)
}
}
fn request_stop(sh: &Shared) {
let state = sh.state();
if matches!(state, RunState::Waiting | RunState::Running | RunState::Paused) {
sh.stop.store(true, Ordering::SeqCst);
sh.set_state(RunState::Stopping);
}
}
fn keep_finished_run(sh: &Shared, h: &mut RunHistory, nfe: usize) {
if sh.keep_runs.load(Ordering::SeqCst) && h.starts_new_run(nfe) && !h.is_empty() {
let mut comparisons = sh.comparisons();
let name = h.meta.run_label.clone().unwrap_or_else(|| {
format!("run {}", comparisons.len() + 1)
+ &h.meta.algorithm.as_ref().map(|a| format!(" · {a}")).unwrap_or_default()
});
comparisons.push((name, h.clone()));
sh.compare_version.fetch_add(1, Ordering::SeqCst);
}
}
fn set_paused(sh: &Shared, paused: bool) {
sh.paused.store(paused, Ordering::SeqCst);
if !paused && sh.state() == RunState::Paused {
sh.set_state(RunState::Running);
}
}
fn accept_loop(listener: TcpListener, sh: Arc<Shared>) {
while !sh.closing.load(Ordering::SeqCst) {
match listener.accept() {
Ok((stream, _)) => {
if stream.set_nonblocking(false).is_err() {
continue;
}
let sh = Arc::clone(&sh);
let _ = thread::Builder::new().name("puggles-dashboard-conn".into()).spawn(move || {
let _ = handle(stream, &sh);
});
}
Err(e) if e.kind() == io::ErrorKind::WouldBlock => thread::sleep(ACCEPT_POLL),
Err(_) => thread::sleep(ACCEPT_POLL),
}
}
}
struct Request {
method: String,
path: String,
query_token: Option<String>,
host: Option<String>,
origin: Option<String>,
cookie: Option<String>,
body: Vec<u8>,
}
const MAX_BODY: usize = 64 * 1024;
fn read_request(stream: &TcpStream) -> io::Result<Request> {
let mut reader = BufReader::new(stream.take((16 * 1024 + MAX_BODY) as u64));
let mut line = String::new();
reader.read_line(&mut line)?;
let mut parts = line.split_whitespace();
let method = parts.next().unwrap_or("").to_string();
let target = parts.next().unwrap_or("/");
let (path, query) = target.split_once('?').unwrap_or((target, ""));
let path = path.split('#').next().unwrap_or("/").to_string();
let query_token = query.split('&').find_map(|kv| kv.strip_prefix("token=")).map(str::to_string);
let (mut host, mut origin, mut cookie, mut length) = (None, None, None, 0usize);
loop {
line.clear();
if reader.read_line(&mut line)? == 0 || line == "\r\n" || line == "\n" {
break;
}
if let Some((name, value)) = line.split_once(':') {
let value = value.trim().to_string();
match name.trim().to_ascii_lowercase().as_str() {
"host" => host = Some(value),
"origin" => origin = Some(value),
"cookie" => cookie = Some(value),
"content-length" => length = value.parse().unwrap_or(0),
_ => {}
}
}
}
let mut body = vec![0u8; length.min(MAX_BODY)];
reader.read_exact(&mut body)?;
Ok(Request { method, path, query_token, host, origin, cookie, body })
}
fn cookie_name(sh: &Shared) -> String {
format!("puggles_token_{}", sh.port) }
fn same_secret(a: &str, b: &str) -> bool {
a.len() == b.len() && a.bytes().zip(b.bytes()).fold(0u8, |acc, (x, y)| acc | (x ^ y)) == 0
}
fn allowed(req: &Request, sh: &Shared) -> bool {
let strip_port = |h: &str| -> String {
h.rsplit_once(':').map_or(h, |(n, port)| if port.chars().all(|c| c.is_ascii_digit()) { n } else { h }).to_string()
};
if let Some(token) = sh.token() {
let name = cookie_name(sh);
let from_cookie = req.cookie.as_deref().and_then(|c| {
c.split(';').find_map(|kv| kv.trim().strip_prefix(name.as_str()).and_then(|v| v.strip_prefix('=')).map(str::to_string))
});
let ok = from_cookie.iter().chain(req.query_token.iter()).any(|t| same_secret(t, &token));
if !ok {
return false;
}
if req.method != "GET" {
if let (Some(o), Some(h)) = (&req.origin, &req.host) {
let o = o.strip_prefix("http://").or_else(|| o.strip_prefix("https://")).unwrap_or(o);
if o != h {
return false;
}
}
}
return true;
}
let local = |h: &str| {
let name = strip_port(h);
matches!(name.as_str(), "127.0.0.1" | "localhost" | "[::1]") || name == sh.host
};
if let Some(h) = &req.host {
if !local(h) {
return false;
}
}
if req.method != "GET" {
if let Some(o) = &req.origin {
let o = o.strip_prefix("http://").unwrap_or(o);
if !local(o) {
return false;
}
}
}
true
}
fn handle(mut stream: TcpStream, sh: &Shared) -> io::Result<()> {
stream.set_read_timeout(Some(Duration::from_secs(5)))?;
let req = read_request(&stream)?;
if !allowed(&req, sh) {
let msg: &[u8] = if sh.token().is_some() {
b"Forbidden: open the dashboard with the URL it printed (it carries ?token=...)"
} else {
b"Forbidden"
};
return respond(&mut stream, "403 Forbidden", "text/plain", msg);
}
match (req.method.as_str(), req.path.as_str()) {
("GET", "/") | ("GET", "/index.html") => {
let cookie = match (&req.query_token, sh.token()) {
(Some(t), Some(_)) => {
format!("Set-Cookie: {}={t}; Path=/; HttpOnly; SameSite=Strict\r\n", cookie_name(sh))
}
_ => String::new(),
};
respond_with(&mut stream, "200 OK", "text/html; charset=utf-8", &cookie, server_page().as_bytes())
}
("POST", "/api/goals") => {
#[derive(serde::Deserialize)]
struct Goals {
goals: Vec<Option<f64>>,
#[serde(default)]
steer: bool,
#[serde(default = "default_spread")]
spread: f64,
}
fn default_spread() -> f64 {
0.25
}
let Ok(g) = serde_json::from_slice::<Goals>(&req.body) else {
return respond(&mut stream, "400 Bad Request", "text/plain", b"expected {goals: [...], steer, spread}");
};
{
let mut h = sh.history();
let any = g.goals.iter().any(Option::is_some);
h.meta.goals = if any { Some(g.goals.clone()) } else { None };
sh.meta_version.fetch_add(1, Ordering::SeqCst);
}
let wants = g.steer && g.goals.iter().any(Option::is_some);
let request = if wants {
Some(FocusRequest::Focus { aspiration: g.goals.iter().map(|v| v.unwrap_or(f64::NAN)).collect(), spread: g.spread })
} else if sh.steering.load(Ordering::SeqCst) {
Some(FocusRequest::Clear)
} else {
None
};
sh.steering.store(wants, Ordering::SeqCst);
if let Some(r) = request {
*sh.focus.lock().unwrap_or_else(|e| e.into_inner()) = Some(r);
}
respond(&mut stream, "200 OK", "application/json", b"{\"ok\":true}")
}
("GET", "/api/meta") => {
let body = serde_json::to_vec(&sh.history().meta)?;
respond(&mut stream, "200 OK", "application/json", &body)
}
("GET", "/api/history") => {
#[derive(Serialize)]
struct History<'a> {
state: &'static str,
run_id: u64,
frames: Vec<&'a Frame>,
}
let body = {
let h = sh.history();
serde_json::to_vec(&History {
state: sh.state().as_str(),
run_id: sh.run_id.load(Ordering::SeqCst),
frames: h.frames().collect(),
})?
};
respond(&mut stream, "200 OK", "application/json", &body)
}
("GET", "/api/compare") => {
let body = {
let comparisons = sh.comparisons();
let runs: Vec<NamedRun<'_>> = comparisons.iter().map(|(n, h)| NamedRun::new(n, h)).collect();
serde_json::to_vec(&runs)?
};
respond(&mut stream, "200 OK", "application/json", &body)
}
("GET", "/api/events") => events(stream, sh),
("POST", "/api/stop") | ("POST", "/api/pause") | ("POST", "/api/resume") => {
match req.path.as_str() {
"/api/stop" => request_stop(sh),
"/api/pause" => set_paused(sh, true),
_ => set_paused(sh, false),
}
let body = format!(
"{{\"state\":\"{}\",\"paused\":{}}}",
sh.state().as_str(),
sh.paused.load(Ordering::SeqCst)
);
respond(&mut stream, "200 OK", "application/json", body.as_bytes())
}
("GET", _) | ("POST", _) => respond(&mut stream, "404 Not Found", "text/plain", b"Not Found"),
_ => respond(&mut stream, "405 Method Not Allowed", "text/plain", b"Method Not Allowed"),
}
}
fn respond(stream: &mut TcpStream, status: &str, content_type: &str, body: &[u8]) -> io::Result<()> {
respond_with(stream, status, content_type, "", body)
}
fn respond_with(stream: &mut TcpStream, status: &str, content_type: &str, extra_headers: &str, body: &[u8]) -> io::Result<()> {
let head = format!(
"HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\n\
Cache-Control: no-store\r\nX-Content-Type-Options: nosniff\r\n{extra_headers}Connection: close\r\n\r\n",
body.len()
);
stream.write_all(head.as_bytes())?;
stream.write_all(body)?;
stream.flush()
}
fn latest_frame_json(sh: &Shared, version: u64) -> io::Result<Option<Arc<Vec<u8>>>> {
let mut cache = sh.latest_json.lock().unwrap_or_else(|e| e.into_inner());
if cache.0 != version {
let json = sh.history().latest().map(serde_json::to_vec).transpose()?;
*cache = (version, json.map(Arc::new));
}
Ok(cache.1.clone())
}
fn events(mut stream: TcpStream, sh: &Shared) -> io::Result<()> {
stream.write_all(
b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nCache-Control: no-store\r\n\
X-Accel-Buffering: no\r\nConnection: close\r\n\r\n",
)?;
stream.flush()?;
let mut seen_version = u64::MAX;
let mut seen_run = sh.run_id.load(Ordering::SeqCst);
let mut seen_meta = u64::MAX;
let mut seen_compare = u64::MAX;
let mut seen_paused: Option<bool> = None;
let mut seen_state: Option<RunState> = None;
let mut last_write = Instant::now();
while !sh.closing.load(Ordering::SeqCst) {
let mut out = Vec::new();
let run = sh.run_id.load(Ordering::SeqCst);
if run != seen_run {
seen_run = run;
out.extend(format!("event: reset\ndata: {{\"run_id\":{run}}}\n\n").into_bytes());
}
let compare_version = sh.compare_version.load(Ordering::SeqCst);
if compare_version != seen_compare {
seen_compare = compare_version;
let count = sh.comparisons().len();
out.extend(format!("event: compare\ndata: {{\"count\":{count}}}\n\n").into_bytes());
}
let paused = sh.paused.load(Ordering::SeqCst);
if seen_paused != Some(paused) {
seen_paused = Some(paused);
out.extend(format!("event: paused\ndata: {{\"paused\":{paused}}}\n\n").into_bytes());
}
let meta_version = sh.meta_version.load(Ordering::SeqCst);
if meta_version != seen_meta {
seen_meta = meta_version;
out.extend_from_slice(b"event: meta\ndata: ");
out.extend(serde_json::to_vec(&sh.history().meta)?);
out.extend_from_slice(b"\n\n");
}
let version = sh.version.load(Ordering::SeqCst);
if version != seen_version {
seen_version = version;
if let Some(json) = latest_frame_json(sh, version)? {
out.extend_from_slice(b"event: frame\ndata: ");
out.extend_from_slice(&json);
out.extend_from_slice(b"\n\n");
}
}
let state = sh.state();
if seen_state != Some(state) {
seen_state = Some(state);
out.extend(format!("event: state\ndata: {{\"state\":\"{}\"}}\n\n", state.as_str()).into_bytes());
}
if out.is_empty() && last_write.elapsed() > HEARTBEAT {
out.extend_from_slice(b": keep-alive\n\n");
}
if !out.is_empty() {
stream.write_all(&out)?;
stream.flush()?;
last_write = Instant::now();
}
thread::sleep(PUSH_INTERVAL);
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::Problem;
use crate::gatypes::{Real, SolutionDataTypes};
use crate::genetic_algorithms_v2::{ExecutionMode, NSGAII};
fn get(dash: &Dashboard, method: &str, path: &str, extra: &str) -> String {
let mut s = TcpStream::connect(dash.addr()).unwrap();
write!(s, "{method} {path} HTTP/1.1\r\nHost: 127.0.0.1\r\n{extra}\r\n").unwrap();
let mut out = String::new();
s.read_to_string(&mut out).unwrap();
out
}
#[test]
fn serves_the_page_api_and_stop() {
let problem = Arc::new(Problem::new(
2, 2, None, None, Some(vec![-1, -1]),
vec![SolutionDataTypes::Real(Real::new(Some(0.0), Some(1.0))); 2],
|x| vec![x[0], 1.0 - x[0] + x[1]],
));
let dash = Dashboard::start(RunMeta::from_problem(&problem).title("test"), "127.0.0.1", 0).unwrap();
assert_eq!(dash.state(), RunState::Waiting);
let page = get(&dash, "GET", "/", "");
assert!(page.starts_with("HTTP/1.1 200"));
assert!(page.contains("window.PugglesPlot"));
assert!(get(&dash, "GET", "/api/meta", "").contains("\"title\":\"test\""));
assert!(get(&dash, "GET", "/nope", "").starts_with("HTTP/1.1 404"));
assert!(get(&dash, "POST", "/api/stop", "Origin: http://evil.example\r\n").starts_with("HTTP/1.1 403"));
let mut ga = NSGAII::new(Arc::clone(&problem), 10, ExecutionMode::Sequential).with_seed(4);
let mut stopped_at = None;
ga.run_with(100_000, |ga| {
if ga.get_nfe() >= 100 && stopped_at.is_none() {
let reply = get(&dash, "POST", "/api/stop", "Origin: http://127.0.0.1\r\n");
assert!(reply.contains("stopping"), "{reply}");
stopped_at = Some(ga.get_nfe());
}
dash.record(ga)
});
dash.finish();
assert_eq!(dash.state(), RunState::Stopped);
assert!(ga.get_nfe() <= stopped_at.unwrap() + 10, "Stop must end the run at the next generation");
let hist = get(&dash, "GET", "/api/history", "");
assert!(hist.contains("\"state\":\"stopped\""));
assert!(hist.contains("\"F\":[["));
assert_eq!(dash.history().meta.algorithm.as_deref(), Some("NSGAII"));
let exec = dash.history().meta.execution.expect("execution info recorded");
assert_eq!(exec.effective, ExecutionMode::Sequential);
assert_eq!(exec.cpu_threads, Some(1));
assert!(get(&dash, "GET", "/api/meta", "").contains("\"execution\":{\"requested\":\"Sequential\""));
}
#[test]
fn streams_frames_over_sse() {
let dash = Dashboard::start(RunMeta::default(), "127.0.0.1", 0).unwrap();
let mut s = TcpStream::connect(dash.addr()).unwrap();
write!(s, "GET /api/events HTTP/1.1\r\nHost: localhost\r\n\r\n").unwrap();
s.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
dash.record_frame(Frame { nfe: 10, objectives: vec![vec![1.0, 2.0]], ..Default::default() });
let mut buf = Vec::new();
let mut chunk = [0u8; 4096];
let deadline = Instant::now() + Duration::from_secs(5);
while !String::from_utf8_lossy(&buf).contains("event: frame") && Instant::now() < deadline {
let n = s.read(&mut chunk).unwrap();
buf.extend_from_slice(&chunk[..n]);
}
let text = String::from_utf8_lossy(&buf);
assert!(text.contains("text/event-stream"));
assert!(text.contains("event: frame\ndata: {\"gen\":1,\"nfe\":10"), "{text}");
assert!(text.contains("event: meta\ndata: {"), "meta is sent on connect: {text}");
dash.close();
}
fn toy_problem() -> Arc<Problem> {
Arc::new(Problem::new(
2, 2, None, None, Some(vec![-1, -1]),
vec![SolutionDataTypes::Real(Real::new(Some(0.0), Some(1.0))); 2],
|x| vec![x[0], 1.0 - x[0] + x[1]],
))
}
#[test]
fn pause_holds_the_run_until_resume() {
let problem = toy_problem();
let dash = Dashboard::start(RunMeta::from_problem(&problem), "127.0.0.1", 0).unwrap();
dash.pause();
let d = dash.clone();
let p = Arc::clone(&problem);
let worker = thread::spawn(move || {
let mut ga = NSGAII::new(p, 10, ExecutionMode::Sequential).with_seed(1);
ga.run_with(200, |ga| d.record(ga));
d.finish();
ga.get_nfe()
});
thread::sleep(Duration::from_millis(300));
assert_eq!(dash.state(), RunState::Paused);
assert_eq!(dash.history().len(), 1, "paused after the first generation");
assert!(get(&dash, "POST", "/api/resume", "").contains("\"paused\":false"));
assert_eq!(worker.join().unwrap(), 200);
assert_eq!(dash.state(), RunState::Done);
}
#[test]
fn keep_runs_turns_earlier_runs_into_comparisons() {
let problem = toy_problem();
let dash = Dashboard::start(RunMeta::from_problem(&problem), "127.0.0.1", 0).unwrap();
dash.keep_runs(true);
for seed in 0..2 {
let mut ga = NSGAII::new(Arc::clone(&problem), 10, ExecutionMode::Sequential).with_seed(seed);
ga.run_with(100, |ga| dash.record(ga));
let mut ga3 = crate::nsga3::NSGAIII::new(Arc::clone(&problem), 12, 4, ExecutionMode::Sequential).with_seed(seed);
ga3.run_with(100, |ga| dash.record(ga));
}
let names: Vec<String> = dash.comparisons().into_iter().map(|(n, _)| n).collect();
assert_eq!(names, ["run 1 · NSGAII", "run 2 · NSGAIII", "run 3 · NSGAII"]);
assert_eq!(dash.history().meta.run_label.as_deref(), Some("run 4 · NSGAIII"));
assert!(get(&dash, "GET", "/api/compare", "").contains("\"name\":\"run 2 · NSGAIII\""));
let html = dash.to_html();
assert!(html.contains("\"comparisons\":[{\"name\":\"run 1 · NSGAII\""));
let latest = dash.history().latest().cloned().unwrap();
let timing = latest.timing.expect("NSGA-II frames carry phase timings");
assert!(timing.generation.evaluation >= 0.0 && timing.record >= 0.0);
}
fn post_json(dash: &Dashboard, path: &str, body: &str) -> String {
get(dash, "POST", path, &format!("Content-Type: application/json\r\nContent-Length: {}\r\n\r\n{body}", body.len()))
}
#[test]
fn token_is_required_when_set() {
let dash = Dashboard::start(RunMeta::default(), "127.0.0.1", 0).unwrap();
assert!(dash.token().is_none() && !dash.url().contains("token"));
let token = dash.require_token(Some("s3cret".into()));
assert!(dash.url().ends_with("/?token=s3cret"));
assert!(get(&dash, "GET", "/api/meta", "").starts_with("HTTP/1.1 403"));
let page = get(&dash, "GET", &format!("/?token={token}"), "");
assert!(page.starts_with("HTTP/1.1 200"));
let cookie = format!("puggles_token_{}=s3cret", dash.addr().port());
assert!(page.contains(&format!("Set-Cookie: {cookie}; Path=/; HttpOnly; SameSite=Strict")));
assert!(get(&dash, "GET", "/api/meta", &format!("Cookie: {cookie}\r\n")).starts_with("HTTP/1.1 200"));
assert!(get(&dash, "GET", "/api/meta", "Cookie: puggles_token_1=nope\r\n").starts_with("HTTP/1.1 403"));
let open = Dashboard::start(RunMeta::default(), "0.0.0.0", 0).unwrap();
assert!(open.token().is_some_and(|t| t.len() == 32));
}
#[test]
fn goals_reach_meta_and_steer_nsga3() {
let problem = toy_problem();
let dash = Dashboard::start(RunMeta::from_problem(&problem), "127.0.0.1", 0).unwrap();
assert!(post_json(&dash, "/api/goals", "{\"goals\":[0.2,null],\"steer\":true,\"spread\":0.3}").contains("ok"));
assert_eq!(dash.history().meta.goals, Some(vec![Some(0.2), None]));
let req = dash.take_focus_request().expect("steering request queued");
match req {
FocusRequest::Focus { aspiration, spread } => {
assert_eq!(aspiration[0], 0.2);
assert!(aspiration[1].is_nan());
assert_eq!(spread, 0.3);
}
other => panic!("{other:?}"),
}
assert_eq!(dash.history().meta.steerable, Some(true));
post_json(&dash, "/api/goals", "{\"goals\":[null,null]}");
assert_eq!(dash.take_focus_request(), Some(FocusRequest::Clear));
assert_eq!(dash.history().meta.goals, None);
assert!(post_json(&dash, "/api/goals", "not json").starts_with("HTTP/1.1 400"));
let mut ga = crate::nsga3::NSGAIII::new(Arc::clone(&problem), 12, 6, ExecutionMode::Sequential).with_seed(1);
post_json(&dash, "/api/goals", "{\"goals\":[0.1,0.9],\"steer\":true}");
ga.run_with(300, |ga| {
dash.apply_focus(ga);
dash.record(ga)
});
assert!(ga.reference_points() != crate::nsga3::das_dennis(2, 6).as_slice(), "focus applied");
let events = dash.history().meta.events;
assert_eq!(events.len(), 1);
assert!(events[0].label.starts_with("steered to goals"));
}
#[test]
fn columns_thinning_and_groups() {
let problem = toy_problem();
let dash = Dashboard::start(RunMeta::from_problem(&problem), "127.0.0.1", 0).unwrap();
dash.set_columns(vec!["sum".into(), "first".into()], |x| vec![x.iter().sum(), x[0]]);
dash.set_max_points(7);
dash.set_group("baseline");
let mut ga = NSGAII::new(Arc::clone(&problem), 20, ExecutionMode::Sequential).with_seed(2);
ga.run_with(200, |ga| dash.record(ga));
let h = dash.history();
let f = h.latest().unwrap();
let extra = f.extra.as_ref().unwrap();
assert_eq!(extra["sum"].len(), f.variables.len());
assert!((extra["sum"][0] - f.variables[0].iter().sum::<f64>()).abs() < 1e-12);
assert_eq!(f.population_objectives.len(), 7);
assert_eq!(f.population_total, Some(20));
assert_eq!(h.meta.group.as_deref(), Some("baseline"));
dash.keep_runs(true);
dash.set_group("tuned");
let mut ga = NSGAII::new(Arc::clone(&problem), 20, ExecutionMode::Sequential).with_seed(3);
ga.run_with(200, |ga| dash.record(ga));
assert_eq!(dash.comparisons()[0].1.meta.group.as_deref(), Some("baseline"));
assert_eq!(dash.history().meta.group.as_deref(), Some("tuned"));
}
}