feat: initial make-space full-stack release with weighted multi-provider LLM and Dockerfile

This commit is contained in:
dahyeon committed 2026-11-04 20:49:24 +09:00
commit 37b323c9ac
55 files changed
+17087

No files matched your search

+244
View File
@@ -0,0 +1,244 @@
mod config;
use std::convert::Infallible;
use std::time::Duration;
use axum::extract::{Path, State};
use axum::http::{header, StatusCode};
use axum::response::sse::{Event, KeepAlive, Sse};
use axum::response::{IntoResponse, Response};
use axum::routing::get;
use axum::Router;
use domain::JobEvent;
use futures::stream::{self, StreamExt};
use leptos::config::get_configuration;
use leptos::prelude::provide_context;
use leptos_axum::{generate_route_list, LeptosRoutes};
use pipeline::Pipeline;
use tokio_stream::wrappers::BroadcastStream;
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let _ = dotenvy::dotenv();
tracing_subscriber::fmt()
.with_env_filter(
tracing_subscriber::EnvFilter::try_from_default_env()
.unwrap_or_else(|_| "info,server=debug,pipeline=debug,providers=debug".into()),
)
.init();
let pipeline = config::init_pipeline_from_env().await?;
let conf = get_configuration(None)?;
let leptos_options = conf.leptos_options;
let addr = leptos_options.site_addr;
let routes = generate_route_list(app::App);
let pipe_for_ctx = pipeline.clone();
let app_router = Router::new()
.route("/health/live", get(health_live))
.route("/health/ready", get(health_check))
.route("/api/health", get(health_check))
.route("/api/jobs/{id}/events", get(job_events_sse))
.route("/api/photos/{id}", get(serve_photo))
.with_state(pipeline)
.leptos_routes_with_context(
&leptos_options,
routes,
move || {
provide_context(pipe_for_ctx.clone());
},
{
let opts = leptos_options.clone();
move || app::shell(opts.clone())
},
)
.fallback(leptos_axum::file_and_error_handler(app::shell))
.with_state(leptos_options);
tracing::info!("listening on http://{addr}");
let listener = tokio::net::TcpListener::bind(&addr).await?;
axum::serve(listener, app_router.into_make_service()).await?;
Ok(())
}
async fn job_events_sse(
State(pipeline): State<Pipeline>,
Path(job_id): Path<String>,
) -> Sse<impl futures::Stream<Item = Result<Event, Infallible>>> {
let (past, rx_opt) = prepare_job_subscription(pipeline.subscribe_job(&job_id).await);
let already_done = past.iter().any(|e| e.is_terminal());
let past_stream = stream::iter(past).map(|ev| {
let json = serde_json::to_string(&ev).unwrap_or_default();
Ok::<_, Infallible>(Event::default().data(json))
});
let live_stream = match rx_opt {
Some(rx) if !already_done => BroadcastStream::new(rx)
.filter_map(|item| async move { item.ok() })
.map(|ev| {
let done = ev.is_terminal();
let json = serde_json::to_string(&ev).unwrap_or_default();
(done, Ok::<_, Infallible>(Event::default().data(json)))
})
.scan(false, |finished, (done, ev)| {
let emit = if *finished { None } else { Some(ev) };
if done {
*finished = true;
}
futures::future::ready(emit)
})
.left_stream(),
_ => stream::empty().right_stream(),
};
Sse::new(past_stream.chain(live_stream)).keep_alive(
KeepAlive::new()
.interval(Duration::from_secs(10))
.text("keep-alive"),
)
}
type JobSubscription = (
Vec<JobEvent>,
Option<tokio::sync::broadcast::Receiver<JobEvent>>,
);
fn prepare_job_subscription(subscription: anyhow::Result<JobSubscription>) -> JobSubscription {
let (mut past, receiver) = match subscription {
Ok(subscription) => subscription,
Err(error) => {
tracing::warn!(%error, "could not subscribe to analysis job");
return (
vec![JobEvent::Error {
message: "분석 진행 상태를 불러오지 못했습니다. 잠시 후 다시 시도해 주세요."
.into(),
}],
None,
);
}
};
// A stored job may outlive its process. Replaying only its nonterminal history
// would make EventSource reconnect forever, resetting the client's retry counter.
if receiver.is_none() && !past.iter().any(JobEvent::is_terminal) {
let message = if past.is_empty() {
"분석 작업을 찾을 수 없습니다. 장소에서 분석을 다시 시작해 주세요."
} else {
"분석 작업이 중단됐습니다. 장소에서 분석을 다시 시작해 주세요."
};
past.push(JobEvent::Error {
message: message.into(),
});
}
(past, receiver)
}
async fn health_live() -> Response {
(
StatusCode::OK,
[(header::CONTENT_TYPE, "application/json")],
r#"{"status":"ok"}"#,
)
.into_response()
}
async fn health_check(State(pipeline): State<Pipeline>) -> Response {
let storage_ok = pipeline.store.health_check().await.is_ok();
let llm_providers = pipeline.llm.health_check_all().await;
let any_llm_healthy = llm_providers.iter().any(|p| p.healthy);
let status = if storage_ok && any_llm_healthy {
StatusCode::OK
} else {
StatusCode::SERVICE_UNAVAILABLE
};
let body = serde_json::json!({
"status": if status == StatusCode::OK { "ok" } else { "degraded" },
"storage_healthy": storage_ok,
"llm_providers": llm_providers,
});
(
status,
[(header::CONTENT_TYPE, "application/json")],
body.to_string(),
)
.into_response()
}
async fn serve_photo(State(pipeline): State<Pipeline>, Path(photo_id): Path<String>) -> Response {
let Ok(Some(photo)) = pipeline.store.get_photo(&photo_id).await else {
return StatusCode::NOT_FOUND.into_response();
};
match pipeline.store.get_blob(&photo.object_key).await {
Ok(bytes) => (
StatusCode::OK,
[
(header::CONTENT_TYPE, "image/jpeg"),
(header::CACHE_CONTROL, "public, max-age=86400"),
],
bytes,
)
.into_response(),
Err(_) => StatusCode::NOT_FOUND.into_response(),
}
}
#[cfg(test)]
mod job_events_tests {
use super::*;
#[test]
fn missing_job_returns_a_terminal_error() {
let (events, receiver) = prepare_job_subscription(Ok((Vec::new(), None)));
assert!(receiver.is_none());
assert_eq!(events.len(), 1);
assert!(
matches!(&events[0], JobEvent::Error { message } if message.contains("찾을 수 없습니다"))
);
}
#[test]
fn interrupted_job_keeps_history_then_terminates() {
let past = vec![
JobEvent::Started {
place_id: "place-1".into(),
},
JobEvent::LayoutDraft { attempt: 1 },
];
let (events, receiver) = prepare_job_subscription(Ok((past, None)));
assert!(receiver.is_none());
assert_eq!(events.len(), 3);
assert!(matches!(events[0], JobEvent::Started { .. }));
assert!(matches!(events[1], JobEvent::LayoutDraft { .. }));
assert!(matches!(&events[2], JobEvent::Error { message } if message.contains("중단")));
}
#[test]
fn subscription_failure_returns_a_user_facing_terminal_error() {
let (events, receiver) =
prepare_job_subscription(Err(anyhow::anyhow!("private storage error")));
assert!(receiver.is_none());
assert_eq!(events.len(), 1);
assert!(matches!(&events[0], JobEvent::Error { message } if !message.contains("private")));
}
#[test]
fn live_job_and_finished_job_are_not_marked_as_interrupted() {
let (_sender, receiver) = tokio::sync::broadcast::channel(2);
let (events, receiver) = prepare_job_subscription(Ok((Vec::new(), Some(receiver))));
assert!(events.is_empty());
assert!(receiver.is_some());
for terminal in [
JobEvent::Done {
place_id: "place-1".into(),
},
JobEvent::Error {
message: "analysis failed".into(),
},
] {
let (events, receiver) = prepare_job_subscription(Ok((vec![terminal], None)));
assert!(receiver.is_none());
assert_eq!(events.len(), 1);
assert!(events[0].is_terminal());
}
}
}