fix: add cors settings; refactor http responses

Cargo.toml

@@ -31,6 +31,7 @@ clarity-repl = "1.6.4"
 clarinet-files = "1.0.0"
 chainhook-types = "1.0.1"
 clarinet-deployments = "1.0.1"
+toml = "0.5.9"
 
 [dev-dependencies]
 tower-test = "0.4.0"

Config.toml

@@ -0,0 +1,2 @@
+allowed_origins = ["*"]
+allowed_methods = ["DELETE", "GET", "OPTIONS", "POST", "HEAD"]

README.md

@@ -17,10 +17,15 @@ brew install kind
 
 You should now be ready to deploy this service to your local Kubernetes cluster!
 
+## Configuration
+The `Config.toml` at the root directory of the project can be used to control some settings. This same file can be used to update both the stable and development build. The following settings are supported:
+ - `allowed_origins` - this setting is an array of strings and is used to set what origins are allowed in cross-origin requests. For example, `allowed_origins = ["*"]` allows any origins to make requests to this service, while `allowed_origins = ["localhost:3002", "dev.platform.so"]` will only allow requests from the two specified hosts.
+ - `allowed_methods` - this setting is an array of strings that sets what HTTP methods can be made to this server.
+
 ## Deploying the Stable Version
-In your terminal, rum 
+In your terminal, run
 ```
-kubectl --context kind-kind apply -f ./templates/stacks-devnet-api.template.yaml
+./scripts/deploy-api.sh
 ```
 to install the [latest version of this service](https://quay.io/repository/hirosystems/stacks-devnet-api?tab=history) that has been deployed to docker (or, to quay for now). This service should now be fully running on your Kubernetes cluster. See the [usage](#usage) sections for steps on how to use the service.
 
@@ -52,14 +57,9 @@ spec:
 +    imagePullPolicy: Never
 ```
 
-If a version of this tool has already been deployed to your local cluster, you'll need to delete the existing pod. You'll need to do this every time you redeploy the service:
-```
-kubectl --context kind-kind delete pod stacks-devnet-api --namespace devnet
-```
-
 Finally, run 
 ```
-kubectl --context kind-kind apply -f ./templates/stacks-devnet-api.template.yaml
+./scripts/redeploy-api.sh
 ```
 to deploy to your local cluster.
 

scripts/deploy-api.sh

@@ -0,0 +1,2 @@
+kubectl --context kind-kind create configmap stacks-devnet-api-conf --from-file=./Config.toml --namespace devnet && \
+kubectl --context kind-kind apply -f ./templates/stacks-devnet-api.template.yaml

scripts/redeploy-api.sh

@@ -0,0 +1,3 @@
+kubectl --context kind-kind delete configmap stacks-devnet-api-conf --namespace devnet & \
+kubectl --context kind-kind delete pod stacks-devnet-api --namespace devnet && \
+./scripts/deploy-api.sh

src/lib.rs

@@ -32,6 +32,7 @@ mod template_parser;
 use template_parser::get_yaml_from_resource;
 
 pub mod resources;
+pub mod responder;
 pub mod routes;
 use crate::resources::configmap::StacksDevnetConfigmap;
 use crate::resources::pod::StacksDevnetPod;

src/main.rs

@@ -1,7 +1,8 @@
 use hiro_system_kit::slog;
 use hyper::server::conn::AddrStream;
 use hyper::service::{make_service_fn, service_fn};
-use hyper::{Body, Method, Request, Response, Server, StatusCode};
+use hyper::{Body, Method, Request, Response, Server};
+use stacks_devnet_api::responder::{Responder, ResponderConfig};
 use stacks_devnet_api::routes::{
     get_standardized_path_parts, handle_delete_devnet, handle_get_devnet, handle_new_devnet,
     handle_try_proxy_service, API_PATH,
@@ -24,14 +25,27 @@ async fn main() {
         tracer: false,
     };
     let k8s_manager = StacksDevnetApiK8sManager::default(&ctx).await;
+    let config_path = if cfg!(debug_assertions) {
+        "./Config.toml"
+    } else {
+        "/etc/config/Config.toml"
+    };
+    let config = ResponderConfig::from_path(config_path);
 
     let make_svc = make_service_fn(|conn: &AddrStream| {
         let k8s_manager = k8s_manager.clone();
         let ctx = ctx.clone();
         let remote_addr = conn.remote_addr().ip();
+        let config = config.clone();
         async move {
             Ok::<_, Infallible>(service_fn(move |req| {
-                handle_request(remote_addr, req, k8s_manager.clone(), ctx.clone())
+                handle_request(
+                    remote_addr,
+                    req,
+                    k8s_manager.clone(),
+                    config.clone(),
+                    ctx.clone(),
+                )
             }))
         }
     });
@@ -49,6 +63,7 @@ async fn handle_request(
     _client_ip: IpAddr,
     request: Request<Body>,
     k8s_manager: StacksDevnetApiK8sManager,
+    config: ResponderConfig,
     ctx: Context,
 ) -> Result<Response<Body>, Infallible> {
     let uri = request.uri();
@@ -63,86 +78,75 @@ async fn handle_request(
         )
     });
 
+    let responder = Responder::new(config, request.headers().clone()).unwrap();
+    if method == &Method::OPTIONS {
+        return responder.ok();
+    }
     if path == "/api/v1/networks" {
         return match method {
-            &Method::POST => handle_new_devnet(request, k8s_manager, ctx).await,
-            _ => Ok(Response::builder()
-                .status(StatusCode::METHOD_NOT_ALLOWED)
-                .body(Body::try_from("network creation must be a POST request").unwrap())
-                .unwrap()),
+            &Method::POST => handle_new_devnet(request, k8s_manager, responder, ctx).await,
+            _ => responder.err_method_not_allowed("network creation must be a POST request".into()),
         };
     } else if path.starts_with(API_PATH) {
         let path_parts = get_standardized_path_parts(uri.path());
 
         if path_parts.route != "network" {
-            return Ok(Response::builder()
-                .status(StatusCode::BAD_REQUEST)
-                .body(Body::try_from("invalid request path").unwrap())
-                .unwrap());
+            return responder.err_bad_request("invalid request path".into());
         }
         // the api path must be followed by a network id
         if path_parts.network.is_none() {
-            return Ok(Response::builder()
-                .status(StatusCode::BAD_REQUEST)
-                .body(Body::try_from("no network id provided").unwrap())
-                .unwrap());
+            return responder.err_bad_request("no network id provided".into());
         }
         let network = path_parts.network.unwrap();
 
         // verify that we have a valid namespace and the network actually exists
         let exists = match k8s_manager.check_namespace_exists(&network).await {
             Ok(exists) => exists,
             Err(e) => {
-                return Ok(Response::builder()
-                    .status(StatusCode::from_u16(e.code).unwrap())
-                    .body(Body::try_from(e.message).unwrap())
-                    .unwrap());
+                return responder.respond(e.code, e.message);
             }
         };
         if !exists {
             let msg = format!("network {} does not exist", &network);
             ctx.try_log(|logger| slog::warn!(logger, "{}", msg));
-            return Ok(Response::builder()
-                .status(StatusCode::from_u16(404).unwrap())
-                .body(Body::try_from(msg).unwrap())
-                .unwrap());
+            return responder.err_not_found(msg);
         }
 
         // the path only contained the network path and network id,
         // so it must be a request to DELETE a network or GET network info
         if path_parts.subroute.is_none() {
             return match method {
-                &Method::DELETE => handle_delete_devnet(k8s_manager, &network).await,
-                &Method::GET => handle_get_devnet(k8s_manager, &network, ctx).await,
-                _ => Ok(Response::builder()
-                    .status(StatusCode::METHOD_NOT_ALLOWED)
-                    .body(Body::empty())
-                    .unwrap()),
+                &Method::DELETE => handle_delete_devnet(k8s_manager, &network, responder).await,
+                &Method::GET => handle_get_devnet(k8s_manager, &network, responder, ctx).await,
+                _ => {
+                    responder.err_method_not_allowed("can only GET/DELETE at provided route".into())
+                }
             };
         }
         let subroute = path_parts.subroute.unwrap();
         if subroute == "commands" {
-            return Ok(Response::builder()
-                .status(StatusCode::NOT_IMPLEMENTED)
-                .body(Body::empty())
-                .unwrap());
+            return responder.err_not_implemented("commands route in progress".into());
         } else {
             let remaining_path = path_parts.remainder.unwrap_or(String::new());
-            return handle_try_proxy_service(&remaining_path, &subroute, &network, request, &ctx)
-                .await;
+            return handle_try_proxy_service(
+                &remaining_path,
+                &subroute,
+                &network,
+                request,
+                responder,
+                &ctx,
+            )
+            .await;
         }
     }
 
-    Ok(Response::builder()
-        .status(StatusCode::BAD_REQUEST)
-        .body(Body::try_from("invalid request path").unwrap())
-        .unwrap())
+    responder.err_bad_request("invalid request path".into())
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use hyper::body;
+    use hyper::{body, StatusCode};
     use k8s_openapi::api::core::v1::Namespace;
     use stacks_devnet_api::{
         resources::service::{
@@ -211,9 +215,15 @@ mod tests {
         for path in invalid_paths {
             let request_builder = Request::builder().uri(path).method("GET");
             let request: Request<Body> = request_builder.body(Body::empty()).unwrap();
-            let mut response = handle_request(client_ip, request, k8s_manager.clone(), ctx.clone())
-                .await
-                .unwrap();
+            let mut response = handle_request(
+                client_ip,
+                request,
+                k8s_manager.clone(),
+                ResponderConfig::default(),
+                ctx.clone(),
+            )
+            .await
+            .unwrap();
             assert_eq!(response.status(), StatusCode::BAD_REQUEST);
             let body = response.body_mut();
             let bytes = body::to_bytes(body).await.unwrap().to_vec();
@@ -241,9 +251,15 @@ mod tests {
 
         let request_builder = Request::builder().uri(path).method("GET");
         let request: Request<Body> = request_builder.body(Body::empty()).unwrap();
-        let mut response = handle_request(client_ip, request, k8s_manager.clone(), ctx)
-            .await
-            .unwrap();
+        let mut response = handle_request(
+            client_ip,
+            request,
+            k8s_manager.clone(),
+            ResponderConfig::default(),
+            ctx,
+        )
+        .await
+        .unwrap();
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
         let body = response.body_mut();
         let bytes = body::to_bytes(body).await.unwrap().to_vec();
@@ -270,9 +286,15 @@ mod tests {
 
         let request_builder = Request::builder().uri(path).method("GET");
         let request: Request<Body> = request_builder.body(Body::empty()).unwrap();
-        let mut response = handle_request(client_ip, request, k8s_manager.clone(), ctx)
-            .await
-            .unwrap();
+        let mut response = handle_request(
+            client_ip,
+            request,
+            k8s_manager.clone(),
+            ResponderConfig::default(),
+            ctx,
+        )
+        .await
+        .unwrap();
         assert_eq!(response.status(), StatusCode::BAD_REQUEST);
         let body = response.body_mut();
         let bytes = body::to_bytes(body).await.unwrap().to_vec();
@@ -301,9 +323,15 @@ mod tests {
         for method in methods {
             let request_builder = Request::builder().uri(path).method(method);
             let request: Request<Body> = request_builder.body(Body::empty()).unwrap();
-            let mut response = handle_request(client_ip, request, k8s_manager.clone(), ctx.clone())
-                .await
-                .unwrap();
+            let mut response = handle_request(
+                client_ip,
+                request,
+                k8s_manager.clone(),
+                ResponderConfig::default(),
+                ctx.clone(),
+            )
+            .await
+            .unwrap();
             assert_eq!(response.status(), StatusCode::METHOD_NOT_ALLOWED);
             let body = response.body_mut();
             let bytes = body::to_bytes(body).await.unwrap().to_vec();
@@ -330,9 +358,15 @@ mod tests {
 
         let request_builder = Request::builder().uri(path).method("POST");
         let request: Request<Body> = request_builder.body(Body::empty()).unwrap();
-        let mut response = handle_request(client_ip, request, k8s_manager.clone(), ctx)
-            .await
-            .unwrap();
+        let mut response = handle_request(
+            client_ip,
+            request,
+            k8s_manager.clone(),
+            ResponderConfig::default(),
+            ctx,
+        )
+        .await
+        .unwrap();
         assert_eq!(response.status(), StatusCode::BAD_REQUEST);
         let body = response.body_mut();
         let bytes = body::to_bytes(body).await.unwrap().to_vec();