fixes

Author: dotansimha

bin/router/src/background_tasks/mod.rs

@@ -16,6 +16,12 @@ pub struct BackgroundTasksManager {
     task_handles: Vec<JoinHandle<()>>,
 }
 
+impl Default for BackgroundTasksManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl BackgroundTasksManager {
     pub fn new() -> Self {
         Self {

bin/router/src/jwt/context.rs

@@ -6,6 +6,7 @@ use sonic_rs::Value;
 
 pub type TokenPayload = TokenData<JwtClaims>;
 
+#[allow(dead_code)] // TODO: Remove this when we actually use this and integrate with header propagation
 pub struct JwtRequestContext {
     pub token: String,
     pub payload: TokenPayload,

bin/router/src/jwt/errors.rs

@@ -46,12 +46,12 @@ pub enum JwtError {
 }
 
 impl JwtError {
-    pub fn into_response(&self) -> web::HttpResponse {
+    pub fn make_response(&self) -> web::HttpResponse {
         let validation_error_result = FailedExecutionResult {
             errors: Some(vec![self.into()]),
         };
 
-        return ResponseBuilder::new(self.into()).json(&validation_error_result);
+        ResponseBuilder::new(self.into()).json(&validation_error_result)
     }
 
     pub fn error_code(&self) -> &'static str {

bin/router/src/jwt/jwks_manager.rs

@@ -3,6 +3,7 @@ use sonic_rs::from_str;
 use std::sync::{Arc, RwLock};
 use tokio::fs::read_to_string;
 use tokio_util::sync::CancellationToken;
+use tracing::debug;
 
 use jsonwebtoken::jwk::JwkSet;
 
@@ -72,27 +73,25 @@ impl BackgroundTask for JwksSource {
     }
 
     async fn run(&self, token: CancellationToken) {
-        match &self.config {
-            JwksProviderSourceConfig::Remote {
-                polling_interval, ..
-            } => {
-                if let Some(interval) = polling_interval {
-                    let mut tokio_interval = tokio::time::interval(*interval);
-
-                    loop {
-                        tokio::select! {
-                            _ = tokio_interval.tick() => { match self.load_and_store_jwks().await {
-                                Ok(_) => {}
-                                Err(err) => {
-                                    tracing::error!("Failed to load remote jwks: {}", err);
-                                }
-                            } }
-                            _ = token.cancelled() => { println!("Shutting down."); return; }
+        if let JwksProviderSourceConfig::Remote {
+            polling_interval: Some(interval),
+            ..
+        } = &self.config
+        {
+            debug!("Starting remote jwks polling for source: {:?}", self.config);
+            let mut tokio_interval = tokio::time::interval(*interval);
+
+            loop {
+                tokio::select! {
+                    _ = tokio_interval.tick() => { match self.load_and_store_jwks().await {
+                        Ok(_) => {}
+                        Err(err) => {
+                            tracing::error!("Failed to load remote jwks: {}", err);
                         }
-                    }
+                    } }
+                    _ = token.cancelled() => { println!("Shutting down."); return; }
                 }
             }
-            _ => {}
         }
     }
 }

bin/router/src/jwt/mod.rs

@@ -242,8 +242,8 @@ impl JwtAuthRuntime {
         match (&self.config.audiences, &token_data.claims.aud) {
             (Some(audiences), Some(token_aud)) => {
                 let all_valid = match token_aud {
-                    Audience::Single(s) => audiences.contains(&s),
-                    Audience::Multiple(s) => s.iter().all(|v| audiences.contains(&v)),
+                    Audience::Single(s) => audiences.contains(s),
+                    Audience::Multiple(s) => s.iter().all(|v| audiences.contains(v)),
                 };
 
                 if !all_valid {

bin/router/src/pipeline/mod.rs

@@ -54,7 +54,7 @@ pub async fn graphql_request_handler(
     if let Some(jwt) = &state.jwt_auth_runtime {
         match jwt.validate_request(req) {
             Ok(_) => (),
-            Err(err) => return err.into_response(),
+            Err(err) => return err.make_response(),
         }
     }
 

e2e/src/lib.rs

@@ -1,3 +1,4 @@
+#[cfg(test)]
 mod jwt;
 #[cfg(test)]
 mod testkit;

e2e/src/testkit.rs

@@ -29,6 +29,7 @@ lazy_static! {
     static ref TRACING_INIT: Once = Once::new();
 }
 
+#[allow(dead_code)] // call this at the beginning of the test if you wish to see gw logs
 pub fn init_logger() {
     TRACING_INIT.call_once(|| {
         let subscriber = tracing_subscriber::registry()

lib/router-config/src/lib.rs

@@ -59,7 +59,7 @@ pub enum RouterConfigError {
     ConfigLoadError(config::ConfigError),
 }
 
-static DEFAULT_FILE_NAMES: &[&'static str] = &[
+static DEFAULT_FILE_NAMES: &[&str] = &[
     "hive-router.config.yaml",
     "hive-router.config.yml",
     "hive-router.config.json",

lib/router-config/src/primitives/file_path.rs

@@ -19,7 +19,7 @@ pub struct FilePath {
 }
 
 // This is a workaround/solution to pass some kind of "context" to the deserialization process.
-thread_local!(static CONTEXT_START_PATH: RefCell<Option<PathBuf>> = RefCell::new(None));
+thread_local!(static CONTEXT_START_PATH: RefCell<Option<PathBuf>> = const { RefCell::new(None) });
 
 pub fn with_start_path<F, T>(start_path: &Path, f: F) -> T
 where