feat(http): implement forward extension type logic

Author: mmalenic

htsget-config/src/config/advanced/auth/mod.rs

@@ -415,19 +415,15 @@ mod tests {
       config.authorization_url().unwrap(),
       &UrlOrStatic::Url("https://www.example.com".parse::<Uri>().unwrap())
     );
-    assert!(
-      config.passthrough_auth()
-    );
-    assert_eq!(
-      config.forward_headers(),
-      ["header".to_string()]
-    );
-    assert!(
-      config.forward_endpoint_type()
-    );
+    assert!(config.passthrough_auth());
+    assert_eq!(config.forward_headers(), ["header".to_string()]);
+    assert!(config.forward_endpoint_type());
     assert_eq!(
       config.forward_extensions(),
-      [ForwardExtensions::new("$.extension".to_string(), "Extension".to_string())]
+      [ForwardExtensions::new(
+        "$.extension".to_string(),
+        "Extension".to_string()
+      )]
     );
   }
 

htsget-http/src/error.rs

@@ -1,4 +1,5 @@
 use http::StatusCode;
+use http::header::{InvalidHeaderName, InvalidHeaderValue};
 use serde::Serialize;
 use thiserror::Error;
 
@@ -84,3 +85,15 @@ impl From<HtsGetSearchError> for HtsGetError {
     }
   }
 }
+
+impl From<InvalidHeaderName> for HtsGetError {
+  fn from(err: InvalidHeaderName) -> Self {
+    Self::InternalError(err.to_string())
+  }
+}
+
+impl From<InvalidHeaderValue> for HtsGetError {
+  fn from(err: InvalidHeaderValue) -> Self {
+    Self::InternalError(err.to_string())
+  }
+}

htsget-http/src/http_core.rs

