domain verification

Cargo.toml

@@ -21,10 +21,6 @@ path = "./src/main.rs"
 name = "tests-migrate"
 path = "./src/tests-migrate.rs"
 
-[[bin]]
-name = "kv-test-util"
-path = "./src/api/v1/tests/kvserver.rs"
-
 [dependencies]
 actix-web = "3"
 actix = "0.11"

src/api/v1/mcaptcha/domains.rs

@@ -67,12 +67,11 @@ pub async fn get_challenge(
     payload: web::Json<Domain>,
     data: web::Data<Data>,
     id: Identity,
-    client: web::Data<Client>,
 ) -> ServiceResult<impl Responder> {
     is_authenticated(&id)?;
     let url = Url::parse(&payload.name)?;
 
-    let host = url.host_str().ok_or(ServiceError::NotAUrl).unwrap();
+    let host = url.host_str().ok_or(ServiceError::NotAUrl)?;
     let user = id.identity().unwrap();
     let res = sqlx::query_as!(
         Challenge,
@@ -83,8 +82,7 @@ pub async fn get_challenge(
         user,
     )
     .fetch_one(&data.db)
-    .await
+    .await?;
-    .unwrap();
     Ok(HttpResponse::Ok().json(res))
 }
 
@@ -95,56 +93,58 @@ pub async fn verify(
     client: web::Data<Client>,
     id: Identity,
 ) -> ServiceResult<impl Responder> {
+    use crate::VERIFICATION_PATH;
     use futures::{future::TryFutureExt, try_join};
 
-    is_authenticated(&id).unwrap();
+    is_authenticated(&id)?;
-    //let url = Url::parse(&payload.name).unwrap();
+    let url = Url::parse(&payload.name)?;
-    //let host = url.host_str().ok_or(ServiceError::NotAUrl).unwrap();
+    let host = url.host_str().ok_or(ServiceError::NotAUrl)?;
-    //let user = id.identity().unwrap();
+    let user = id.identity().unwrap();
-    //let challenge_fut = sqlx::query_as!(
+    let challenge_fut = sqlx::query_as!(
-    //    Challenge,
+        Challenge,
-    //    "SELECT verification_challenge
+        "SELECT verification_challenge
-    //        FROM mcaptcha_domains_unverified where
+            FROM mcaptcha_domains_unverified where
-    //        name = $1 AND owner_id = (SELECT ID from mcaptcha_users where name = $2)",
+            name = $1 AND owner_id = (SELECT ID from mcaptcha_users where name = $2)",
-    //    &host,
+        &host,
-    //    &user,
+        &user,
-    //)
+    )
-    //.fetch_one(&data.db)
+    .fetch_one(&data.db)
-    //.map_err(|e| {
+    .map_err(|e| {
-    //    let r: ServiceError = e.into();
+        let r: ServiceError = e.into();
-    //    r
+        r
-    //});
+    });
 
-    //let res_fut = client.get(host).send().map_err(|e| {
+    let res_fut = client
-    //    let r: ServiceError = e.into();
+        .get(format!("{}{}", url.to_string(), VERIFICATION_PATH))
-    //    r
+        .send()
-    //});
+        .map_err(|e| {
+            let r: ServiceError = e.into();
+            r
+        });
 
-    //let (challenge, mut server_res) = try_join!(challenge_fut, res_fut).unwrap();
+    let (challenge, mut server_res) = try_join!(challenge_fut, res_fut)?;
 
-    //let server_resp: Challenge = server_res
+    let server_resp: Challenge = server_res
-    //    .json()
+        .json()
-    //    .await
+        .await
-    //    .map_err(|_| return ServiceError::ChallengeCourruption)
+        .map_err(|_| return ServiceError::ChallengeCourruption)?;
-    //    .unwrap();
 
-    //if server_resp.verification_challenge == challenge.verification_challenge {
+    if server_resp.verification_challenge == challenge.verification_challenge {
-    //    sqlx::query!(
+        sqlx::query!(
-    //        "INSERT INTO mcaptcha_domains_verified (name, owner_id) VALUES
+            "INSERT INTO mcaptcha_domains_verified (name, owner_id) VALUES
-    //        ($1, (SELECT ID from mcaptcha_users WHERE name = $2))",
+            ($1, (SELECT ID from mcaptcha_users WHERE name = $2))",
-    //        &host,
+            &host,
-    //        &user
+            &user
-    //    )
+        )
-    //    .execute(&data.db)
+        .execute(&data.db)
-    //    .await
+        .await?;
-    //    .unwrap();
 
-    //    // TODO delete staging unverified
+        // TODO delete staging unverified
 
-    Ok(HttpResponse::Ok())
+        Ok(HttpResponse::Ok())
-    //} else {
+    } else {
-    //    Err(ServiceError::ChallengeVerificationFailure)
+        Err(ServiceError::ChallengeVerificationFailure)
-    //}
+    }
 }
 
 #[post("/api/v1/mcaptcha/domain/delete")]
@@ -304,7 +304,7 @@ mod tests {
         let challenge: Challenge = test::read_body_json(get_challenge_resp).await;
 
         client
-            .post(format!("{}/domain_verification_works/", DOMAIN))
+            .post(format!("{}/{}/", DOMAIN, VERIFICATION_PATH))
             .send_json(&challenge)
             .await
             .unwrap();

src/api/v1/tests/kvserver.rs

@@ -20,7 +20,7 @@ use std::env;
 use std::sync::mpsc;
 use std::sync::{Arc, RwLock};
 
-use actix_web::{dev::Server, web, App, HttpResponse, HttpServer, Responder};
+use actix_web::{dev::Server, middleware, web, App, HttpResponse, HttpServer, Responder};
 use serde::{Deserialize, Serialize};
 
 // from
@@ -30,32 +30,13 @@ pub struct Challenge {
     verification_challenge: String,
 }
 
-#[cfg(not(tarpaulin_include))]
-#[actix_web::main]
-async fn main() {
-    pretty_env_logger::init();
-    let mut confif = env::args();
-    confif.next();
-    let port = confif.next().unwrap();
-    HttpServer::new(move || {
-        let store: UtilKVServer = Arc::new(RwLock::new(HashMap::new()));
-        App::new()
-            .data(store)
-            .route("/{key}/", web::post().to(util_server_add))
-            .route("/{key}/", web::get().to(util_server_retrive))
-    })
-    .bind(format!("localhost:{}", port))
-    .unwrap()
-    .run()
-    .await
-    .unwrap();
-}
-
 pub async fn server(ip: &str, tx: mpsc::Sender<Server>) {
     pretty_env_logger::init();
     let srv = HttpServer::new(move || {
         let store: UtilKVServer = Arc::new(RwLock::new(HashMap::new()));
         App::new()
+            .wrap(middleware::Logger::default())
+            .wrap(middleware::NormalizePath::default())
             .data(store)
             .route("/{key}/", web::post().to(util_server_add))
             .route("/{key}/", web::get().to(util_server_retrive))
@@ -64,7 +45,7 @@ pub async fn server(ip: &str, tx: mpsc::Sender<Server>) {
     .unwrap()
     .run();
 
-    tx.send(srv.clone());
+    tx.send(srv.clone()).unwrap();
 }
 
 type UtilKVServer = Arc<RwLock<HashMap<String, Challenge>>>;
@@ -77,7 +58,7 @@ async fn util_server_retrive(
     let key = key.into_inner();
     let store = data.read().unwrap();
     let resp = store.get(&key).unwrap();
-    info!("key :{}, value: {:?}", key, resp);
+    info!("[kv-server] retrive: key :{}, value: {:?}", key, resp);
     HttpResponse::Ok().json(resp)
 }
 
@@ -87,7 +68,7 @@ async fn util_server_add(
     payload: web::Json<Challenge>,
     data: web::Data<UtilKVServer>,
 ) -> impl Responder {
-    info!("key :{}, value: {:?}", key, payload);
+    info!("[kv-server] cache: key :{}, value: {:?}", key, payload);
     let mut store = data.write().unwrap();
     store.insert(key.into_inner(), payload.into_inner());
     HttpResponse::Ok()

src/errors.rs

@@ -18,13 +18,13 @@
 use std::convert::From;
 
 use actix_web::{
-    client::SendRequestError,
     dev::HttpResponseBuilder,
     error::ResponseError,
     http::{header, StatusCode},
     HttpResponse,
 };
 use argon2_creds::errors::CredsError;
+use awc::error::SendRequestError;
 use derive_more::{Display, Error};
 use log::debug;
 use m_captcha::errors::CaptchaError;

src/main.rs

@@ -46,6 +46,8 @@ pub static PKG_NAME: &str = env!("CARGO_PKG_NAME");
 pub static PKG_DESCRIPTION: &str = env!("CARGO_PKG_DESCRIPTION");
 pub static PKG_HOMEPAGE: &str = env!("CARGO_PKG_HOMEPAGE");
 
+pub static VERIFICATION_PATH: &str = "mcaptchaVerificationChallenge.json";
+
 #[cfg(not(tarpaulin_include))]
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {