policy-engine: add OpenAPI spec and endpoint

policy-engine/Cargo.toml

@@ -18,3 +18,4 @@ prometheus = "^0.4.2"
 semver = "^0.9.0"
 serde_json = "^1.0.22"
 structopt = "^0.2.10"
+openapiv3 = "0.1"

policy-engine/src/main.rs

@@ -11,17 +11,20 @@ extern crate futures;
 extern crate hyper;
 #[macro_use]
 extern crate lazy_static;
+#[macro_use]
 extern crate log;
 #[macro_use]
 extern crate prometheus;
 extern crate semver;
 extern crate serde_json;
 #[macro_use]
 extern crate structopt;
+extern crate openapiv3;
 
 mod config;
 mod graph;
 mod metrics;
+mod openapi;
 
 use actix_web::{http::Method, middleware::Logger, server, App};
 use failure::Error;
@@ -65,6 +68,7 @@ fn main() -> Result<(), Error> {
             .middleware(Logger::default())
             .prefix(app_prefix)
             .route("/v1/graph", Method::GET, graph::index)
+            .route("/v1/openapi", Method::GET, openapi::index)
     })
     .bind((opts.address, opts.port))?
     .start();

policy-engine/src/openapi.rs

@@ -0,0 +1,65 @@
+use actix_web::{HttpRequest, HttpResponse};
+use openapiv3::OpenAPI;
+use AppState;
+
+const SPEC: &str = include_str!("openapiv3.json");
+
+pub(crate) fn index(req: HttpRequest<AppState>) -> HttpResponse {
+    let path_prefix = &req.state().path_prefix;
+
+    let mut spec_object: OpenAPI = match serde_json::from_str(SPEC) {
+        Ok(o) => o,
+        Err(e) => {
+            let e = format_err!("Could not deserialize to OpenAPI object: {}", e);
+            error!("{}", e);
+            return HttpResponse::from_error(e.into());
+        }
+    };
+
+    // Prefix all paths with `path_prefix`
+    spec_object.paths = rewrite_paths(spec_object.paths, path_prefix);
+
+    match serde_json::to_string(&spec_object) {
+        Ok(s) => HttpResponse::from(s),
+        Err(e) => {
+            let e = format_err!("Could not serialize OpenAPI object: {}", e);
+            error!("{}", e);
+            HttpResponse::from_error(e.into())
+        }
+    }
+}
+
+fn rewrite_paths(paths: openapiv3::Paths, path_prefix: &str) -> openapiv3::Paths {
+    paths
+        .into_iter()
+        .map(|(path, path_item)| {
+            let new_path = format!("{}{}", path_prefix, &path);
+            trace!("Rewrote path {} -> {} ", &path, &new_path);
+            (new_path, path_item)
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_rewrite_paths() {
+        use super::{rewrite_paths, SPEC};
+        use openapiv3::OpenAPI;
+
+        let prefix = "/test_prefix";
+        let spec_object: OpenAPI = serde_json::from_str(SPEC).expect("couldn't parse JSON file");
+
+        let paths_before = spec_object.paths;
+        let paths_after = rewrite_paths(paths_before.clone(), &prefix);
+
+        paths_before.iter().zip(paths_after.iter()).for_each(
+            |((path_before, _), (path_after, _))| {
+                assert_ne!(path_after, path_before);
+                assert_eq!(path_after, &format!("{}{}", prefix, path_before));
+                assert!(path_after.as_str().starts_with(prefix));
+            },
+        );
+    }
+}

policy-engine/src/openapiv3.json

@@ -0,0 +1,103 @@
+{
+    "openapi": "3.0.2",
+    "info": {
+        "version": "0.0.0",
+        "title": "OpenShift Cincinnati Policy-Engine",
+        "license": {
+            "name": "Apache2"
+        },
+        "contact": {}
+    },
+    "servers": [],
+    "paths": {
+        "/v1/graph": {
+            "get": {
+                "summary": "Get the update graph",
+                "operationId": "getGraph",
+                "responses": {
+                    "200": {
+                        "description": "An update graph",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/Graph"
+                                }
+                            }
+                        }
+                    },
+                    "default": {
+                        "description": "unexpected error",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/Error"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "components": {
+        "schemas": {
+            "Graph": {
+                "properties": {
+                    "nodes": {
+                        "type": "array",
+                        "items": {
+                            "$ref": "#/components/schemas/Node"
+                        }
+                    },
+                    "edges": {
+                        "type": "array",
+                        "items": {
+                            "$ref": "#/components/schemas/Edge"
+                        }
+                    }
+                }
+            },
+            "Node": {
+                "required": [
+                    "version",
+                    "payload",
+                    "metadata"
+                ],
+                "properties": {
+                    "version": {
+                        "type": "string"
+                    },
+                    "payload": {
+                        "type": "string"
+                    },
+                    "metadata": {
+                        "type": "string"
+                    }
+                }
+            },
+            "Edge": {
+                "type": "array",
+                "items": {
+                    "type": "integer",
+                    "format": "int32"
+                }
+            },
+            "Error": {
+                "required": [
+                    "code",
+                    "message"
+                ],
+                "properties": {
+                    "code": {
+                        "type": "integer",
+                        "format": "int32"
+                    },
+                    "message": {
+                        "type": "string"
+                    }
+                }
+            }
+        }
+    },
+    "security": []
+}