@@ -37,10 +37,11 @@ async fn authorize(
   queries: &mut [Query],
   auth: Option<(TokenData<Value>, Auth)>,
   extensions: Option<Value>,
+  endpoint: &Endpoint,
 ) -> Result<Option<AuthorizationRestrictions>> {
   if let Some((_, mut auth)) = auth {
     let _rules = auth
-      .validate_authorization(headers, path, queries, extensions)
+      .validate_authorization(headers, path, queries, extensions, endpoint)
       .await?;
     cfg_if! {
       if #[cfg(feature = "experimental")] {
@@ -77,7 +78,15 @@ pub async fn get(
 
   let format = match_format_from_query(&endpoint, request.query())?;
   let mut query = vec![convert_to_query(request, format)?];
-  let rules = authorize(&headers, &path, query.as_mut_slice(), auth, extensions).await?;
+  let rules = authorize(
+    &headers,
+    &path,
+    query.as_mut_slice(),
+    auth,
+    extensions,
+    &endpoint,
+  )
+  .await?;
 
   debug!(endpoint = ?endpoint, query = ?query, "getting GET response");
 
@@ -137,7 +146,15 @@ pub async fn post(
   }
 
   let mut queries = body.get_queries(request, &endpoint)?;
-  let rules = authorize(&headers, &path, queries.as_mut_slice(), auth, extensions).await?;
+  let rules = authorize(
+    &headers,
+    &path,
+    queries.as_mut_slice(),
+    auth,
+    extensions,
+    &endpoint,
+  )
+  .await?;
 
   debug!(endpoint = ?endpoint, queries = ?queries, "getting POST response");
 

htsget-http/src/lib.rs

@@ -9,8 +9,9 @@ use query_builder::QueryBuilder;
 pub use service_info::get_service_info_json;
 pub use service_info::{Htsget, ServiceInfo, Type};
 use std::collections::HashMap;
-use std::result;
+use std::fmt::{Display, Formatter};
 use std::str::FromStr;
+use std::{fmt, result};
 
 pub mod error;
 pub mod http_core;
@@ -39,6 +40,15 @@ impl FromStr for Endpoint {
   }
 }
 
+impl Display for Endpoint {
+  fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    match self {
+      Self::Reads => write!(f, "reads"),
+      Self::Variants => write!(f, "variants"),
+    }
+  }
+}
+
 /// Match the format from a query parameter.
 pub fn match_format_from_query(
   endpoint: &Endpoint,

htsget-http/src/middleware/auth.rs

@@ -1,10 +1,10 @@
 //! The htsget authorization middleware.
 //!
 
-use crate::HtsGetError;
 use crate::error::Result as HtsGetResult;
 use crate::middleware::error::Error::AuthBuilderError;
 use crate::middleware::error::Result;
+use crate::{Endpoint, HtsGetError};
 use cfg_if::cfg_if;
 use headers::authorization::Bearer;
 use headers::{Authorization, Header};
@@ -72,6 +72,7 @@ impl Debug for Auth {
 }
 
 const FORWARD_HEADER_PREFIX: &str = "Htsget-Context-";
+const ENDPOINT_TYPE_NAME: &str = "Endpoint-Type";
 
 impl Auth {
   /// Get the config for this auth layer instance.
@@ -134,6 +135,7 @@ impl Auth {
     &self,
     request_headers: &HeaderMap,
     request_extensions: Option<Value>,
+    request_endpoint: &Endpoint,
   ) -> HtsGetResult<HeaderMap> {
     let mut forwarded_headers = if self.config.passthrough_auth() {
       let auth_header = request_headers
@@ -186,14 +188,20 @@ impl Auth {
         })?;
 
         let header_name =
-          HeaderName::from_str(&format!("{}{}", FORWARD_HEADER_PREFIX, extension.name()))
-            .map_err(|err| HtsGetError::InternalError(err.to_string()))?;
-        let value = HeaderValue::from_str(value)
-          .map_err(|err| HtsGetError::InternalError(err.to_string()))?;
+          HeaderName::from_str(&format!("{}{}", FORWARD_HEADER_PREFIX, extension.name()))?;
+        let value = HeaderValue::from_str(value)?;
         forwarded_headers.insert(header_name, value);
       }
     }
 
+    if self.config.forward_endpoint_type() {
+      let header_name =
+        HeaderName::from_str(&format!("{}{}", FORWARD_HEADER_PREFIX, ENDPOINT_TYPE_NAME))?;
+      let value = HeaderValue::from_str(&request_endpoint.to_string())?;
+
+      forwarded_headers.insert(header_name, value);
+    }
+
     Ok(forwarded_headers)
   }
 
@@ -204,10 +212,12 @@ impl Auth {
     &mut self,
     headers: &HeaderMap,
     request_extensions: Option<Value>,
+    request_endpoint: &Endpoint,
   ) -> HtsGetResult<Option<AuthorizationRestrictions>> {
     match self.config.authorization_url() {
       Some(UrlOrStatic::Url(uri)) => {
-        let forwarded_headers = self.forwarded_headers(headers, request_extensions)?;
+        let forwarded_headers =
+          self.forwarded_headers(headers, request_extensions, request_endpoint)?;
 
         self
           .fetch_from_url(&uri.to_string(), forwarded_headers)
@@ -408,9 +418,10 @@ impl Auth {
     path: &str,
     queries: &mut [Query],
     request_extensions: Option<Value>,
+    endpoint: &Endpoint,
   ) -> HtsGetResult<Option<AuthorizationRestrictions>> {
     let restrictions = self
-      .query_authorization_service(headers, request_extensions)
+      .query_authorization_service(headers, request_extensions, endpoint)
       .await?;
 
     if let Some(restrictions) = restrictions {
@@ -601,7 +612,9 @@ mod tests {
       ("Custom1".parse().unwrap(), "Value".parse().unwrap()),
       ("Custom2".parse().unwrap(), "Value".parse().unwrap()),
     ]);
-    let forwarded_headers = result.forwarded_headers(&request_headers, None).unwrap();
+    let forwarded_headers = result
+      .forwarded_headers(&request_headers, None, &Endpoint::Reads)
+      .unwrap();
     assert_eq!(
       forwarded_headers,
       HeaderMap::from_iter([
@@ -624,7 +637,9 @@ mod tests {
       .unwrap();
     let result = AuthBuilder::default().with_config(config).build().unwrap();
 
-    let forwarded_headers = result.forwarded_headers(&request_headers, None).unwrap();
+    let forwarded_headers = result
+      .forwarded_headers(&request_headers, None, &Endpoint::Reads)
+      .unwrap();
     assert_eq!(
       forwarded_headers,
       HeaderMap::from_iter([
@@ -648,12 +663,13 @@ mod tests {
     let config = builder
       .clone()
       .forward_headers(vec!["Custom1".to_string()])
-      .passthrough_auth(false)
       .build()
       .unwrap();
     let result = AuthBuilder::default().with_config(config).build().unwrap();
 
-    let forwarded_headers = result.forwarded_headers(&request_headers, None).unwrap();
+    let forwarded_headers = result
+      .forwarded_headers(&request_headers, None, &Endpoint::Reads)
+      .unwrap();
     assert_eq!(
       forwarded_headers,
       HeaderMap::from_iter([(
@@ -663,11 +679,11 @@ mod tests {
     );
 
     let config = builder
+      .clone()
       .forward_extensions(vec![ForwardExtensions::new(
         "$.Key".to_string(),
         "Custom1".to_string(),
       )])
-      .passthrough_auth(false)
       .build()
       .unwrap();
     let result = AuthBuilder::default().with_config(config).build().unwrap();
@@ -678,6 +694,7 @@ mod tests {
         Some(json!({
           "Key": "Value"
         })),
+        &Endpoint::Reads,
       )
       .unwrap();
     assert_eq!(
@@ -687,6 +704,22 @@ mod tests {
         "Value".parse().unwrap()
       ),])
     );
+
+    let config = builder.forward_endpoint_type(true).build().unwrap();
+    let result = AuthBuilder::default().with_config(config).build().unwrap();
+
+    let forwarded_headers = result
+      .forwarded_headers(&request_headers, None, &Endpoint::Variants)
+      .unwrap();
+    assert_eq!(
+      forwarded_headers,
+      HeaderMap::from_iter([(
+        format!("{}{}", FORWARD_HEADER_PREFIX, ENDPOINT_TYPE_NAME)
+          .parse()
+          .unwrap(),
+        "variants".parse().unwrap()
+      ),])
+    );
   }
 
   #[test]