microcosm.blue
Server tools to backfill, tail, mirror, and verify PLC logs
show latest at in health endpoint
track upstream lag sorta
bad-example.com
+1
-1
src/bin/mirror.rs
+1
-1
src/bin/mirror.rs
+58
src/cached_value.rs
+58
src/cached_value.rs
···
···
1
+
use std::error::Error;
2
+
use std::sync::Arc;
3
+
use std::time::{Duration, Instant};
4
+
use tokio::sync::Mutex;
5
+
6
+
pub trait Fetcher<T> {
7
+
fn fetch(&self) -> impl Future<Output = Result<T, Box<dyn Error>>>;
8
+
}
9
+
10
+
#[derive(Debug)]
11
+
struct ExpiringValue<T: Clone> {
12
+
value: T,
13
+
expires: Instant,
14
+
}
15
+
16
+
impl<T: Clone> ExpiringValue<T> {
17
+
fn get(&self, now: Instant) -> Option<T> {
18
+
if now <= self.expires {
19
+
Some(self.value.clone())
20
+
} else {
21
+
None
22
+
}
23
+
}
24
+
}
25
+
26
+
// TODO: generic over the fetcher's actual error type
27
+
#[derive(Clone)]
28
+
pub struct CachedValue<T: Clone, F: Fetcher<T>> {
29
+
latest: Arc<Mutex<Option<ExpiringValue<T>>>>,
30
+
fetcher: F,
31
+
validitiy: Duration,
32
+
}
33
+
34
+
impl<T: Clone, F: Fetcher<T>> CachedValue<T, F> {
35
+
pub fn new(f: F, validitiy: Duration) -> Self {
36
+
Self {
37
+
latest: Default::default(),
38
+
fetcher: f,
39
+
validitiy,
40
+
}
41
+
}
42
+
pub async fn get(&self) -> Result<T, Box<dyn Error>> {
43
+
let now = Instant::now();
44
+
return self.get_impl(now).await;
45
+
}
46
+
async fn get_impl(&self, now: Instant) -> Result<T, Box<dyn Error>> {
47
+
let mut val = self.latest.lock().await;
48
+
if let Some(v) = val.as_ref().and_then(|v| v.get(now)) {
49
+
return Ok(v);
50
+
}
51
+
let new = self.fetcher.fetch().await?;
52
+
*val = Some(ExpiringValue {
53
+
value: new.clone(),
54
+
expires: now + self.validitiy,
55
+
});
56
+
Ok(new)
57
+
}
58
+
}
+2
src/lib.rs
+2
src/lib.rs
···
2
use tokio::sync::{mpsc, oneshot};
3
4
mod backfill;
5
+
mod cached_value;
6
mod client;
7
mod mirror;
8
mod plc_pg;
···
13
pub mod bin;
14
15
pub use backfill::backfill;
16
+
pub use cached_value::{CachedValue, Fetcher};
17
pub use client::{CLIENT, UA};
18
pub use mirror::{ListenConf, serve};
19
pub use plc_pg::{Db, backfill_to_pg, pages_to_pg};
+38
-16
src/mirror.rs
+38
-16
src/mirror.rs
···
1
-
use crate::{GovernorMiddleware, UA, logo};
2
use futures::TryStreamExt;
3
use governor::Quota;
4
use poem::{
···
12
use reqwest::{Client, Url};
13
use std::{net::SocketAddr, path::PathBuf, time::Duration};
14
15
-
#[derive(Debug, Clone)]
16
struct State {
17
client: Client,
18
plc: Url,
19
upstream: Url,
20
}
21
22
#[handler]
···
119
plc,
120
client,
121
upstream,
122
}): Data<&State>,
123
) -> impl IntoResponse {
124
let mut overall_status = StatusCode::OK;
···
130
if !ok {
131
overall_status = StatusCode::BAD_GATEWAY;
132
}
133
(
134
overall_status,
135
Json(serde_json::json!({
···
137
"version": env!("CARGO_PKG_VERSION"),
138
"wrapped_plc": wrapped_status,
139
"upstream_plc": upstream_status,
140
})),
141
)
142
}
···
203
Bind(SocketAddr),
204
}
205
206
-
pub async fn serve(upstream: Url, plc: Url, listen: ListenConf) -> anyhow::Result<&'static str> {
207
log::info!("starting server...");
208
209
// not using crate CLIENT: don't want the retries etc
···
213
.build()
214
.expect("reqwest client to build");
215
216
let state = State {
217
client,
218
plc,
219
upstream: upstream.clone(),
220
};
221
222
let app = Route::new()
···
252
}
253
let auto_cert = auto_cert.build().expect("acme config to build");
254
255
-
let notice_task = tokio::task::spawn(run_insecure_notice());
256
-
let listener = TcpListener::bind("0.0.0.0:443");
257
-
let app_res = if ipv6 {
258
-
let listener = listener.combine(TcpListener::bind("[::]:443"));
259
-
run(app, listener.acme(auto_cert)).await
260
-
} else {
261
-
run(app, listener.acme(auto_cert)).await
262
-
};
263
log::warn!("server task ended, aborting insecure server task...");
264
notice_task.abort();
265
app_res?;
···
283
}
284
285
/// kick off a tiny little server on a tokio task to tell people to use 443
286
-
async fn run_insecure_notice() -> Result<(), std::io::Error> {
287
#[handler]
288
fn oop_plz_be_secure() -> (StatusCode, String) {
289
(
···
302
.at("/", get(oop_plz_be_secure))
303
.at("/favicon.ico", get(favicon))
304
.with(Tracing);
305
-
Server::new(TcpListener::bind("0.0.0.0:80"))
306
-
.name("allegedly (mirror:80 helper)")
307
-
.run(app)
308
-
.await
309
}
···
1
+
use crate::{CachedValue, Db, Dt, Fetcher, GovernorMiddleware, UA, logo};
2
use futures::TryStreamExt;
3
use governor::Quota;
4
use poem::{
···
12
use reqwest::{Client, Url};
13
use std::{net::SocketAddr, path::PathBuf, time::Duration};
14
15
+
#[derive(Clone)]
16
struct State {
17
client: Client,
18
plc: Url,
19
upstream: Url,
20
+
latest_at: CachedValue<Dt, LatestAt>,
21
+
}
22
+
23
+
#[derive(Clone)]
24
+
struct LatestAt(Db);
25
+
impl Fetcher<Dt> for LatestAt {
26
+
async fn fetch(&self) -> Result<Dt, Box<dyn std::error::Error>> {
27
+
let now = self.0.get_latest().await?.ok_or(anyhow::anyhow!(
28
+
"expected to find at least one thing in the db"
29
+
))?;
30
+
Ok(now)
31
+
}
32
}
33
34
#[handler]
···
131
plc,
132
client,
133
upstream,
134
+
latest_at,
135
}): Data<&State>,
136
) -> impl IntoResponse {
137
let mut overall_status = StatusCode::OK;
···
143
if !ok {
144
overall_status = StatusCode::BAD_GATEWAY;
145
}
146
+
let latest = latest_at.get().await.ok();
147
(
148
overall_status,
149
Json(serde_json::json!({
···
151
"version": env!("CARGO_PKG_VERSION"),
152
"wrapped_plc": wrapped_status,
153
"upstream_plc": upstream_status,
154
+
"latest_at": latest,
155
})),
156
)
157
}
···
218
Bind(SocketAddr),
219
}
220
221
+
pub async fn serve(
222
+
upstream: Url,
223
+
plc: Url,
224
+
listen: ListenConf,
225
+
db: Db,
226
+
) -> anyhow::Result<&'static str> {
227
log::info!("starting server...");
228
229
// not using crate CLIENT: don't want the retries etc
···
233
.build()
234
.expect("reqwest client to build");
235
236
+
let latest_at = CachedValue::new(LatestAt(db), Duration::from_secs(1));
237
+
238
let state = State {
239
client,
240
plc,
241
upstream: upstream.clone(),
242
+
latest_at,
243
};
244
245
let app = Route::new()
···
275
}
276
let auto_cert = auto_cert.build().expect("acme config to build");
277
278
+
let notice_task = tokio::task::spawn(run_insecure_notice(ipv6));
279
+
let listener = TcpListener::bind(if ipv6 { "[::]:443" } else { "0.0.0.0:443" });
280
+
let app_res = run(app, listener.acme(auto_cert)).await;
281
log::warn!("server task ended, aborting insecure server task...");
282
notice_task.abort();
283
app_res?;
···
301
}
302
303
/// kick off a tiny little server on a tokio task to tell people to use 443
304
+
async fn run_insecure_notice(ipv6: bool) -> Result<(), std::io::Error> {
305
#[handler]
306
fn oop_plz_be_secure() -> (StatusCode, String) {
307
(
···
320
.at("/", get(oop_plz_be_secure))
321
.at("/favicon.ico", get(favicon))
322
.with(Tracing);
323
+
Server::new(TcpListener::bind(if ipv6 {
324
+
"[::]:80"
325
+
} else {
326
+
"0.0.0.0:80"
327
+
}))
328
+
.name("allegedly (mirror:80 helper)")
329
+
.run(app)
330
+
.await
331
}