update for AC

src/cryptoservice.rs

@@ -1,37 +1,40 @@
-
-#[macro_use] extern crate rocket;
+#[macro_use]
+extern crate rocket;
 extern crate bls12_381;
 extern crate rand;
 
-use std::sync::RwLock;
 use bls12_381::pairing;
 use bls12_381::G2Affine;
-use std::sync::Mutex;
-use std::sync::Arc;
-use rocket_okapi::settings::UrlObject;
-use rocket_okapi::{openapi, openapi_get_routes, rapidoc::*, swagger_ui::*};
 use rocket::serde::json::Json;
 use rocket::Request;
+use rocket_okapi::settings::UrlObject;
+use rocket_okapi::{openapi, openapi_get_routes, rapidoc::*, swagger_ui::*};
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::sync::RwLock;
 
-use ophe::core::{RatelimiterRequest,RatelimiterResponse,SetKeyHelper, RatelimiterRotateRequest, RatelimiterRotateResponse};
 use ophe::core;
+use ophe::core::{
+    RatelimiterRequest, RatelimiterResponse, RatelimiterRotateRequest, RatelimiterRotateResponse,
+    SetKeyHelper,
+};
 
+use bls12_381::G1Affine;
+use bls12_381::Scalar;
 use ophe::utils;
 use rocket::State;
-use bls12_381::Scalar;
-use bls12_381::G1Affine;
 
-
-
-fn make_public_parameters(key: Scalar) -> CryptoserviceState{
+fn make_public_parameters(key: Scalar) -> CryptoserviceState {
     let generator = pairing(&G1Affine::generator(), &G2Affine::generator());
     let public_key = generator * key;
 
-    let pp = core::PublicParameters{ratelimiter_public_key:public_key,gt_gen:generator};
-    CryptoserviceState{key,pp}
+    let pp = core::PublicParameters {
+        ratelimiter_public_key: public_key,
+        gt_gen: generator,
+    };
+    CryptoserviceState { key, pp }
 }
 
-
 struct CryptoserviceState {
     key: Scalar,
     pp: core::PublicParameters,
@@ -39,39 +42,43 @@ struct CryptoserviceState {
 
 type CryptoserviceStatePointer = Arc<RwLock<CryptoserviceState>>;
 
-
 #[rocket::main]
 async fn main() {
     let c = make_public_parameters(utils::random_scalar());
-    let c_p:CryptoserviceStatePointer = Arc::new(RwLock::new(c));
+    let c_p: CryptoserviceStatePointer = Arc::new(RwLock::new(c));
+    let figment = rocket::Config::figment().merge(("port", 8081));
 
-    let launch_result = rocket::build()
-    .manage(c_p)
-    .mount("/", openapi_get_routes![phe_help,get_public_parameters,set_key, rotate_key])
-    .mount(
-        "/swagger-ui/",
-        make_swagger_ui(&SwaggerUIConfig {
-            url: "../openapi.json".to_owned(),
-            ..Default::default()
-        }),
-    ) .mount(
-        "/rapidoc/",
-        make_rapidoc(&RapiDocConfig {
-            general: GeneralConfig {
-                spec_urls: vec![UrlObject::new("General", "../openapi.json")],
+    let launch_result = rocket::custom(figment)
+        .manage(c_p)
+        .mount(
+            "/",
+            openapi_get_routes![phe_help, get_public_parameters, set_key, rotate_key],
+        )
+        .mount(
+            "/swagger-ui/",
+            make_swagger_ui(&SwaggerUIConfig {
+                url: "../openapi.json".to_owned(),
                 ..Default::default()
-            },
-            hide_show: HideShowConfig {
-                allow_spec_url_load: false,
-                allow_spec_file_load: false,
+            }),
+        )
+        .mount(
+            "/rapidoc/",
+            make_rapidoc(&RapiDocConfig {
+                general: GeneralConfig {
+                    spec_urls: vec![UrlObject::new("General", "../openapi.json")],
+                    ..Default::default()
+                },
+                hide_show: HideShowConfig {
+                    allow_spec_url_load: false,
+                    allow_spec_file_load: false,
+                    ..Default::default()
+                },
                 ..Default::default()
-            },
-            ..Default::default()
-        }),
-    )    
-    .register("/",catchers![serialize_failed])
-    .launch()
-    .await;
+            }),
+        )
+        .register("/", catchers![serialize_failed])
+        .launch()
+        .await;
     match launch_result {
         Ok(_) => println!("Rocket shut down gracefully."),
         Err(err) => println!("Rocket had an error: {}", err),
@@ -79,47 +86,53 @@ async fn main() {
 }
 
 #[openapi()]
-#[post("/phe_help",format = "json", data = "<request>")]
-fn phe_help(request: Json<RatelimiterRequest>,c_state: &State<CryptoserviceStatePointer>) -> Json<RatelimiterResponse> {
-    
-    let (key,pp) = {
+#[post("/phe_help", format = "json", data = "<request>")]
+fn phe_help(
+    request: Json<RatelimiterRequest>,
+    c_state: &State<CryptoserviceStatePointer>,
+) -> Json<RatelimiterResponse> {
+    let (key, pp) = {
         let c_state = c_state.read().unwrap();
-        (c_state.key.clone(),c_state.pp.clone())
+        (c_state.key.clone(), c_state.pp.clone())
     };
 
-
-    Json(core::phe_ratelimiter(&key,&request,&pp))
+    Json(core::phe_ratelimiter(&key, &request, &pp))
 }
 
 #[openapi()]
 #[get("/get_public_parameters")]
-fn get_public_parameters(c_state: &State<CryptoserviceStatePointer>) -> Json<core::PublicParameters>{
+fn get_public_parameters(
+    c_state: &State<CryptoserviceStatePointer>,
+) -> Json<core::PublicParameters> {
     let pp = c_state.read().unwrap().pp.clone();
     Json(pp)
 }
 
-
 #[openapi()]
-#[post("/set_key",format = "json", data = "<request>")]
-fn set_key(request: Json<SetKeyHelper>,c_state: &State<CryptoserviceStatePointer>) -> Json<core::PublicParameters> {
+#[post("/set_key", format = "json", data = "<request>")]
+fn set_key(
+    request: Json<SetKeyHelper>,
+    c_state: &State<CryptoserviceStatePointer>,
+) -> Json<core::PublicParameters> {
     let new_c = make_public_parameters(request.key);
 
     let mut c_state = c_state.write().unwrap();
     c_state.key = new_c.key;
     c_state.pp = new_c.pp;
-    
 
     Json(new_c.pp)
 }
 
-
 #[openapi()]
-#[post("/rotate_key",format = "json", data = "<request>")]
-fn rotate_key(request: Json<RatelimiterRotateRequest>,c_state: &State<CryptoserviceStatePointer>) -> Json<RatelimiterRotateResponse> {
+#[post("/rotate_key", format = "json", data = "<request>")]
+fn rotate_key(
+    request: Json<RatelimiterRotateRequest>,
+    c_state: &State<CryptoserviceStatePointer>,
+) -> Json<RatelimiterRotateResponse> {
     let mut c_state = c_state.write().unwrap();
     let (response, k_new) = core::phe_roate_ratelimiter(&c_state.key, &request.s);
     c_state.key = k_new;
-    
+
     Json(response)
 }