235 lines
7.6 KiB
Rust
235 lines
7.6 KiB
Rust
use std::sync::Arc;
|
|
|
|
use axum::extract::State;
|
|
use axum::http::{HeaderMap, StatusCode, header};
|
|
use axum::response::IntoResponse;
|
|
use axum::Json;
|
|
use noisebell_common::{validate_bearer, HistoryEntry, WebhookPayload};
|
|
use tokio::sync::Mutex;
|
|
use tracing::{error, info};
|
|
|
|
use crate::db;
|
|
use crate::types::{DoorStatus, WebhookTarget};
|
|
use crate::webhook;
|
|
|
|
static OPEN_PNG: &[u8] = include_bytes!("../assets/open.png");
|
|
static CLOSED_PNG: &[u8] = include_bytes!("../assets/closed.png");
|
|
static OFFLINE_PNG: &[u8] = include_bytes!("../assets/offline.png");
|
|
|
|
pub struct AppState {
|
|
pub db: Arc<Mutex<rusqlite::Connection>>,
|
|
pub client: reqwest::Client,
|
|
pub inbound_api_key: String,
|
|
pub webhooks: Vec<WebhookTarget>,
|
|
pub retry_attempts: u32,
|
|
pub retry_base_delay_secs: u64,
|
|
pub webhook_last_request: std::sync::atomic::AtomicU64,
|
|
pub webhook_tokens: std::sync::atomic::AtomicU32,
|
|
}
|
|
|
|
fn unix_now() -> u64 {
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_secs()
|
|
}
|
|
|
|
const WEBHOOK_RATE_LIMIT: u32 = 10;
|
|
const WEBHOOK_RATE_WINDOW_SECS: u64 = 60;
|
|
|
|
pub async fn post_webhook(
|
|
State(state): State<Arc<AppState>>,
|
|
headers: HeaderMap,
|
|
Json(body): Json<WebhookPayload>,
|
|
) -> StatusCode {
|
|
if !validate_bearer(&headers, &state.inbound_api_key) {
|
|
return StatusCode::UNAUTHORIZED;
|
|
}
|
|
|
|
// Simple rate limiting: reset tokens every window, reject if exhausted
|
|
let now = unix_now();
|
|
let last = state.webhook_last_request.load(std::sync::atomic::Ordering::Relaxed);
|
|
if now.saturating_sub(last) >= WEBHOOK_RATE_WINDOW_SECS {
|
|
state.webhook_tokens.store(WEBHOOK_RATE_LIMIT, std::sync::atomic::Ordering::Relaxed);
|
|
state.webhook_last_request.store(now, std::sync::atomic::Ordering::Relaxed);
|
|
}
|
|
let remaining = state.webhook_tokens.fetch_update(
|
|
std::sync::atomic::Ordering::Relaxed,
|
|
std::sync::atomic::Ordering::Relaxed,
|
|
|n| if n > 0 { Some(n - 1) } else { None },
|
|
);
|
|
if remaining.is_err() {
|
|
return StatusCode::TOO_MANY_REQUESTS;
|
|
}
|
|
|
|
let Some(status) = DoorStatus::from_str(&body.status) else {
|
|
return StatusCode::BAD_REQUEST;
|
|
};
|
|
|
|
let now = unix_now();
|
|
let db = state.db.clone();
|
|
let timestamp = body.timestamp;
|
|
let result = tokio::task::spawn_blocking(move || {
|
|
let conn = db.blocking_lock();
|
|
db::update_state(&conn, status, timestamp, now)
|
|
})
|
|
.await
|
|
.expect("db task panicked");
|
|
|
|
if let Err(e) = result {
|
|
error!(error = %e, "failed to update state from webhook");
|
|
return StatusCode::INTERNAL_SERVER_ERROR;
|
|
}
|
|
|
|
info!(status = status.as_str(), timestamp = body.timestamp, "state updated via webhook");
|
|
|
|
webhook::forward(
|
|
&state.client,
|
|
&state.webhooks,
|
|
&WebhookPayload {
|
|
status: status.as_str().to_string(),
|
|
timestamp: body.timestamp,
|
|
},
|
|
state.retry_attempts,
|
|
state.retry_base_delay_secs,
|
|
)
|
|
.await;
|
|
|
|
StatusCode::OK
|
|
}
|
|
|
|
pub async fn get_status(State(state): State<Arc<AppState>>) -> Result<Json<serde_json::Value>, StatusCode> {
|
|
let db = state.db.clone();
|
|
let status = tokio::task::spawn_blocking(move || {
|
|
let conn = db.blocking_lock();
|
|
db::get_status(&conn)
|
|
})
|
|
.await
|
|
.expect("db task panicked")
|
|
.map_err(|e| {
|
|
error!(error = %e, "failed to get status");
|
|
StatusCode::INTERNAL_SERVER_ERROR
|
|
})?;
|
|
|
|
Ok(Json(serde_json::to_value(status).unwrap()))
|
|
}
|
|
|
|
pub async fn get_info(State(state): State<Arc<AppState>>) -> Result<Json<serde_json::Value>, StatusCode> {
|
|
let db = state.db.clone();
|
|
let info = tokio::task::spawn_blocking(move || {
|
|
let conn = db.blocking_lock();
|
|
db::get_pi_info(&conn)
|
|
})
|
|
.await
|
|
.expect("db task panicked")
|
|
.map_err(|e| {
|
|
error!(error = %e, "failed to get pi info");
|
|
StatusCode::INTERNAL_SERVER_ERROR
|
|
})?;
|
|
|
|
Ok(Json(info))
|
|
}
|
|
|
|
pub async fn health() -> StatusCode {
|
|
StatusCode::OK
|
|
}
|
|
|
|
pub async fn get_history(
|
|
State(state): State<Arc<AppState>>,
|
|
) -> Result<Json<Vec<HistoryEntry>>, StatusCode> {
|
|
let limit = 100u32;
|
|
let db = state.db.clone();
|
|
let entries = tokio::task::spawn_blocking(move || {
|
|
let conn = db.blocking_lock();
|
|
db::get_history(&conn, limit)
|
|
})
|
|
.await
|
|
.expect("db task panicked")
|
|
.map_err(|e| {
|
|
error!(error = %e, "failed to get history");
|
|
StatusCode::INTERNAL_SERVER_ERROR
|
|
})?;
|
|
|
|
Ok(Json(entries))
|
|
}
|
|
|
|
pub async fn get_image_open() -> impl IntoResponse {
|
|
([(header::CONTENT_TYPE, "image/png"), (header::CACHE_CONTROL, "public, max-age=86400")], OPEN_PNG)
|
|
}
|
|
|
|
pub async fn get_image_closed() -> impl IntoResponse {
|
|
([(header::CONTENT_TYPE, "image/png"), (header::CACHE_CONTROL, "public, max-age=86400")], CLOSED_PNG)
|
|
}
|
|
|
|
pub async fn get_image_offline() -> impl IntoResponse {
|
|
([(header::CONTENT_TYPE, "image/png"), (header::CACHE_CONTROL, "public, max-age=86400")], OFFLINE_PNG)
|
|
}
|
|
|
|
pub async fn get_image(State(state): State<Arc<AppState>>) -> impl IntoResponse {
|
|
let db = state.db.clone();
|
|
let status = tokio::task::spawn_blocking(move || {
|
|
let conn = db.blocking_lock();
|
|
db::get_current_status(&conn)
|
|
})
|
|
.await
|
|
.expect("db task panicked")
|
|
.unwrap_or(DoorStatus::Offline);
|
|
|
|
let image = match status {
|
|
DoorStatus::Open => OPEN_PNG,
|
|
DoorStatus::Closed => CLOSED_PNG,
|
|
DoorStatus::Offline => OFFLINE_PNG,
|
|
};
|
|
([(header::CONTENT_TYPE, "image/png"), (header::CACHE_CONTROL, "public, max-age=5")], image)
|
|
}
|
|
|
|
pub async fn get_badge(State(state): State<Arc<AppState>>) -> impl IntoResponse {
|
|
let db = state.db.clone();
|
|
let status = tokio::task::spawn_blocking(move || {
|
|
let conn = db.blocking_lock();
|
|
db::get_current_status(&conn)
|
|
})
|
|
.await
|
|
.expect("db task panicked")
|
|
.unwrap_or(DoorStatus::Offline);
|
|
|
|
let (label, color) = match status {
|
|
DoorStatus::Open => ("open", "#57f287"),
|
|
DoorStatus::Closed => ("closed", "#ed4245"),
|
|
DoorStatus::Offline => ("offline", "#99aab5"),
|
|
};
|
|
|
|
let label_width = 70u32;
|
|
let value_width = 10 + label.len() as u32 * 7;
|
|
let total_width = label_width + value_width;
|
|
let label_x = label_width as f32 / 2.0;
|
|
let value_x = label_width as f32 + value_width as f32 / 2.0;
|
|
|
|
let svg = format!(
|
|
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"{total_width}\" height=\"20\">\
|
|
<linearGradient id=\"s\" x2=\"0\" y2=\"100%\">\
|
|
<stop offset=\"0\" stop-color=\"#bbb\" stop-opacity=\".1\"/>\
|
|
<stop offset=\"1\" stop-opacity=\".1\"/>\
|
|
</linearGradient>\
|
|
<clipPath id=\"r\"><rect width=\"{total_width}\" height=\"20\" rx=\"3\" fill=\"#fff\"/></clipPath>\
|
|
<g clip-path=\"url(#r)\">\
|
|
<rect width=\"{label_width}\" height=\"20\" fill=\"#555\"/>\
|
|
<rect x=\"{label_width}\" width=\"{value_width}\" height=\"20\" fill=\"{color}\"/>\
|
|
<rect width=\"{total_width}\" height=\"20\" fill=\"url(#s)\"/>\
|
|
</g>\
|
|
<g fill=\"#fff\" text-anchor=\"middle\" font-family=\"Verdana,Geneva,sans-serif\" font-size=\"11\">\
|
|
<text x=\"{label_x}\" y=\"15\" fill=\"#010101\" fill-opacity=\".3\">noisebell</text>\
|
|
<text x=\"{label_x}\" y=\"14\">noisebell</text>\
|
|
<text x=\"{value_x}\" y=\"15\" fill=\"#010101\" fill-opacity=\".3\">{label}</text>\
|
|
<text x=\"{value_x}\" y=\"14\">{label}</text>\
|
|
</g></svg>"
|
|
);
|
|
|
|
(
|
|
[
|
|
(header::CONTENT_TYPE, "image/svg+xml"),
|
|
(header::CACHE_CONTROL, "no-cache, max-age=0"),
|
|
],
|
|
svg,
|
|
)
|
|
}
|