Feat/db setup

Cargo.toml

@@ -27,3 +27,4 @@ structopt = { version = "0.3", default-features = false }
 actix-cors = "0.6.4"
 reqwest = { version = "0.11.18", features = ["json"] }
 futures = "0.3.28"
+mongodb = "2.6.1"

src/db/collections/mod.rs

@@ -0,0 +1 @@
+pub mod logs;

src/db/mod.rs

@@ -0,0 +1,2 @@
+pub mod collections;
+pub mod setup;

src/db/setup.rs

@@ -0,0 +1,32 @@
+use dotenv;
+use mongodb::{
+    bson::doc,
+    options::{ClientOptions, ServerApi, ServerApiVersion},
+    Client,
+};
+
+pub async fn db_health_check(client: Client) -> mongodb::error::Result<()> {
+    // Ping the server to see if you can connect to the cluster
+    client
+        .database("admin")
+        .run_command(doc! {"ping": 1}, None)
+        .await?;
+    println!("Pinged your deployment. You successfully connected to MongoDB!");
+
+    Ok(())
+}
+
+pub async fn setup() -> mongodb::error::Result<Client> {
+    let key = "MONGODB_URL";
+    let value = dotenv::var(key).expect("Expected a MONGODB_URL in the environment");
+    let mut client_options = ClientOptions::parse(value).await?;
+
+    // Set the server_api field of the client_options object to Stable API version 1
+    let server_api = ServerApi::builder().version(ServerApiVersion::V1).build();
+    client_options.server_api = Some(server_api);
+
+    // Get a handle to the cluster
+    let client = Client::with_options(client_options)?;
+
+    Ok(client)
+}

src/main.rs

@@ -1,11 +1,14 @@
 extern crate markdown;
 
+use std::sync::Mutex;
+
 use actix_web::middleware::Logger;
-use actix_web::{App, HttpServer};
+use actix_web::{App, HttpServer, web};
 use env_logger;
 
 pub(crate) mod b64;
 pub(crate) mod core;
+pub(crate) mod db;
 pub(crate) mod external_services;
 pub(crate) mod parsers;
 pub(crate) mod router;
@@ -26,13 +29,19 @@ pub(crate) mod router;
 #[tokio::main]
 async fn main() -> std::io::Result<()> {
     env_logger::init_from_env(env_logger::Env::new().default_filter_or("debug"));
+    let client =match  db::setup::setup().await {
+        Ok(client) => client,
+        Err(e) => panic!("Error setting up database: {}", e),
+    };
 
+    let state = web::Data::new(Mutex::new(client));
     HttpServer::new(move || {
         let cors = actix_cors::Cors::default()
             .allow_any_origin()
             .allow_any_method()
             .allow_any_header();
         App::new()
+            .app_data(state.clone())
             .wrap(Logger::default())
             .wrap(cors)
             .service(router::health)

src/router/mod.rs

@@ -1,10 +1,16 @@
+use std::sync::Mutex;
+
 use actix_web::{get, HttpResponse, Responder};
 
 pub mod application;
 pub mod blockchain;
 
 /// Return server health status
 #[get("/health")]
-pub async fn health() -> impl Responder {
-    HttpResponse::Ok().body("OK")
+pub async fn health(client: actix_web::web::Data<Mutex<mongodb::Client>>) -> impl Responder {
+    let client = client.lock().unwrap();
+    match crate::db::setup::db_health_check(client.clone()).await {
+        Ok(_) => HttpResponse::Ok().body("OK"),
+        Err(e) => HttpResponse::InternalServerError().body(format!("Error: {}", e)),
+    }
 }