Merge pull request #125 from filecoin-project/feat/create-or-update-allocator

allocator create logic

Author: clriesco

fplus-http-server/src/main.rs

@@ -5,7 +5,6 @@ use actix_web::{App, HttpServer};
 use env_logger;
 use log::info;
 use fplus_database;
-
 pub(crate) mod router;
 
 #[tokio::main]
@@ -44,9 +43,9 @@ async fn main() -> std::io::Result<()> {
             .service(router::blockchain::verified_clients)
             .service(router::verifier::verifiers)
             .service(router::allocator::allocators)
-            .service(router::allocator::create_or_update)
             .service(router::allocator::allocator)
             .service(router::allocator::delete)
+            .service(router::allocator::create_from_json)
     })
     .bind(("0.0.0.0", 8080))?
     .run()

fplus-http-server/src/router/allocator.rs

@@ -1,6 +1,6 @@
 use actix_web::{get, post, put, delete, web, HttpResponse, Responder};
 use fplus_database::database;
-use fplus_lib::core::{Allocator, AllocatorUpdateInfo};
+use fplus_lib::core::{allocator::process_allocator_file, AllocatorUpdateInfo, ChangedAllocator};
 
 /**
  * Get all allocators
@@ -19,35 +19,47 @@ pub async fn allocators() -> impl Responder {
         },
     }
 }
-
 /**
- * Create a new allocator
+ * Creates new Allocator in the db from a JSON file in the repository
  * 
  * # Arguments
- * @param info: web::Json<Allocator> - The allocator information
+ * @param files: web::Json<ChangedAllocators> - The list of changed JSON file names
  * 
  * # Returns
  * @return HttpResponse - The result of the operation
  */
-#[post("/allocator")]
-pub async fn create_or_update(info: web::Json<Allocator>) -> impl Responder {
-    match database::create_or_update_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());
+#[post("/allocator/create")]
+pub async fn create_from_json(file: web::Json<ChangedAllocator>) -> actix_web::Result<impl Responder> {
+    let file_name = &file.file_changed;
+    log::info!("Starting allocator creation on:  {}", file_name);
+
+    match process_allocator_file(file_name).await {
+        Ok(model) => {
+            if model.multisig_address.is_empty() {
+                return Ok(HttpResponse::BadRequest().body("Missing or invalid multisig_address"));
             }
-            return HttpResponse::InternalServerError().body(e.to_string());
-        }
+            let verifiers_gh_handles = if model.application.verifiers_gh_handles.is_empty() {
+                None
+            } else {
+                Some(model.application.verifiers_gh_handles.join(", ")) // Join verifiers in a string if exists
+            };
+            
+            match database::create_or_update_allocator(
+                model.owner,
+                model.repo,
+                Some(model.installation_id as i64), 
+                Some(model.multisig_address),      
+                verifiers_gh_handles,
+            ).await {
+                Ok(allocator_model) => Ok(HttpResponse::Ok().json(allocator_model)),
+                Err(e) => Ok(HttpResponse::BadRequest().body(e.to_string())),
+            }
+        },
+        Err(e) => Ok(HttpResponse::BadRequest().body(e.to_string())),
     }
 }
 
