wip:milestone 0 fixes

gateway/src/control.rs

@@ -0,0 +1,130 @@
+### /Users/vlad/Developer/madapes/madbase/gateway/src/control.rs
+```rust
+1: use axum::{
+2:     extract::{Request, Query},
+3:     middleware::{from_fn, Next},
+4:     response::{Response, IntoResponse},
+5:     routing::get,
+6:     Router,
+7: };
+8: use axum::http::StatusCode;
+9: use axum_prometheus::PrometheusMetricLayer;
+10: use common::{init_pool, Config};
+11: use sqlx::PgPool;
+12: use crate::admin_auth::admin_auth_middleware;
+13: use std::collections::HashMap;
+14: use std::net::SocketAddr;
+15: use std::time::Duration;
+16: use tower_http::services::ServeDir;
+17: use tower_http::cors::{AllowOrigin, CorsLayer};
+use axum::http::{HeaderMap, HeaderValue, Method};
+use axum::http::header;
+18: use tower_http::trace::TraceLayer;
+19: 
+20: async fn logs_proxy_handler(
+21:     Query(params): Query<HashMap<String, String>>,
+22: ) -> impl IntoResponse {
+23:     let client = reqwest::Client::new();
+24:     let loki_url = std::env::var("LOKI_URL")
+25:         .unwrap_or_else(|_| "http://loki:3100".to_string());
+26:     let query_url = format!("{}/loki/api/v1/query_range", loki_url);
+27:     
+28:     let resp = client
+29:         .get(&query_url)
+30:         .query(&params)
+31:         .send()
+32:         .await;
+33:         
+34:     match resp {
+35:         Ok(r) => {
+36:             let status = StatusCode::from_u16(r.status().as_u16())
+37:                 .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
+38:             let body = r.bytes().await.unwrap_or_default();
+39:             (status, body).into_response()
+40:         },
+41:         Err(e) => {
+42:             tracing::error!("Loki proxy error: {}", e);
+43:             (StatusCode::BAD_GATEWAY, e.to_string()).into_response()
+44:         }
+45:     }
+46: }
+47: 
+48: async fn dashboard_handler() -> axum::response::Html<&'static str> {
+49:     axum::response::Html(include_str!("../../web/admin.html"))
+50: }
+51: 
+52: async fn wait_for_db(db_url: &str) -> PgPool {
+53:     loop {
+54:         match init_pool(db_url).await {
+55:             Ok(pool) => return pool,
+56:             Err(e) => {
+57:                 tracing::warn!("Database not ready yet, retrying in 2s: {}", e);
+58:                 tokio::time::sleep(Duration::from_secs(2)).await;
+59:             }
+60:         }
+61:     }
+62: }
+63: 
+64: async fn log_headers(req: Request, next: Next) -> Response {
+65:     tracing::debug!("Request Headers: {:?}", req.headers());
+66:     next.run(req).await
+67: }
+68: 
+69: pub async fn run() -> anyhow::Result<()> {
+70:     let config = Config::new().expect("Failed to load configuration");
+71: 
+72:     tracing::info!("Starting MadBase Control Plane...");
+73: 
+74:     let pool = wait_for_db(&config.database_url).await;
+75:     
+76:     sqlx::migrate!("../migrations")
+77:         .run(&pool)
+78:         .await
+79:         .expect("Failed to run migrations");
+80: 
+81:     let default_tenant_db_url = std::env::var("DEFAULT_TENANT_DB_URL")
+82:         .expect("DEFAULT_TENANT_DB_URL must be set");
+83:     let tenant_pool = wait_for_db(&default_tenant_db_url).await;
+84: 
+85:     let control_state = control_plane::ControlPlaneState {
+86:         db: pool.clone(),
+87:         tenant_db: tenant_pool.clone(),
+88:     };
+89: 
+90:     let (prometheus_layer, metric_handle) = PrometheusMetricLayer::pair();
+91: 
+92:     let platform_router = control_plane::router(control_state)
+93:         .route("/logs", get(logs_proxy_handler));
+94: 
+95:     let app = Router::new()
+96:         .route("/", get(|| async { "MadBase Control Plane" }))
+97:         .route("/health", get(|| async { "OK" }))
+98:         .route("/metrics", get(|| async move { metric_handle.render() }))
+99:         .route("/dashboard", get(dashboard_handler))
+100:         .nest_service("/css", ServeDir::new("web/css"))
+101:         .nest_service("/js", ServeDir::new("web/js"))
+102:         .nest("/platform/v1", platform_router)
+103:         .layer(from_fn(admin_auth_middleware))
+104:         .layer(
+105:             CorsLayer::new()
+106:                 .allow_origin(Any)
+107:                 .allow_methods(Any)
+108:                 .allow_headers(Any),
+109:         )
+110:         .layer(TraceLayer::new_for_http())
+111:         .layer(from_fn(log_headers))
+112:         .layer(prometheus_layer);
+113: 
+114:     let port = std::env::var("CONTROL_PORT")
+115:         .unwrap_or_else(|_| "8001".to_string())
+116:         .parse::<u16>()?;
+117:     
+118:     let addr = SocketAddr::from(([0, 0, 0, 0], port));
+119:     tracing::info!("Control plane listening on {}", addr);
+120: 
+121:     let listener = tokio::net::TcpListener::bind(addr).await?;
+122:     axum::serve(listener, app.into_make_service_with_connect_info::<SocketAddr>()).await?;
+123: 
+124:     Ok(())
+125: }
+```