notifications_handler: Move the /notifications scope configuration

Move the /notifications scope configuration from main to
notifications_handler.  This is a preparation to support multiple API
versions.

Also, restrict the visibility of methods that are not required outside
the module to private.

Signed-off-by: Anderson Toshiyuki Sasaki <[email protected]>

Author: ansasaki

keylime-agent/src/errors_handler.rs

@@ -127,39 +127,6 @@ pub(crate) async fn agent_default(req: HttpRequest) -> impl Responder {
     response
 }
 
-pub(crate) async fn notifications_default(
-    req: HttpRequest,
-) -> impl Responder {
-    let error;
-    let response;
-    let message;
-
-    match req.head().method {
-        http::Method::POST => {
-            error = 400;
-            message = "URI not supported, only /revocation is supported for POST in /notifications/ interface";
-            response = HttpResponse::BadRequest()
-                .json(JsonWrapper::error(error, message));
-        }
-        _ => {
-            error = 405;
-            message = "Method is not supported in /notifications/ interface";
-            response = HttpResponse::MethodNotAllowed()
-                .insert_header(http::header::Allow(vec![http::Method::POST]))
-                .json(JsonWrapper::error(error, message));
-        }
-    };
-
-    warn!(
-        "{} returning {} response. {}",
-        req.head().method,
-        error,
-        message
-    );
-
-    response
-}
-
 pub(crate) async fn version_not_supported(
     req: HttpRequest,
     version: web::Path<APIVersion>,
@@ -288,12 +255,6 @@ mod tests {
         test_default(web::resource("/").to(api_default), "GET, POST").await
     }
 
-    #[actix_rt::test]
-    async fn test_notifications_default() {
-        test_default(web::resource("/").to(notifications_default), "POST")
-            .await
-    }
-
     #[actix_rt::test]
     async fn test_agent_default() {
         test_default(web::resource("/").to(agent_default), "GET").await

keylime-agent/src/main.rs

@@ -910,16 +910,9 @@ async fn main() -> Result<()> {
                             keys_handler::configure_keys_endpoints,
                         ))
                         .service(
-                            web::scope("/notifications")
-                                .service(web::resource("/revocation").route(
-                                    web::post().to(
-                                        notifications_handler::revocation,
-                                    ),
-                                ))
-                                .default_service(web::to(
-                                    errors_handler::notifications_default,
-                                )),
-                        )
+                            web::scope("/notifications").configure(
+                            notifications_handler::configure_notifications_endpoints,
+                        ))
                         .service(web::scope("/quotes").configure(
                             quotes_handler::configure_quotes_endpoints,
                         ))

keylime-agent/src/notifications_handler.rs

@@ -6,13 +6,13 @@ use crate::{
     revocation::{Revocation, RevocationMessage},
     Error, QuoteData, Result,
 };
-use actix_web::{web, HttpRequest, HttpResponse, Responder};
+use actix_web::{http, web, HttpRequest, HttpResponse, Responder};
 use log::*;
 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
 
 // This is Revocation request from the cloud verifier via REST API
-pub(crate) async fn revocation(
+async fn revocation(
     body: web::Json<Revocation>,
     req: HttpRequest,
     data: web::Data<QuoteData>,
@@ -35,16 +35,97 @@ pub(crate) async fn revocation(
     }
 }
 
+async fn notifications_default(req: HttpRequest) -> impl Responder {
+    let error;
+    let response;
+    let message;
+
+    match req.head().method {
+        http::Method::POST => {
+            error = 400;
+            message = "URI not supported, only /revocation is supported for POST in /notifications/ interface";
+            response = HttpResponse::BadRequest()
+                .json(JsonWrapper::error(error, message));
+        }
+        _ => {
+            error = 405;
+            message = "Method is not supported in /notifications/ interface";
+            response = HttpResponse::MethodNotAllowed()
+                .insert_header(http::header::Allow(vec![http::Method::POST]))
+                .json(JsonWrapper::error(error, message));
+        }
+    };
+
+    warn!(
+        "{} returning {} response. {}",
+        req.head().method,
+        error,
+        message
+    );
+
+    response
+}
+
+/// Configure the endpoints for the /notifications scope
+pub(crate) fn configure_notifications_endpoints(
+    cfg: &mut web::ServiceConfig,
+) {
+    _ = cfg
+        .service(
+            web::resource("/revocation").route(web::post().to(revocation)),
+        )
+        .default_service(web::to(notifications_default));
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::common::API_VERSION;
     use actix_rt::Arbiter;
     use actix_web::{test, web, App};
-    use serde_json::json;
+    use serde_json::{json, Value};
     use std::{fs, path::Path};
     use tokio::sync::mpsc;
 
+    #[actix_rt::test]
+    async fn test_notifications_default() {
+        let mut app = test::init_service(
+            App::new().service(web::resource("/").to(notifications_default)),
+        )
+        .await;
+
+        let req = test::TestRequest::post()
+            .uri("/")
+            .data("some data")
+            .to_request();
+
+        let resp = test::call_service(&app, req).await;
+        assert!(resp.status().is_client_error());
+
+        let result: JsonWrapper<Value> = test::read_body_json(resp).await;
+
+        assert_eq!(result.results, json!({}));
+        assert_eq!(result.code, 400);
+
+        let req = test::TestRequest::delete().uri("/").to_request();
+
+        let resp = test::call_service(&app, req).await;
+        assert!(resp.status().is_client_error());
+
+        let headers = resp.headers();
+
+        assert!(headers.contains_key("allow"));
+        assert_eq!(
+            headers.get("allow").unwrap().to_str().unwrap(), //#[allow_ci]
+            "POST"
+        );
+
+        let result: JsonWrapper<Value> = test::read_body_json(resp).await;
+
+        assert_eq!(result.results, json!({}));
+        assert_eq!(result.code, 405);
+    }
+
     #[cfg(feature = "testing")]
     #[actix_rt::test]
     async fn test_revocation() {