+
 /**
  * Update an allocator
  * 

fplus-lib/src/base64.rs

@@ -1,15 +1,28 @@
-use std::io::Cursor;
-
+use base64::read::DecoderReader;
+use serde_json::from_reader;
 use base64;
 
-use crate::core::application::file::ApplicationFile;
+use crate::core::{allocator::file::AllocatorModel, application::file::ApplicationFile};
 
-pub fn decode(i: &str) -> Option<ApplicationFile> {
+pub fn decode_application_file(i: &str) -> Option<ApplicationFile> {
     let mut binding = Cursor::new(i);
-    let decoder = base64::read::DecoderReader::new(&mut binding, base64::STANDARD);
+    let decoder = DecoderReader::new(&mut binding, base64::STANDARD);
     let app_file: ApplicationFile = match serde_json::from_reader(decoder) {
         Ok(f) => f,
         Err(_) => return None,
     };
     Some(app_file)
 }
+
+use std::io::Cursor;
+
+
+pub fn decode_allocator_model(encoded_str: &str) -> Option<AllocatorModel> {
+    let mut binding = Cursor::new(encoded_str);
+    let decoder = DecoderReader::new(&mut binding, base64::STANDARD);
+
+    match from_reader(decoder) {
+        Ok(model) => Some(model),
+        Err(_) => None,
+    }
+}

fplus-lib/src/core/allocator/file.rs

@@ -0,0 +1,20 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct AllocatorModel {
+    #[serde(rename = "slug")]
+    pub repo: String,  
+    #[serde(rename = "organization")]
+    pub owner: String,
+    #[serde(rename = "address")]
+    pub multisig_address: String,
+    pub application: Application,
+    #[serde(rename = "common_ui_install_id")]
+    pub installation_id: u64, 
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Application {
+    #[serde(rename = "github_handles")]
+    pub verifiers_gh_handles: Vec<String>
+}

fplus-lib/src/core/allocator/mod.rs

@@ -0,0 +1,55 @@
+use octocrab::models::repos::ContentItems;
+
+use crate::{base64::decode_allocator_model, error::LDNError, external_services::github::GithubWrapper};
+
+use self::file::AllocatorModel;
+
+pub mod file;
+
+pub async fn process_allocator_file(file_name: &str) -> Result<AllocatorModel, LDNError> {
+
+    let owner = std::env::var("ALLOCATOR_GOVERNANCE_OWNER").unwrap_or_else(|_| {
+        log::warn!("ALLOCATOR_GOVERNANCE_OWNER not found in .env file");
+        "Allocator-Governance-Staging".to_string()
+    });
+    let repo = std::env::var("ALLOCATOR_GOVERNANCE_REPO").unwrap_or_else(|_| {
+        log::warn!("ALLOCATOR_GOVERNANCE_REPO not found in .env file");
+        "fidlabs".to_string()
+    });
+    let branch = "main";
+    let path = file_name.to_string();
+
+    let gh = GithubWrapper::new(owner.to_string(), repo.to_string());
+    let content_items = gh.get_file(&path, branch).await.map_err(|e| LDNError::Load(e.to_string()))?;
+    let model = content_items_to_allocator_model(content_items).map_err(|e| LDNError::Load(e.to_string()))?;
+
+    Ok(model)
+}
+
+
+fn content_items_to_allocator_model(file: ContentItems) -> Result<AllocatorModel, LDNError> {
+    let encoded_content = match file.items.get(0).and_then(|f| f.content.clone()) {
+        Some(content) => {
+            log::info!("Fetched content: {:?}", content);
+            content
+        },
+        None => {
+            log::error!("Allocator file is corrupted or empty");
+            return Err(LDNError::Load("Allocator file is corrupted".to_string()));
+        }
+    };
+
+    let cleaned_content = encoded_content.replace("\n", "");
+    log::info!("Cleaned content: {:?}", cleaned_content);
+
+    match decode_allocator_model(&cleaned_content) {
+        Some(model) => {
+            log::info!("Parsed allocator model successfully");
+            Ok(model)
+        },
+        None => {
+            log::error!("Failed to parse allocator model");
+            Err(LDNError::Load("Failed to parse allocator model".to_string()))
+        }
+    }
+}

fplus-lib/src/core/mod.rs

@@ -9,7 +9,7 @@ use reqwest::Response;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    base64,
+    base64::{self},
     config::get_env_var_or_default,
     error::LDNError,
     external_services::github::{
@@ -20,13 +20,13 @@ use crate::{
 use fplus_database::database;
 
 use self::application::file::{
-    AllocationRequest, AllocationRequestType, AppState, ApplicationFile, VerifierInput,
-    ValidVerifierList,
+    AllocationRequest, AllocationRequestType, AppState, ApplicationFile, ValidVerifierList, VerifierInput
 };
 use rayon::prelude::*;
 use crate::core::application::file::Allocation;
 
 pub mod application;
+pub mod allocator;
 
 #[derive(Deserialize)]
 pub struct CreateApplicationInfo {
@@ -98,6 +98,12 @@ pub struct Allocator {
     pub installation_id: Option<i64>,
     pub multisig_address: Option<String>,
     pub verifiers_gh_handles: Option<String>,
+
+
+}
+#[derive(Deserialize)]
+pub struct ChangedAllocator {
+    pub file_changed: String
 }
 
 #[derive(Deserialize)]
@@ -584,7 +590,7 @@ impl LDNApplication {
             .take_items()
             .get(0)
             .and_then(|f| f.content.clone())
-            .and_then(|f| base64::decode(&f.replace("\n", "")))
+            .and_then(|f| base64::decode_application_file(&f.replace("\n", "")))
             .ok_or(LDNError::Load(format!("Application file is corrupted",)))?;
         return Ok(ApplicationFile::from(f.clone()));
     }