dotenv support

database credentials loading from .env
removed db cred from constants
updated tests accordingly

.env

@@ -0,0 +1,5 @@
+DB_URL = "localhost:8000"
+DB_USER = "root"
+DB_PASS = "root"
+DB_NAMESPACE = "brain"
+DB_NAME = "migration"

Cargo.lock

@@ -1078,6 +1078,12 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
 
+[[package]]
+name = "dotenv"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77c90badedccf4105eca100756a0b1289e191f6fcbdadd3cee1d2f614f97da8f"
+
 [[package]]
 name = "earcutr"
 version = "0.4.3"
@@ -3777,6 +3783,7 @@ dependencies = [
  "chrono",
  "dashmap 6.1.0",
  "detee-shared",
+ "dotenv",
  "ed25519-dalek",
  "env_logger",
  "futures",

Cargo.toml

@@ -21,6 +21,7 @@ log = "0.4.27"
 env_logger = "0.11.8"
 thiserror = "2.0.12"
 nanoid = "0.4.0"
+dotenv = "0.15.0"
 
 [profile.release]
 lto = true

README.md

@@ -0,0 +1 @@
+# Brain Miration to SurrealDB

src/bin/brain.rs

@@ -3,9 +3,8 @@ use std::sync::Arc;
 use detee_shared::general_proto::brain_general_cli_server::BrainGeneralCliServer;
 use detee_shared::vm_proto::brain_vm_cli_server::BrainVmCliServer;
 use detee_shared::vm_proto::brain_vm_daemon_server::BrainVmDaemonServer;
-use surreal_brain::constants::{
+use dotenv::dotenv;
-    BRAIN_GRPC_ADDR, CERT_KEY_PATH, CERT_PATH, DB_ADDRESS, DB_NAME, DB_NS,
+use surreal_brain::constants::{BRAIN_GRPC_ADDR, CERT_KEY_PATH, CERT_PATH};
-};
 use surreal_brain::db;
 use surreal_brain::grpc::BrainVmCliForReal;
 use surreal_brain::grpc::{BrainGeneralCliForReal, BrainVmDaemonForReal};
@@ -13,9 +12,16 @@ use tonic::transport::{Identity, Server, ServerTlsConfig};
 
 #[tokio::main]
 async fn main() {
+    dotenv().ok();
     env_logger::builder().filter_level(log::LevelFilter::Debug).init();
 
-    let db = db::db_connection(DB_ADDRESS, DB_NS, DB_NAME).await.unwrap();
+    let db_url = std::env::var("DB_URL").expect("DB_URL not set in .env");
+    let db_user = std::env::var("DB_USER").expect("DB_USER not set in .env");
+    let db_pass = std::env::var("DB_PASS").expect("DB_PASS not set in .env");
+    let db_ns = std::env::var("DB_NAMESPACE").expect("DB_NAMESPACE not set in .env");
+    let db_name = std::env::var("DB_NAME").expect("DB_NAME not set in .env");
+
+    let db = db::db_connection(&db_url, &db_user, &db_pass, &db_ns, &db_name).await.unwrap();
     let db_arc = Arc::new(db);
 
     let addr = BRAIN_GRPC_ADDR.parse().unwrap();

src/bin/migration0.rs

@@ -1,17 +1,24 @@
 // After deleting this migration, also delete old_brain structs
 // and dangling impls from the model
+use dotenv::dotenv;
 use std::error::Error;
-use surreal_brain::constants::{DB_ADDRESS, DB_NAME, DB_NS};
 use surreal_brain::{db, old_brain};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
+    dotenv().ok();
     let old_brain_data = old_brain::BrainData::load_from_disk()?;
     // println!("{}", serde_yaml::to_string(&old_brain_data)?);
 
-    let db_connection = db::db_connection(DB_ADDRESS, DB_NS, DB_NAME).await.unwrap();
+    let db_url = std::env::var("DB_URL").expect("DB_URL not set in .env");
+    let db_user = std::env::var("DB_USER").expect("DB_USER not set in .env");
+    let db_pass = std::env::var("DB_PASS").expect("DB_PASS not set in .env");
+    let db_ns = std::env::var("DB_NAMESPACE").expect("DB_NAMESPACE not set in .env");
+    let db_name = std::env::var("DB_NAME").expect("DB_NAME not set in .env");
 
-    db::migration0(&db_connection, &old_brain_data).await?;
+    let db = db::db_connection(&db_url, &db_user, &db_pass, &db_ns, &db_name).await.unwrap();
+
+    db::migration0(&db, &old_brain_data).await?;
 
     Ok(())
 }

src/constants.rs

@@ -2,14 +2,6 @@ pub const BRAIN_GRPC_ADDR: &str = "0.0.0.0:31337";
 pub const CERT_PATH: &str = "./tmp/brain-crt.pem";
 pub const CERT_KEY_PATH: &str = "./tmp/brain-key.pem";
 
-pub const DB_ADDRESS: &str = "localhost:8000";
-pub const DB_NS: &str = "brain";
-pub const DB_NAME: &str = "migration";
-
-// TODO: read from .env
-pub const DB_USER: &str = "root";
-pub const DB_PASS: &str = "root";
-
 pub const DB_SCHEMA_FILE: &str = "interim_tables.surql";
 
 pub const ADMIN_ACCOUNTS: &[&str] = &[

src/db.rs

@@ -1,8 +1,8 @@
 use std::str::FromStr;
 
 pub use crate::constants::{
-    ACCOUNT, ACTIVE_VM, DB_ADDRESS, DB_NAME, DB_NS, DB_PASS, DB_SCHEMA_FILE, DB_USER, DELETED_VM,
+    ACCOUNT, ACTIVE_VM, DB_SCHEMA_FILE, DELETED_VM, ID_ALPHABET, NEW_VM_REQ, UPDATE_VM_REQ,
-    ID_ALPHABET, NEW_VM_REQ, UPDATE_VM_REQ, VM_CONTRACT, VM_NODE,
+    VM_CONTRACT, VM_NODE,
 };
 
 use crate::old_brain;
@@ -26,11 +26,17 @@ pub enum Error {
     StdIo(#[from] std::io::Error),
 }
 
-pub async fn db_connection(db_address: &str, ns: &str, db: &str) -> Result<Surreal<Client>, Error> {
+pub async fn db_connection(
+    db_address: &str,
+    username: &str,
+    password: &str,
+    ns: &str,
+    db: &str,
+) -> Result<Surreal<Client>, Error> {
     let db_connection: Surreal<Client> = Surreal::init();
     db_connection.connect::<Ws>(db_address).await?;
     // Sign in to the server
-    db_connection.signin(Root { username: DB_USER, password: DB_PASS }).await?;
+    db_connection.signin(Root { username, password }).await?;
     db_connection.use_ns(ns).use_db(db).await?;
     Ok(db_connection)
 }

tests/common/prepare_test_env.rs

@@ -3,30 +3,36 @@ use detee_shared::{
     general_proto::brain_general_cli_server::BrainGeneralCliServer,
     vm_proto::brain_vm_daemon_server::BrainVmDaemonServer,
 };
+use dotenv::dotenv;
 use hyper_util::rt::TokioIo;
 use std::net::SocketAddr;
 use std::sync::Arc;
 use surreal_brain::grpc::{BrainGeneralCliForReal, BrainVmCliForReal, BrainVmDaemonForReal};
+use surrealdb::engine::remote::ws::Client;
+use surrealdb::Surreal;
 use tokio::io::DuplexStream;
 use tokio::{net::TcpListener, sync::OnceCell};
 use tonic::transport::{Channel, Endpoint, Server, Uri};
 use tower::service_fn;
 
-use surrealdb::engine::remote::ws::Client;
-use surrealdb::Surreal;
-
-pub const DB_URL: &str = "localhost:8000";
-pub const DB_NS: &str = "test_brain";
-pub const DB_NAME: &str = "test_migration_db";
-
 pub static DB_STATE: OnceCell<()> = OnceCell::const_new();
 
 pub async fn prepare_test_db() -> Surreal<Client> {
-    let db = surreal_brain::db::db_connection(DB_URL, DB_NS, DB_NAME).await.unwrap();
+    dotenv().ok();
+
+    let db_url = std::env::var("DB_URL").expect("DB_URL not set in .env");
+    let db_user = std::env::var("DB_USER").expect("DB_USER not set in .env");
+    let db_pass = std::env::var("DB_PASS").expect("DB_PASS not set in .env");
+    let db_ns = "test_brain";
+    let db_name = "test_migration_db";
+
+    let db = surreal_brain::db::db_connection(&db_url, &db_user, &db_pass, &db_ns, &db_name)
+        .await
+        .unwrap();
     DB_STATE
         .get_or_init(|| async {
             let old_brain_data = surreal_brain::old_brain::BrainData::load_from_disk().unwrap();
-            db.query(format!("REMOVE DATABASE {DB_NAME}")).await.unwrap();
+            db.query(format!("REMOVE DATABASE {db_name}")).await.unwrap();
             db.query(std::fs::read_to_string("interim_tables.surql").unwrap()).await.unwrap();
             surreal_brain::db::migration0(&db, &old_brain_data).await.unwrap();
         })
@@ -35,11 +41,20 @@ pub async fn prepare_test_db() -> Surreal<Client> {
 }
 
 pub async fn run_service_in_background() -> SocketAddr {
+    dotenv().ok();
     let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
     let addr = listener.local_addr().unwrap();
 
+    let db_url = std::env::var("DB_URL").expect("DB_URL not set in .env");
+    let db_user = std::env::var("DB_USER").expect("DB_USER not set in .env");
+    let db_pass = std::env::var("DB_PASS").expect("DB_PASS not set in .env");
+    let db_ns = "test_brain";
+    let db_name = "test_migration_db";
+
     tokio::spawn(async move {
-        let db = surreal_brain::db::db_connection(DB_URL, DB_NS, DB_NAME).await.unwrap();
+        let db = surreal_brain::db::db_connection(&db_url, &db_user, &db_pass, &db_ns, &db_name)
+            .await
+            .unwrap();
         let db_arc = Arc::new(db);
 
         Server::builder()
@@ -57,10 +72,19 @@ pub async fn run_service_in_background() -> SocketAddr {
 }
 
 pub async fn run_service_for_stream_server() -> DuplexStream {
+    dotenv().ok();
     let (client, server) = tokio::io::duplex(1024);
 
+    let db_url = std::env::var("DB_URL").expect("DB_URL not set in .env");
+    let db_user = std::env::var("DB_USER").expect("DB_USER not set in .env");
+    let db_pass = std::env::var("DB_PASS").expect("DB_PASS not set in .env");
+    let db_ns = "test_brain";
+    let db_name = "test_migration_db";
+
     tokio::spawn(async move {
-        let db = surreal_brain::db::db_connection(DB_URL, DB_NS, DB_NAME).await.unwrap();
+        let db = surreal_brain::db::db_connection(&db_url, &db_user, &db_pass, &db_ns, &db_name)
+            .await
+            .unwrap();
         let db_arc = Arc::new(db);
 
         tonic::transport::Server::builder()