qualia_solid_bridge/
solid_proxy.rs1use 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#[derive(Debug, Clone)]
12pub struct BridgeConfig {
13 pub listen: SocketAddr,
14 pub data_root: PathBuf,
16 pub public_base: String,
18 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 std::env::temp_dir().join("qualia-solid-pod")
53}
54
55type 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
67pub 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 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 box_reply(banner.or(pod).or(ldp_routes()))
93 }
94}
95
96pub fn bridge_routes() -> DynRoutes {
98 bridge_routes_for(&BridgeConfig::default())
99}
100
101pub fn start_proxy_daemon() {
107 start_proxy_daemon_with(BridgeConfig::default());
108}
109
110pub 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
128pub 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 assert!(
239 response.status() == StatusCode::NOT_FOUND
240 || response.status() == StatusCode::METHOD_NOT_ALLOWED
241 || response.status() == StatusCode::OK );
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}