Dominik Werder
113 lines
3.9 KiB
Rust
113 lines
3.9 KiB
Rust
pub mod reqstatus;
|
|
|
|
use crate::bodystream::response;
|
|
use crate::err::Error;
|
|
use crate::ReqCtx;
|
|
use http::header;
|
|
use http::HeaderValue;
|
|
use http::Method;
|
|
use http::Request;
|
|
use http::StatusCode;
|
|
use http::Uri;
|
|
use httpclient::body_bytes;
|
|
use httpclient::body_empty;
|
|
use httpclient::body_stream;
|
|
use httpclient::connect_client;
|
|
use httpclient::read_body_bytes;
|
|
use httpclient::Requ;
|
|
use httpclient::StreamIncoming;
|
|
use httpclient::StreamResponse;
|
|
use netpod::log::*;
|
|
use netpod::query::api1::Api1Query;
|
|
use netpod::ProxyConfig;
|
|
use netpod::ACCEPT_ALL;
|
|
use netpod::X_DAQBUF_REQID;
|
|
|
|
pub struct PythonDataApi1Query {}
|
|
|
|
impl PythonDataApi1Query {
|
|
pub fn path() -> &'static str {
|
|
"/api/1/query"
|
|
}
|
|
|
|
pub fn handler(req: &Requ) -> Option<Self> {
|
|
if req.uri().path() == Self::path() {
|
|
Some(Self {})
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
pub async fn handle(&self, req: Requ, ctx: &ReqCtx, proxy_config: &ProxyConfig) -> Result<StreamResponse, Error> {
|
|
if req.method() != Method::POST {
|
|
return Ok(response(StatusCode::METHOD_NOT_ALLOWED).body(body_empty())?);
|
|
}
|
|
let (head, body) = req.into_parts();
|
|
let _accept = head
|
|
.headers
|
|
.get(http::header::ACCEPT)
|
|
.map_or(Ok(ACCEPT_ALL), |k| k.to_str())
|
|
.map_err(|e| Error::with_msg_no_trace(format!("{e:?}")))?
|
|
.to_owned();
|
|
let body_data = read_body_bytes(body).await?;
|
|
let qu = match serde_json::from_slice::<Api1Query>(&body_data) {
|
|
Ok(qu) => qu,
|
|
Err(e) => {
|
|
let buf = &body_data[..body_data.len().min(200)];
|
|
error!("got body_data: {:?}", String::from_utf8_lossy(buf));
|
|
error!("can not parse: {e}");
|
|
return Err(Error::with_msg_no_trace("can not parse query"));
|
|
}
|
|
};
|
|
info!("{qu:?}");
|
|
let back = {
|
|
let mut ret = None;
|
|
for b in &proxy_config.backends {
|
|
if b.name == "sf-databuffer" {
|
|
ret = Some(b);
|
|
break;
|
|
}
|
|
}
|
|
ret
|
|
};
|
|
if let Some(back) = back {
|
|
// TODO remove special code, make it part of configuration
|
|
let back = if back.url.contains("sf-daqbuf-23.psi.ch") {
|
|
let id = 21 + rand::random::<u32>() % 13;
|
|
let url = back.url.replace("-23.", &format!("-{id}."));
|
|
netpod::ProxyBackend {
|
|
name: back.name.clone(),
|
|
url,
|
|
}
|
|
} else {
|
|
back.clone()
|
|
};
|
|
let url_str = format!("{}/api/1/query", back.url);
|
|
info!("try to ask {url_str}");
|
|
let uri: Uri = url_str.parse()?;
|
|
let req = Request::builder()
|
|
.method(Method::POST)
|
|
.header(header::HOST, uri.host().unwrap())
|
|
.header(ctx.header_name(), ctx.header_value())
|
|
.uri(&uri)
|
|
.body(body_bytes(body_data))?;
|
|
let mut client = connect_client(&uri).await?;
|
|
let res = client.send_request(req).await?;
|
|
let (head, body) = res.into_parts();
|
|
if head.status != StatusCode::OK {
|
|
error!("backend returned error: {head:?}");
|
|
Ok(response(StatusCode::INTERNAL_SERVER_ERROR).body(body_empty())?)
|
|
} else {
|
|
info!("backend returned OK");
|
|
let riq_def = HeaderValue::from_static("none");
|
|
let riq = head.headers.get(X_DAQBUF_REQID).unwrap_or(&riq_def);
|
|
Ok(response(StatusCode::OK)
|
|
.header(X_DAQBUF_REQID, riq)
|
|
.body(body_stream(StreamIncoming::new(body)))?)
|
|
}
|
|
} else {
|
|
Ok(response(StatusCode::INTERNAL_SERVER_ERROR).body(body_empty())?)
|
|
}
|
|
}
|
|
}
|