Skip to main content

qualia_solid_bridge/
solid_proxy.rs

1//! Solid bridge HTTP daemon — personal pod server + optional demo OIDC.
2
3use crate::ldp_translator::{ldp_routes, pod_ldp_routes};
4use crate::pod_store::PodStore;
5use std::net::SocketAddr;
6use std::path::PathBuf;
7use std::sync::Arc;
8use warp::Filter;
9
10/// Runtime configuration for the personal Solid pod / bridge.
11#[derive(Debug, Clone)]
12pub struct BridgeConfig {
13    pub listen: SocketAddr,
14    /// Filesystem root for LDP resources.
15    pub data_root: PathBuf,
16    /// Public base URL advertised in WebID / OIDC discovery (no trailing slash).
17    pub public_base: String,
18    /// Mount demo Solid-OIDC-shaped routes (local hackathon / SolidOS smoke only).
19    pub demo_oidc: bool,
20}
21
22impl Default for BridgeConfig {
23    fn default() -> Self {
24        let data_root = std::env::var("QUALIA_SOLID_POD_ROOT")
25            .map(PathBuf::from)
26            .unwrap_or_else(|_| dirs_next_fallback());
27        let host = std::env::var("QUALIA_SOLID_HOST").unwrap_or_else(|_| "127.0.0.1".into());
28        let port: u16 = std::env::var("QUALIA_SOLID_PORT")
29            .ok()
30            .and_then(|s| s.parse().ok())
31            .unwrap_or(4243);
32        let public_base = std::env::var("QUALIA_SOLID_PUBLIC_BASE")
33            .unwrap_or_else(|_| format!("http://{host}:{port}"));
34        let demo_oidc = matches!(
35            std::env::var("QUALIA_SOLID_DEMO_OIDC").ok().as_deref(),
36            Some("1") | Some("true") | Some("yes")
37        ) || cfg!(feature = "demo");
38        Self {
39            listen: SocketAddr::new(
40                host.parse().unwrap_or_else(|_| ([127, 0, 0, 1]).into()),
41                port,
42            ),
43            data_root,
44            public_base,
45            demo_oidc,
46        }
47    }
48}
49
50fn dirs_next_fallback() -> PathBuf {
51    // Avoid extra dep: use TEMP or CWD/solid-pod
52    std::env::temp_dir().join("qualia-solid-pod")
53}
54
55/// Type-erased filter so demo/non-demo trees share one return type.
56type DynRoutes = warp::filters::BoxedFilter<(Box<dyn warp::Reply + Send>,)>;
57
58fn box_reply<F, R>(f: F) -> DynRoutes
59where
60    F: Filter<Extract = (R,), Error = warp::Rejection> + Clone + Send + Sync + 'static,
61    R: warp::Reply + Send + 'static,
62{
63    f.map(|r: R| -> Box<dyn warp::Reply + Send> { Box::new(r) })
64        .boxed()
65}
66
67/// Compose routes for a config (used by tests + daemon).
68pub fn bridge_routes_for(cfg: &BridgeConfig) -> DynRoutes {
69    let store = Arc::new(PodStore::new(cfg.data_root.clone()));
70    let _ = store.ensure_defaults(&cfg.public_base);
71    let demo = cfg.demo_oidc || cfg!(feature = "demo");
72
73    let pod = pod_ldp_routes(store, cfg.public_base.clone());
74
75    // Health / identity banner
76    let banner = warp::path!(".well-known" / "qualia-solid-bridge")
77        .and(warp::get())
78        .map(move || {
79            warp::reply::json(&serde_json::json!({
80                "service": "qualia-solid-bridge",
81                "role": ["personal-pod", "ldp-resource-server", "solid-consumer-library"],
82                "demo_oidc": demo,
83                "note": "Demo OIDC is not a production identity root (NON_GOALS.md)"
84            }))
85        });
86
87    if demo {
88        let oidc = crate::oidc_micro_idp::oidc_routes(cfg.public_base.clone());
89        box_reply(oidc.or(banner).or(pod))
90    } else {
91        // Keep legacy simulated /public/<name> routes for unit tests + fallback.
92        box_reply(banner.or(pod).or(ldp_routes()))
93    }
94}
95
96/// Default routes (unit tests / legacy).
97pub fn bridge_routes() -> DynRoutes {
98    bridge_routes_for(&BridgeConfig::default())
99}
100
101/// Starts the Solid Bridge Proxy Daemon (blocking).
102///
103/// Implements the "Tokio Perimeter Firewall" as mandated by the Qualia Core.
104/// - Tokio is restricted to a single thread.
105/// - The thread is pinned natively to Core 3 when available (I/O & Parity loop).
106pub fn start_proxy_daemon() {
107    start_proxy_daemon_with(BridgeConfig::default());
108}
109
110/// Starts the proxy daemon with config.
111pub fn start_proxy_daemon_with(cfg: BridgeConfig) {
112    let rt = tokio::runtime::Builder::new_current_thread()
113        .enable_all()
114        .build()
115        .expect("Failed to initialize Tokio Single-Threaded Firewall");
116
117    let core_ids = core_affinity::get_core_ids().unwrap_or_default();
118    if core_ids.len() > 3 {
119        core_affinity::set_for_current(core_ids[3]);
120        println!("Webizen Proxy Daemon pinned to CPU Core 3.");
121    } else {
122        println!("System has < 4 cores. Tokio not pinned to Core 3.");
123    }
124
125    rt.block_on(run_bridge(cfg));
126}
127
128/// Async entry (for CLI already inside a tokio runtime).
129pub async fn run_bridge(cfg: BridgeConfig) {
130    let store = PodStore::new(&cfg.data_root);
131    if let Err(e) = store.ensure_defaults(&cfg.public_base) {
132        eprintln!("solid-bridge: failed to init pod root: {e}");
133    }
134
135    let cors = warp::cors()
136        .allow_any_origin()
137        .allow_headers(vec![
138            "Authorization",
139            "Content-Type",
140            "Accept",
141            "Slug",
142            "Link",
143            "DPoP",
144        ])
145        .allow_methods(vec![
146            "GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "PATCH",
147        ]);
148
149    let api = bridge_routes_for(&cfg).with(cors);
150
151    println!("============================================================");
152    println!(" Qualia Solid Bridge — personal pod + LDP resource server");
153    println!(" listen     : http://{}", cfg.listen);
154    println!(" public_base: {}", cfg.public_base);
155    println!(" data_root  : {}", cfg.data_root.display());
156    println!(
157        " demo_oidc  : {} {}",
158        cfg.demo_oidc || cfg!(feature = "demo"),
159        if cfg.demo_oidc || cfg!(feature = "demo") {
160            "(DEMO ONLY — not production identity)"
161        } else {
162            "(off; set QUALIA_SOLID_DEMO_OIDC=1)"
163        }
164    );
165    println!(" profile    : {}/profile/card#me", cfg.public_base);
166    println!("============================================================");
167
168    warp::serve(api).run(cfg.listen).await;
169}
170
171#[cfg(test)]
172mod tests {
173    use super::*;
174    use warp::http::StatusCode;
175
176    #[tokio::test]
177    async fn ldp_and_profile_available() {
178        let dir = std::env::temp_dir().join(format!("solid-bridge-test-{}", std::process::id()));
179        let _ = std::fs::remove_dir_all(&dir);
180        let cfg = BridgeConfig {
181            listen: "127.0.0.1:0".parse().unwrap(),
182            data_root: dir.clone(),
183            public_base: "http://127.0.0.1:4243".into(),
184            demo_oidc: false,
185        };
186        let routes = bridge_routes_for(&cfg);
187
188        let response = warp::test::request()
189            .method("GET")
190            .path("/profile/card")
191            .reply(&routes)
192            .await;
193        assert_eq!(response.status(), StatusCode::OK);
194        assert!(response.headers().get("content-type").is_some());
195        let body = String::from_utf8_lossy(response.body());
196        assert!(body.contains("foaf:Person") || body.contains("oidcIssuer"));
197
198        let put = warp::test::request()
199            .method("PUT")
200            .path("/public/hackathon.ttl")
201            .body("<urn:inst:1> <urn:pred:deposit> <urn:citizen:1> .")
202            .reply(&routes)
203            .await;
204        assert!(
205            put.status() == StatusCode::CREATED || put.status() == StatusCode::OK,
206            "put status {}",
207            put.status()
208        );
209
210        let get = warp::test::request()
211            .method("GET")
212            .path("/public/hackathon.ttl")
213            .reply(&routes)
214            .await;
215        assert_eq!(get.status(), StatusCode::OK);
216        assert!(String::from_utf8_lossy(get.body()).contains("urn:inst:1"));
217
218        let _ = std::fs::remove_dir_all(&dir);
219    }
220
221    #[cfg(not(feature = "demo"))]
222    #[tokio::test]
223    async fn oidc_off_by_default_without_flag() {
224        let dir = std::env::temp_dir().join(format!("solid-bridge-oidc-{}", std::process::id()));
225        let _ = std::fs::remove_dir_all(&dir);
226        let cfg = BridgeConfig {
227            listen: "127.0.0.1:0".parse().unwrap(),
228            data_root: dir.clone(),
229            public_base: "http://127.0.0.1:4243".into(),
230            demo_oidc: false,
231        };
232        let response = warp::test::request()
233            .method("GET")
234            .path("/.well-known/openid-configuration")
235            .reply(&bridge_routes_for(&cfg))
236            .await;
237        // May 404 when demo off
238        assert!(
239            response.status() == StatusCode::NOT_FOUND
240                || response.status() == StatusCode::METHOD_NOT_ALLOWED
241                || response.status() == StatusCode::OK // if something else matches
242        );
243        let _ = std::fs::remove_dir_all(&dir);
244    }
245
246    #[tokio::test]
247    async fn demo_oidc_discovery_when_enabled() {
248        let dir = std::env::temp_dir().join(format!("solid-bridge-demo-{}", std::process::id()));
249        let _ = std::fs::remove_dir_all(&dir);
250        let cfg = BridgeConfig {
251            listen: "127.0.0.1:0".parse().unwrap(),
252            data_root: dir.clone(),
253            public_base: "http://127.0.0.1:4243".into(),
254            demo_oidc: true,
255        };
256        let response = warp::test::request()
257            .method("GET")
258            .path("/.well-known/openid-configuration")
259            .reply(&bridge_routes_for(&cfg))
260            .await;
261        assert_eq!(response.status(), StatusCode::OK);
262        let body = String::from_utf8_lossy(response.body());
263        assert!(body.contains("authorization_endpoint"));
264        let _ = std::fs::remove_dir_all(&dir);
265    }
266}