Do not use files where no matching files have been found

2021-05-14 15:03:40 +02:00
parent 8dc80f5dba
commit fd80616e24
7 changed files with 166 additions and 23 deletions
--- a/httpret/src/gather.rs
+++ b/httpret/src/gather.rs
@@ -0,0 +1,101 @@
+use crate::response;
+use err::Error;
+use http::{Method, StatusCode};
+use hyper::{Body, Client, Request, Response};
+use serde::{Deserialize, Serialize};
+use serde_json::Value as JsonValue;
+
+#[derive(Clone, Serialize, Deserialize)]
+struct GatherFrom {
+    hosts: Vec<GatherHost>,
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+struct GatherHost {
+    host: String,
+    port: u16,
+    inst: String,
+}
+
+async fn process_answer(res: Response<Body>) -> Result<JsonValue, Error> {
+    let (pre, mut body) = res.into_parts();
+    if pre.status != StatusCode::OK {
+        use hyper::body::HttpBody;
+        if let Some(c) = body.data().await {
+            let c: bytes::Bytes = c?;
+            let s1 = String::from_utf8(c.to_vec())?;
+            Ok(JsonValue::String(format!(
+                "status {}  body {}",
+                pre.status.as_str(),
+                s1
+            )))
+        } else {
+            Ok(JsonValue::String(format!("status {}", pre.status.as_str())))
+        }
+    } else {
+        let body: hyper::Body = body;
+        let body_all = hyper::body::to_bytes(body).await?;
+        let val = match serde_json::from_slice(&body_all) {
+            Ok(k) => k,
+            Err(_e) => JsonValue::String(String::from_utf8(body_all.to_vec())?),
+        };
+        Ok::<_, Error>(val)
+    }
+}
+
+pub async fn gather_json(req: Request<Body>, pathpre: &str) -> Result<Response<Body>, Error> {
+    let (part_head, part_body) = req.into_parts();
+    let bodyslice = hyper::body::to_bytes(part_body).await?;
+    let gather_from: GatherFrom = serde_json::from_slice(&bodyslice)?;
+    let mut spawned = vec![];
+    let uri = part_head.uri;
+    let path_post = &uri.path()[pathpre.len()..];
+    for gh in gather_from.hosts {
+        let uri = format!("http://{}:{}/{}", gh.host, gh.port, path_post);
+        let req = Request::builder().method(Method::GET).uri(uri);
+        let req = if gh.inst.len() > 0 {
+            req.header("retrieval_instance", &gh.inst)
+        } else {
+            req
+        };
+        let req = req.header(http::header::ACCEPT, "application/json");
+        let req = req.body(Body::empty());
+        use futures_util::select;
+        use futures_util::FutureExt;
+        use std::time::Duration;
+        use tokio::time::sleep;
+        let task = tokio::spawn(async move {
+            select! {
+              _ = sleep(Duration::from_millis(1500)).fuse() => {
+                Err(Error::with_msg("timeout"))
+              }
+              res = Client::new().request(req?).fuse() => Ok(process_answer(res?).await?)
+            }
+        });
+        spawned.push((gh.clone(), task));
+    }
+    #[derive(Serialize)]
+    struct Hres {
+        gh: GatherHost,
+        res: JsonValue,
+    }
+    #[derive(Serialize)]
+    struct Jres {
+        hosts: Vec<Hres>,
+    }
+    let mut a = vec![];
+    for tr in spawned {
+        let res = match tr.1.await {
+            Ok(k) => match k {
+                Ok(k) => k,
+                Err(e) => JsonValue::String(format!("ERROR({:?})", e)),
+            },
+            Err(e) => JsonValue::String(format!("ERROR({:?})", e)),
+        };
+        a.push(Hres { gh: tr.0, res });
+    }
+    let res = response(StatusCode::OK)
+        .header(http::header::CONTENT_TYPE, "application/json")
+        .body(serde_json::to_string(&Jres { hosts: a })?.into())?;
+    Ok(res)
+}
--- a/httpret/src/lib.rs
+++ b/httpret/src/lib.rs
@@ -10,6 +10,7 @@ use http::{HeaderMap, Method, StatusCode};
 use hyper::service::{make_service_fn, service_fn};
 use hyper::{server::Server, Body, Request, Response};
 use net::SocketAddr;
+use netpod::log::*;
 use netpod::{ByteSize, Node, NodeConfigCached};
 use panic::{AssertUnwindSafe, UnwindSafe};
 use pin::Pin;
@@ -17,8 +18,8 @@ use serde::{Deserialize, Serialize};
 use std::{future, net, panic, pin, task};
 use task::{Context, Poll};
 use tracing::field::Empty;
-#[allow(unused_imports)]
-use tracing::{debug, error, info, span, trace, warn, Level};
+
+pub mod gather;

 pub async fn host(node_config: NodeConfigCached) -> Result<(), Error> {
    let node_config = node_config.clone();