diff --git a/.github/workflows/deploy_to_staging.yml b/.github/workflows/deploy_to_staging.yml index 2ce3d167..ecb13176 100644 --- a/.github/workflows/deploy_to_staging.yml +++ b/.github/workflows/deploy_to_staging.yml @@ -17,6 +17,7 @@ jobs: - name: Run tests env: GH_PRIVATE_KEY: ${{ secrets.GH_STAGING_PRIVATE_KEY }} + DB_URL: ${{secrets.STAGING_DB_URL}} run: cargo test -- --nocapture deploy_to_staging: @@ -63,7 +64,8 @@ jobs: "8080": "HTTP" }, "environment": { - "GH_PRIVATE_KEY": "${{secrets.GH_STAGING_PRIVATE_KEY}}" + "GH_PRIVATE_KEY": "${{secrets.GH_STAGING_PRIVATE_KEY}}", + "DB_URL": "${{secrets.STAGING_DB_URL}}" } } }' > containers.json diff --git a/.github/workflows/end_to_end_tests.yml b/.github/workflows/end_to_end_tests.yml index f41de963..a8e5ba13 100644 --- a/.github/workflows/end_to_end_tests.yml +++ b/.github/workflows/end_to_end_tests.yml @@ -17,4 +17,5 @@ jobs: - name: Run tests env: GH_PRIVATE_KEY: ${{ secrets.GH_STAGING_PRIVATE_KEY }} + DB_URL: ${{secrets.STAGING_DB_URL}} run: cargo test -- --nocapture \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index 30bf5adb..361a407c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,7 +3,8 @@ members = [ "fplus-lib", "fplus-http-server", - "fplus-cli" + "fplus-cli", + "fplus-database" ] resolver = "2" diff --git a/fplus-database/Cargo.toml b/fplus-database/Cargo.toml index e295890f..5d017860 100644 --- a/fplus-database/Cargo.toml +++ b/fplus-database/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "fplus-database" -authors = ["jbesraa", "kokal33"] -version = "0.1.3" +authors = ["clriesco", "kokal33", "alexmcon"] +version = "1.0.19" edition = "2021" description = "FPlus main database module" license = "MIT OR Apache-2.0" @@ -10,7 +10,16 @@ repository = "https://github.com/filecoin-project/filplus-backend/tree/publish-t # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -actix-web = "4.4.0" +dotenv = "0.15.0" +env_logger = "0.10.0" +futures = "0.3.28" +sea-orm ={ version = "0.12", features = [ "sqlx-postgres", "runtime-tokio-native-tls", "macros" ] } anyhow = "1.0.75" -mongodb = {version = "2.7.0", features = ["openssl-tls"]} -serde = "1.0.188" +tokio = { version = "1", features = ["full"] } +log = "0.4.20" +chrono = "0.4.26" +once_cell = "1.8" +serde = { version = "1.0.164", features = ["derive", "std", +"serde_derive", "alloc", "rc"] } +serial_test = "3.0.0" + diff --git a/fplus-database/src/config.rs b/fplus-database/src/config.rs new file mode 100644 index 00000000..48fb73a7 --- /dev/null +++ b/fplus-database/src/config.rs @@ -0,0 +1,21 @@ +use log::warn; + +/** + * Get an environment variable or a default value + * + * # Arguments + * @param key: &str - The environment variable key + * @param default: &str - The default value + * + * # Returns + * @return String - The value of the environment variable or the default value + */ +pub fn get_env_var_or_default(key: &str, default: &str) -> String { + match std::env::var(key) { + Ok(val) => val, + Err(_) => { + warn!("{} not set, using default value: {}", key, default); + default.to_string() + } + } +} diff --git a/fplus-database/src/core/collections/govteam.rs b/fplus-database/src/core/collections/govteam.rs deleted file mode 100644 index 4c3f6b59..00000000 --- a/fplus-database/src/core/collections/govteam.rs +++ /dev/null @@ -1,40 +0,0 @@ -use actix_web::web; -use anyhow::Result; -use mongodb::{Client, Collection}; -use serde::{Deserialize, Serialize}; -use std::sync::Mutex; - -use crate::core::common::get_collection; - -const COLLECTION_NAME: &str = "govteam"; - -#[derive(Debug, Serialize, Deserialize)] -pub struct GovTeamMember { - pub github_handle: String, -} - -pub async fn find(state: web::Data>) -> Result> { - let govteam_collection: Collection = get_collection(state, COLLECTION_NAME).await?; - let mut cursor = govteam_collection.find(None, None).await?; - let mut ret = vec![]; - while let Ok(result) = cursor.advance().await { - if result { - let d = match cursor.deserialize_current() { - Ok(d) => d, - Err(_) => { - continue; - } - }; - ret.push(d); - } else { - break; - } - } - Ok(ret) -} - -pub async fn insert(state: web::Data>, govteam: GovTeamMember) -> Result<()> { - let govteam_collection: Collection = get_collection(state, COLLECTION_NAME).await?; - govteam_collection.insert_one(govteam, None).await?; - Ok(()) -} diff --git a/fplus-database/src/core/collections/logs.rs b/fplus-database/src/core/collections/logs.rs deleted file mode 100644 index 62134227..00000000 --- a/fplus-database/src/core/collections/logs.rs +++ /dev/null @@ -1,41 +0,0 @@ -use actix_web::web; -use anyhow::Result; -use mongodb::{Client, Collection}; -use serde::{Deserialize, Serialize}; -use std::sync::Mutex; - -use crate::core::common::get_collection; - -const COLLECTION_NAME: &str = "logs"; - -#[derive(Debug, Serialize, Deserialize)] -pub struct Log { - pub timestamp: String, - pub message: String, -} - -pub async fn find(state: web::Data>) -> Result> { - let logs_collection: Collection = get_collection(state, COLLECTION_NAME).await?; - let mut cursor = logs_collection.find(None, None).await?; - let mut ret = vec![]; - while let Ok(result) = cursor.advance().await { - if result { - let d = match cursor.deserialize_current() { - Ok(d) => d, - Err(_) => { - continue; - } - }; - ret.push(d); - } else { - break; - } - } - Ok(ret) -} - -pub async fn insert(state: web::Data>, log: Log) -> Result<()> { - let log_collection: Collection = get_collection(state, COLLECTION_NAME).await?; - log_collection.insert_one(log, None).await?; - Ok(()) -} diff --git a/fplus-database/src/core/collections/mod.rs b/fplus-database/src/core/collections/mod.rs deleted file mode 100644 index 5507d1d2..00000000 --- a/fplus-database/src/core/collections/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -pub mod logs; -pub mod notary; -pub mod govteam; diff --git a/fplus-database/src/core/collections/notary.rs b/fplus-database/src/core/collections/notary.rs deleted file mode 100644 index f300ba64..00000000 --- a/fplus-database/src/core/collections/notary.rs +++ /dev/null @@ -1,41 +0,0 @@ -use actix_web::web; -use anyhow::Result; -use mongodb::{Client, Collection}; -use serde::{Deserialize, Serialize}; -use std::sync::Mutex; - -use crate::core::common::get_collection; - -const COLLECTION_NAME: &str = "notary"; - -#[derive(Debug, Serialize, Deserialize)] -pub struct Notary { - pub github_handle: String, - pub on_chain_address: String, -} - -pub async fn find(state: web::Data>) -> Result> { - let notary_collection: Collection = get_collection(state, COLLECTION_NAME).await?; - let mut cursor = notary_collection.find(None, None).await?; - let mut ret = vec![]; - while let Ok(result) = cursor.advance().await { - if result { - let d = match cursor.deserialize_current() { - Ok(d) => d, - Err(_) => { - continue; - } - }; - ret.push(d); - } else { - break; - } - } - Ok(ret) -} - -pub async fn insert(state: web::Data>, notary: Notary) -> Result<()> { - let notary_collection: Collection = get_collection(state, COLLECTION_NAME).await?; - notary_collection.insert_one(notary, None).await?; - Ok(()) -} diff --git a/fplus-database/src/core/common.rs b/fplus-database/src/core/common.rs deleted file mode 100644 index f4e5edf6..00000000 --- a/fplus-database/src/core/common.rs +++ /dev/null @@ -1,18 +0,0 @@ -use actix_web::web; -use anyhow::Result; -use mongodb::{Client, Collection}; -use std::sync::Mutex; - -pub const DATABASE: &str = "fplus-db"; - -pub async fn get_collection( - state: web::Data>, - collection_name: &str, -) -> Result> { - let col: Collection = state - .lock() - .unwrap() - .database(DATABASE) - .collection(collection_name); - Ok(col) -} diff --git a/fplus-database/src/core/mod.rs b/fplus-database/src/core/mod.rs deleted file mode 100644 index 29c9fbb0..00000000 --- a/fplus-database/src/core/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -pub mod collections; -pub mod common; -pub mod setup; diff --git a/fplus-database/src/core/setup.rs b/fplus-database/src/core/setup.rs deleted file mode 100644 index c7a97439..00000000 --- a/fplus-database/src/core/setup.rs +++ /dev/null @@ -1,36 +0,0 @@ -use mongodb::{ - bson::doc, - options::{ClientOptions, ServerApi, ServerApiVersion, Tls, TlsOptions}, - 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 { - let key = "MONGODB_URL"; - let value = std::env::var(key).expect("Expected a MONGODB_URL in the environment"); - let mut client_options = ClientOptions::parse(value).await?; - - let mut tls_options = TlsOptions::default(); - tls_options.allow_invalid_hostnames = Some(true); - tls_options.allow_invalid_certificates = Some(true); - client_options.tls = Some(Tls::Enabled(tls_options)); - - // 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) -} diff --git a/fplus-database/src/database/mod.rs b/fplus-database/src/database/mod.rs new file mode 100644 index 00000000..2c979ff4 --- /dev/null +++ b/fplus-database/src/database/mod.rs @@ -0,0 +1,137 @@ +use sea_orm::{entity::*, query::*, DbErr}; +use crate::models::allocators::{Column, ActiveModel, Entity as Allocator, Model as AllocatorModel}; +use crate::get_database_connection; + +/** + * Get all allocators from the database + * + * # Returns + * @return Result, sea_orm::DbErr> - The result of the operation + */ +pub async fn get_allocators() ->Result, sea_orm::DbErr> { + let conn = get_database_connection().await?; + Allocator::find().all(&conn).await +} + +/** + * Update an allocator in the database + * + * # Arguments + * @param owner: &str - The owner of the repository + * @param repo: &str - The repository name + * @param installation_id: Option - The installation ID + * @param multisig_address: Option - The multisig address + * @param verifiers_gh_handles: Option - The GitHub handles of the verifiers + * + * # Returns + * @return Result - The result of the operation + */ +pub async fn update_allocator( + owner: &str, + repo: &str, + installation_id: Option, + multisig_address: Option, + verifiers_gh_handles: Option, +) -> Result { + let conn = get_database_connection().await?; + + let existing_allocator = get_allocator(owner, repo).await?; + if let Some(allocator_model) = existing_allocator { + let mut allocator_active_model = allocator_model.into_active_model(); + + allocator_active_model.installation_id = Set(installation_id); + allocator_active_model.multisig_address = Set(multisig_address); + allocator_active_model.verifiers_gh_handles = Set(verifiers_gh_handles); + + let updated_model = allocator_active_model.update(&conn).await?; + + Ok(updated_model) + } else { + Err(DbErr::Custom(format!("Allocator not found").into())) + } +} + +/** + * Get an allocator from the database + * + * # Arguments + * @param owner: &str - The owner of the repository + * @param repo: &str - The repository name + * + * # Returns + * @return Result, sea_orm::DbErr> - The result of the operation + */ +pub async fn get_allocator( + owner: &str, + repo: &str, +) -> Result, sea_orm::DbErr> { + let conn = get_database_connection().await?; + Allocator::find() + .filter(Column::Owner.eq(owner)) + .filter(Column::Repo.eq(repo)) + .one(&conn) + .await +} + +/** + * Create an allocator in the database + * + * # Arguments + * @param owner: String - The owner of the repository + * @param repo: String - The repository name + * @param installation_id: Option - The installation ID + * @param multisig_address: Option - The multisig address + * @param verifiers_gh_handles: Option - The GitHub handles of the verifiers + * + * # Returns + * @return Result - The result of the operation + */ +pub async fn create_allocator( + owner: String, + repo: String, + installation_id: Option, + multisig_address: Option, + verifiers_gh_handles: Option, +) -> Result { + + let existing_allocator = get_allocator(&owner, &repo).await?; + match existing_allocator { + Some(_) => return Err(DbErr::Custom(format!("Allocator already exists").into())), + None => (), + }; + let new_allocator = ActiveModel { + owner: Set(owner), + repo: Set(repo), + installation_id: Set(installation_id), + multisig_address: Set(multisig_address), + verifiers_gh_handles: Set(verifiers_gh_handles), + ..Default::default() + }; + + let conn = get_database_connection().await.expect("Failed to get DB connection"); + new_allocator.insert(&conn).await +} + +/** + * Delete an allocator from the database + * + * # Arguments + * @param owner: &str - The owner of the repository + * @param repo: &str - The repository name + * + * # Returns + * @return Result<(), sea_orm::DbErr> - The result of the operation + */ +pub async fn delete_allocator( + owner: &str, + repo: &str, +) -> Result<(), sea_orm::DbErr> { + let conn = get_database_connection().await?; + let allocator = get_allocator(owner, repo).await?; + let allocator = match allocator { + Some(allocator) => allocator, + None => return Err(DbErr::Custom(format!("Allocator not found").into())), + }; + allocator.delete(&conn).await?; + Ok(()) +} \ No newline at end of file diff --git a/fplus-database/src/lib.rs b/fplus-database/src/lib.rs index 5a7ca06a..0752539c 100644 --- a/fplus-database/src/lib.rs +++ b/fplus-database/src/lib.rs @@ -1 +1,235 @@ -pub mod core; +pub mod models; +pub mod database; +pub mod config; + +use sea_orm::{Database, DatabaseConnection, DbErr}; +use once_cell::sync::Lazy; +use std::sync::Mutex; +use crate::config::get_env_var_or_default; + +/** + * The global database connection + */ +static DB_CONN: Lazy>> = Lazy::new(|| Mutex::new(None)); + +/** + * Initialize the database (Just for testing purposes, not used in the actual application, as dotenv is called in the main function of the application) + * + * # Returns + * @return () - The result of the operation + */ +pub fn init() { + dotenv::dotenv().ok(); +} + +/** + * Establish a connection to the database + * + * # Returns + * @return Result - The result of the operation + */ +pub async fn setup() -> Result<(), DbErr> { + let database_url = get_env_var_or_default("DB_URL", ""); + let db_conn = Database::connect(&database_url).await?; + let mut db_conn_global = DB_CONN.lock().unwrap(); + *db_conn_global = Some(db_conn); + Ok(()) +} + +/** + * Get a reference to the established database connection + * + * # Returns + * @return Result - The database connection or an error message + */ +pub async fn get_database_connection() -> Result { + let db_conn = DB_CONN.lock().unwrap(); + if let Some(ref conn) = *db_conn { + Ok(conn.clone()) + } else { + Err(DbErr::Custom("Database connection is not established".into())) + } +} +#[cfg(test)] +mod tests { + + use super::*; + use tokio; + use serial_test::serial; + + /** + * Sets up the initial test environment (database connection and env variables) + */ + async fn setup_test_environment() { + init(); + setup().await.expect("Failed to setup database connection."); + } + + /** + * Test the establish_connection function + * + * # Returns + * @return () - The result of the test + */ + #[tokio::test] + #[serial] + async fn test_establish_connection_with_env_url() { + init(); + let connection_result = setup().await; + assert!(connection_result.is_ok()); + } + + /** + * Test the create_allocator function + * + * # Returns + * @return () - The result of the test + */ + #[tokio::test] + #[serial] + async fn test_create_allocator() { + setup_test_environment().await; + + let owner = "test_owner".to_string(); + let repo = "test_repo".to_string(); + + let existing_allocator = database::get_allocator(&owner, &repo).await.unwrap(); + if let Some(_) = existing_allocator { + let result = database::delete_allocator(&owner, &repo).await; + return assert!(result.is_ok()); + } + + let installation_id = Some(1234); + let multisig_address = Some("0x1234567890".to_string()); + let verifiers_gh_handles = Some("test_verifier_1, test_verifier_2".to_string()); + + let result = database::create_allocator( + owner, + repo, + installation_id, + multisig_address, + verifiers_gh_handles + ).await; + assert!(result.is_ok()); + } + + /** + * Test the get_allocators function + * + * # Returns + * @return () - The result of the test + */ + #[tokio::test] + #[serial] + async fn test_get_allocators() { + setup_test_environment().await; + + let result = database::get_allocators().await; + assert!(result.is_ok()); + } + + /** + * Test the update_allocator function + * + * # Returns + * @return () - The result of the test + */ + #[tokio::test] + #[serial] + async fn test_update_allocator() { + setup_test_environment().await; + + let allocator = database::get_allocator("test_owner", "test_repo") + .await + .expect("Allocator not found"); + if allocator.is_none() { + let owner = "test_owner".to_string(); + let repo = "test_repo".to_string(); + let installation_id = Some(1234); + let multisig_address = Some + ("0x1234567890".to_string()); + let verifiers_gh_handles = Some("test_verifier_1, test_verifier_2".to_string()); + + let result = database::create_allocator( + owner.clone(), + repo.clone(), + installation_id, + multisig_address, + verifiers_gh_handles + ).await; + assert!(result.is_ok()); + } + + let owner = "test_owner".to_string(); + let repo = "test_repo".to_string(); + let installation_id = Some(1234); + let multisig_address = Some("0x0987654321".to_string()); + let verifiers_gh_handles = Some("test_verifier_3, test_verifier_4".to_string()); + + let result = database::update_allocator( + &owner, + &repo, + installation_id, + multisig_address, + verifiers_gh_handles + ).await; + assert!(result.is_ok()); + } + + /** + * Test the get_allocator function + * + * # Returns + * @return () - The result of the test + */ + #[tokio::test] + #[serial] + async fn test_get_allocator() { + setup_test_environment().await; + + let allocator = database::get_allocators().await.expect("Failed to get allocators").pop().expect("No allocators found"); + + let result = database::get_allocator(&allocator.owner, &allocator.repo).await; + assert!(result.is_ok()); + } + + /** + * Test the delete_allocator function + * + * # Returns + * @return () - The result of the test + */ + #[tokio::test] + #[serial] + async fn test_delete_allocator() { + setup_test_environment().await; + + let owner = "test_owner".to_string(); + let repo = "test_repo".to_string(); + + let existing_allocator = database::get_allocator(&owner, &repo).await.unwrap(); + if let Some(_) = existing_allocator { + let result = database::delete_allocator(&owner, &repo).await; + return assert!(result.is_ok()); + } + + let installation_id = Some(1234); + let multisig_address = Some("0x1234567890".to_string()); + let verifiers_gh_handles = Some("test_verifier_1, test_verifier_2".to_string()); + + let result = database::create_allocator( + owner.clone(), + repo.clone(), + installation_id, + multisig_address, + verifiers_gh_handles + ).await; + + assert!(result.is_ok()); + + let result = database::delete_allocator(&owner, &repo).await; + assert!(result.is_ok()); + + } + +} \ No newline at end of file diff --git a/fplus-database/src/models/allocators.rs b/fplus-database/src/models/allocators.rs new file mode 100644 index 00000000..b0a8ffba --- /dev/null +++ b/fplus-database/src/models/allocators.rs @@ -0,0 +1,22 @@ +//! `SeaORM` Entity. Generated by sea-orm-codegen 0.12.14 + +use sea_orm::entity::prelude::*; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)] +#[sea_orm(table_name = "allocators")] +pub struct Model { + #[sea_orm(primary_key)] + pub id: i32, + pub owner: String, + pub repo: String, + pub installation_id: Option, + pub multisig_address: Option, + #[sea_orm(column_type = "Text", nullable)] + pub verifiers_gh_handles: Option, +} + +#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)] +pub enum Relation {} + +impl ActiveModelBehavior for ActiveModel {} diff --git a/fplus-database/src/models/mod.rs b/fplus-database/src/models/mod.rs new file mode 100644 index 00000000..5ef71648 --- /dev/null +++ b/fplus-database/src/models/mod.rs @@ -0,0 +1,5 @@ +//! `SeaORM` Entity. Generated by sea-orm-codegen 0.12.14 + +pub mod prelude; + +pub mod allocators; diff --git a/fplus-database/src/models/prelude.rs b/fplus-database/src/models/prelude.rs new file mode 100644 index 00000000..6eb2dd59 --- /dev/null +++ b/fplus-database/src/models/prelude.rs @@ -0,0 +1,3 @@ +//! `SeaORM` Entity. Generated by sea-orm-codegen 0.12.14 + +pub use super::allocators::Entity as Allocators; diff --git a/fplus-database/tests/connection_tests.rs b/fplus-database/tests/connection_tests.rs new file mode 100644 index 00000000..e69de29b diff --git a/fplus-http-server/Cargo.toml b/fplus-http-server/Cargo.toml index dbda027a..28dacb6f 100644 --- a/fplus-http-server/Cargo.toml +++ b/fplus-http-server/Cargo.toml @@ -21,6 +21,7 @@ reqwest = { version = "0.11.18", features = ["json"] } futures = "0.3.28" dotenv = "0.15.0" fplus-lib = { path = "../fplus-lib", version = "1.0.19" } +fplus-database = { path = "../fplus-database", version = "1.0.19"} anyhow = "1.0.75" async-trait = "0.1.73" uuidv4 = "1.0.0" diff --git a/fplus-http-server/src/main.rs b/fplus-http-server/src/main.rs index e78ae629..268d2827 100644 --- a/fplus-http-server/src/main.rs +++ b/fplus-http-server/src/main.rs @@ -4,6 +4,7 @@ use actix_web::middleware::Logger; use actix_web::{App, HttpServer}; use env_logger; use log::info; +use fplus_database; pub(crate) mod router; @@ -14,6 +15,9 @@ async fn main() -> std::io::Result<()> { env_logger::init_from_env(env_logger::Env::new().default_filter_or("info")); info!("Logger initialized at log level: {}", log_level); + if let Err(e) = fplus_database::setup().await { + panic!("Failed to setup database connection: {}", e); + } HttpServer::new(move || { let cors = actix_cors::Cors::default() .allow_any_origin() @@ -41,6 +45,11 @@ async fn main() -> std::io::Result<()> { .service(router::notary::notaries) .service(router::notary::ldn_actors) .service(router::govteam::gov_team_members) + .service(router::allocator::allocators) + .service(router::allocator::create) + .service(router::allocator::update) + .service(router::allocator::allocator) + .service(router::allocator::delete) }) .bind(("0.0.0.0", 8080))? .run() diff --git a/fplus-http-server/src/router/allocator.rs b/fplus-http-server/src/router/allocator.rs new file mode 100644 index 00000000..12b74a2a --- /dev/null +++ b/fplus-http-server/src/router/allocator.rs @@ -0,0 +1,130 @@ +use actix_web::{get, post, put, delete, web, HttpResponse, Responder}; +use fplus_database::database; +use fplus_lib::core::{Allocator, AllocatorUpdateInfo}; + +/** + * Get all allocators + * + * # Returns + * @return HttpResponse - The result of the operation + */ +#[get("/allocators")] +pub async fn allocators() -> impl Responder { + let allocators = database::get_allocators().await; + match allocators { + Ok(allocators) => HttpResponse::Ok().json(allocators), + Err(e) => { + log::error!("Failed to fetch allocators: {}", e); + HttpResponse::InternalServerError().body(e.to_string()) + }, + } +} + +/** + * Create a new allocator + * + * # Arguments + * @param info: web::Json - The allocator information + * + * # Returns + * @return HttpResponse - The result of the operation + */ +#[post("/allocator")] +pub async fn create(info: web::Json) -> impl Responder { + match database::create_allocator( + info.owner.clone(), + info.repo.clone(), + info.installation_id, + info.multisig_address.clone(), + info.verifiers_gh_handles.clone(), + ).await { + Ok(allocator_model) => HttpResponse::Ok().json(allocator_model), + Err(e) => { + if e.to_string().contains("Allocator already exists") { + return HttpResponse::BadRequest().body(e.to_string()); + } + return HttpResponse::InternalServerError().body(e.to_string()); + } + } +} + +/** + * Update an allocator + * + * # Arguments + * @param path: web::Path<(String, String)> - The owner and repo of the allocator + * @param info: web::Json - The updated allocator information + * + * # Returns + * @return HttpResponse - The result of the operation + */ +#[put("/allocator/{owner}/{repo}")] +pub async fn update( + path: web::Path<(String, String)>, + info: web::Json +) -> impl Responder { + let (owner, repo) = path.into_inner(); + match database::update_allocator( + &owner, + &repo, + info.installation_id, + info.multisig_address.clone(), + info.verifiers_gh_handles.clone(), + ).await { + Ok(allocator_model) => HttpResponse::Ok().json(allocator_model), + Err(e) => { + if e.to_string().contains("Allocator not found") { + return HttpResponse::NotFound().body(e.to_string()); + } + return HttpResponse::InternalServerError().body(e.to_string()); + } + } +} + +/** + * Get an allocator + * + * # Arguments + * @param path: web::Path<(String, String)> - The owner and repo of the allocator + * + * # Returns + * @return HttpResponse - The result of the operation + */ +#[get("/allocator/{owner}/{repo}")] +pub async fn allocator(path: web::Path<(String, String)>) -> impl Responder { + let (owner, repo) = path.into_inner(); + match database::get_allocator(&owner, &repo).await { + Ok(allocator) => { + match allocator { + Some(allocator) => HttpResponse::Ok().json(allocator), + None => HttpResponse::NotFound().finish(), + } + }, + Err(e) => { + HttpResponse::InternalServerError().body(e.to_string()) + } + } +} + +/** + * Delete an allocator + * + * # Arguments + * @param path: web::Path<(String, String)> - The owner and repo of the allocator + * + * # Returns + * @return HttpResponse - The result of the operation + */ +#[delete("/allocator/{owner}/{repo}")] +pub async fn delete(path: web::Path<(String, String)>) -> impl Responder { + let (owner, repo) = path.into_inner(); + match database::delete_allocator(&owner, &repo).await { + Ok(_) => HttpResponse::Ok().finish(), + Err(e) => { + if e.to_string().contains("Allocator not found") { + return HttpResponse::NotFound().body(e.to_string()); + } + return HttpResponse::InternalServerError().body(e.to_string()); + } + } +} \ No newline at end of file diff --git a/fplus-http-server/src/router/mod.rs b/fplus-http-server/src/router/mod.rs index ff9070fc..c048e93f 100644 --- a/fplus-http-server/src/router/mod.rs +++ b/fplus-http-server/src/router/mod.rs @@ -4,6 +4,7 @@ pub mod application; pub mod blockchain; pub mod govteam; pub mod notary; +pub mod allocator; /// Return server health status #[get("/health")] diff --git a/fplus-lib/src/core/allocator/mod.rs b/fplus-lib/src/core/allocator/mod.rs new file mode 100644 index 00000000..e69de29b diff --git a/fplus-lib/src/core/mod.rs b/fplus-lib/src/core/mod.rs index eb5e3c21..83b5ced0 100644 --- a/fplus-lib/src/core/mod.rs +++ b/fplus-lib/src/core/mod.rs @@ -74,6 +74,22 @@ pub struct ValidationIssueData { pub user_handle: String, } +#[derive(Deserialize)] +pub struct Allocator { + pub owner: String, + pub repo: String, + pub installation_id: Option, + pub multisig_address: Option, + pub verifiers_gh_handles: Option, +} + +#[derive(Deserialize)] +pub struct AllocatorUpdateInfo { + pub installation_id: Option, + pub multisig_address: Option, + pub verifiers_gh_handles: Option, +} + impl LDNApplication { pub async fn single_active(pr_number: u64) -> Result { let gh: GithubWrapper = GithubWrapper::new(); diff --git a/fplus-lib/src/external_services/github.rs b/fplus-lib/src/external_services/github.rs index 1c53b4b7..c83232f9 100644 --- a/fplus-lib/src/external_services/github.rs +++ b/fplus-lib/src/external_services/github.rs @@ -90,17 +90,17 @@ impl GithubWrapper { pub fn new() -> Self { let owner = get_env_var_or_default("GITHUB_OWNER", "filecoin-project"); let repo = get_env_var_or_default("GITHUB_REPO", "filplus-tooling-backend-test"); - let app_id = get_env_var_or_default("GITHUB_APP_ID", "373258") + let app_id = get_env_var_or_default("GITHUB_APP_ID", "826129") .parse::() .unwrap_or_else(|_| { log::error!("Failed to parse GITHUB_APP_ID, using default"); - 373258 + 826129 }); - let installation_id = get_env_var_or_default("GITHUB_INSTALLATION_ID", "40514592") + let installation_id = get_env_var_or_default("GITHUB_INSTALLATION_ID", "47207972") .parse::() .unwrap_or_else(|_| { log::error!("Failed to parse GITHUB_INSTALLATION_ID, using default"); - 40514592 + 47207972 }); let gh_private_key = std::env::var("GH_PRIVATE_KEY").unwrap_or_else(|_| { log::warn!(