Merge pull request #111 from filecoin-project/fix/change-rkh-govteam

clriesco · web-flow · commit 831f33e0bdcb · 2024-02-01T12:33:08.000+01:00
Changed rkh -&gt; gov team
diff --git a/fplus-cli/src/main.rs b/fplus-cli/src/main.rs
@@ -14,7 +14,7 @@ fn cli() -> Command {
             Command::new("validate-trigger")
                 .about("Validates triggering an application")
                 .arg(arg!(<PR_NUMBER> "Pull Request Number"))
-                .arg(arg!(<RKH_GITHUB_HANDLE> "Github handle of Root Key Holder"))
+                .arg(arg!(<GOV_GITHUB_HANDLE> "Github handle of Gov Team Member"))
                 .arg_required_else_help(true),
         )
         .subcommand(
@@ -41,10 +41,10 @@ async fn main() -> std::io::Result<()> {
             let pull_request_number = sub_matches
                 .get_one::<String>("PR_NUMBER")
                 .expect("required");
-            let rkh_gh_handle = sub_matches
-                .get_one::<String>("RKH_GITHUB_HANDLE")
+            let gov_gh_handle = sub_matches
+                .get_one::<String>("GOV_GITHUB_HANDLE")
                 .expect("required");
-            validate_trigger(rkh_gh_handle.to_string(), pull_request_number.to_string()).await;
+            validate_trigger(gov_gh_handle.to_string(), pull_request_number.to_string()).await;
         }
         Some(("validate-proposal", sub_matches)) => {
             let pull_request_number = sub_matches
diff --git a/fplus-cli/src/validators.rs b/fplus-cli/src/validators.rs
@@ -1,6 +1,6 @@
 pub async fn validate_trigger(github_handle: String, pull_request_number: String) -> bool {
     true
-    // if validate_rkh_holder(&github_handle).await {
+    // if validate_gov_team_member(&github_handle).await {
     //     println!(
     //         "Validated Root Key Holder {} for application {}",
     //         &github_handle, pull_request_number
@@ -37,18 +37,18 @@ pub async fn validate_approval(github_handle: String, pull_request_number: Strin
     // }
 }
 
-async fn validate_rkh_holder(github_handle: &str) -> bool {
+async fn validate_gov_team_member(github_handle: &str) -> bool {
     true
     // let db_connection: web::Data<Mutex<mongodb::Client>> = web::Data::new(Mutex::new(
     //     fplus_database::core::setup::setup().await.unwrap(),
     // ));
-    // let rkh_holders = fplus_database::core::collections::rkh::find(db_connection)
+    // let gov_team_members = fplus_database::core::collections::govteam::find(db_connection)
     //     .await
     //     .unwrap();
-    // let rkh_holders: Option<fplus_database::core::collections::rkh::RootKeyHolder> = rkh_holders
+    // let gov_team_members: Option<fplus_database::core::collections::govteam::GovTeamMember> = gov_team_members
     //     .into_iter()
-    //     .find(|rkh| &rkh.github_handle == github_handle);
-    // if rkh_holders.is_none() {
+    //     .find(|gov| &gov.github_handle == github_handle);
+    // if gov_team_members.is_none() {
     //     false
     // } else {
     //     true
diff --git a/fplus-database/src/core/collections/govteam.rs b/fplus-database/src/core/collections/govteam.rs
@@ -6,16 +6,16 @@ use std::sync::Mutex;
 
 use crate::core::common::get_collection;
 
-const COLLECTION_NAME: &str = "rkh";
+const COLLECTION_NAME: &str = "govteam";
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct RootKeyHolder {
+pub struct GovTeamMember {
     pub github_handle: String,
 }
 
-pub async fn find(state: web::Data<Mutex<Client>>) -> Result<Vec<RootKeyHolder>> {
-    let rkh_collection: Collection<RootKeyHolder> = get_collection(state, COLLECTION_NAME).await?;
-    let mut cursor = rkh_collection.find(None, None).await?;
+pub async fn find(state: web::Data<Mutex<Client>>) -> Result<Vec<GovTeamMember>> {
+    let govteam_collection: Collection<GovTeamMember> = 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 {
@@ -33,8 +33,8 @@ pub async fn find(state: web::Data<Mutex<Client>>) -> Result<Vec<RootKeyHolder>>
     Ok(ret)
 }
 
-pub async fn insert(state: web::Data<Mutex<Client>>, rkh: RootKeyHolder) -> Result<()> {
-    let rkh_collection: Collection<RootKeyHolder> = get_collection(state, COLLECTION_NAME).await?;
-    rkh_collection.insert_one(rkh, None).await?;
+pub async fn insert(state: web::Data<Mutex<Client>>, govteam: GovTeamMember) -> Result<()> {
+    let govteam_collection: Collection<GovTeamMember> = get_collection(state, COLLECTION_NAME).await?;
+    govteam_collection.insert_one(govteam, None).await?;
     Ok(())
 }
diff --git a/fplus-database/src/core/collections/mod.rs b/fplus-database/src/core/collections/mod.rs
@@ -1,3 +1,3 @@
 pub mod logs;
 pub mod notary;
-pub mod rkh;
+pub mod govteam;
diff --git a/fplus-http-server/Cargo.toml b/fplus-http-server/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "fplus-http-server"
 authors = ["jbesraa", "kokal33", "clriesco"]
-version = "1.0.18"
+version = "1.0.19"
 description = "FPlus main http module"
 license = "MIT OR Apache-2.0"
 edition = "2021"
@@ -20,7 +20,7 @@ actix-cors = "0.6.4"
 reqwest = { version = "0.11.18", features = ["json"] }
 futures = "0.3.28"
 dotenv = "0.15.0"
-fplus-lib = { path = "../fplus-lib", version = "1.0.18" }
+fplus-lib = { path = "../fplus-lib", 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
@@ -40,7 +40,7 @@ async fn main() -> std::io::Result<()> {
             .service(router::blockchain::verified_clients)
             .service(router::notary::notaries)
             .service(router::notary::ldn_actors)
-            .service(router::rkh::rkhs)
+            .service(router::govteam::gov_team_members)
     })
     .bind(("0.0.0.0", 8080))?
     .run()
diff --git a/fplus-http-server/src/router/govteam.rs b/fplus-http-server/src/router/govteam.rs
@@ -1,9 +1,9 @@
 use actix_web::{get, HttpResponse, Responder};
 use fplus_lib::core::LDNApplication;
 
-#[get("/rkhs")]
-pub async fn rkhs() -> actix_web::Result<impl Responder> {
-    match LDNApplication::fetch_rkh().await {
+#[get("/gov-team-members")]
+pub async fn gov_team_members() -> actix_web::Result<impl Responder> {
+    match LDNApplication::fetch_gov().await {
         Ok(notaries) => {
             Ok(HttpResponse::Ok().json(notaries))
         }
diff --git a/fplus-http-server/src/router/mod.rs b/fplus-http-server/src/router/mod.rs
@@ -2,7 +2,7 @@ use actix_web::{get, HttpResponse, Responder};
 
 pub mod application;
 pub mod blockchain;
-pub mod rkh;
+pub mod govteam;
 pub mod notary;
 
 /// Return server health status
diff --git a/fplus-http-server/src/router/notary.rs b/fplus-http-server/src/router/notary.rs
@@ -15,7 +15,7 @@ pub async fn notaries() -> actix_web::Result<impl Responder> {
 
 #[get("/ldn-actors")]
 pub async fn ldn_actors() -> actix_web::Result<impl Responder> {
-    match LDNApplication::fetch_rkh_and_notary_gh_users().await {
+    match LDNApplication::fetch_gov_and_notary_gh_users().await {
         Ok((governance_gh_handles, notary_gh_handles)) => {
             let response = LDNActorsResponse { governance_gh_handles, notary_gh_handles };
             Ok(HttpResponse::Ok().json(response))
diff --git a/fplus-lib/Cargo.toml b/fplus-lib/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "fplus-lib"
 authors = ["jbesraa", "kokal33", "clriesco"]
-version = "1.0.18"
+version = "1.0.19"
 edition = "2021"
 description = "FPlus library/helper files"
 license = "MIT OR Apache-2.0"
diff --git a/fplus-lib/src/base64.rs b/fplus-lib/src/base64.rs
@@ -2,7 +2,7 @@ use std::io::Cursor;
 
 use base64;
 
-use crate::core::application::file::{ApplicationFile, ValidNotaryList, ValidRKHList};
+use crate::core::application::file::{ApplicationFile, ValidNotaryList, ValidGovTeamList};
 
 pub fn decode(i: &str) -> Option<ApplicationFile> {
     let mut binding = Cursor::new(i);
@@ -24,12 +24,12 @@ pub fn decode_notary(i: &str) -> Option<ValidNotaryList> {
     Some(notaries)
 }
 
-pub fn decode_rkh(i: &str) -> Option<ValidRKHList> {
+pub fn decode_gov_team(i: &str) -> Option<ValidGovTeamList> {
     let mut binding = Cursor::new(i);
     let decoder = base64::read::DecoderReader::new(&mut binding, base64::STANDARD);
-    let rkh: ValidRKHList = match serde_json::from_reader(decoder) {
+    let gov_team: ValidGovTeamList = match serde_json::from_reader(decoder) {
         Ok(f) => f,
         Err(_) => return None,
     };
-    Some(rkh)
+    Some(gov_team)
 }
diff --git a/fplus-lib/src/core/application/file.rs b/fplus-lib/src/core/application/file.rs
@@ -385,13 +385,13 @@ impl ValidNotaryList {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ValidRKHList {
-    pub rkh: Vec<String>,
+pub struct ValidGovTeamList {
+    pub gov_team: Vec<String>,
 }
 
-impl ValidRKHList {
-    pub fn is_valid(&self, rkh: &str) -> bool {
-        self.rkh.contains(&rkh.to_string())
+impl ValidGovTeamList {
+    pub fn is_valid(&self, member: &str) -> bool {
+        self.gov_team.contains(&member.to_string())
     }
 }
 
diff --git a/fplus-lib/src/core/mod.rs b/fplus-lib/src/core/mod.rs
@@ -20,7 +20,7 @@ use crate::{
 
 use self::application::file::{
     AllocationRequest, AllocationRequestType, AppState, ApplicationFile, NotaryInput,
-    ValidNotaryList, ValidRKHList,
+    ValidNotaryList, ValidGovTeamList,
 };
 use rayon::prelude::*;
 use crate::core::application::file::Allocation;
@@ -537,23 +537,23 @@ impl LDNApplication {
         }
     }
 
-    pub async fn fetch_rkh() -> Result<ValidRKHList, LDNError> {
+    pub async fn fetch_gov() -> Result<ValidGovTeamList, LDNError> {
         let gh = GithubWrapper::new();
-        let rkh = gh
-            .get_file("data/rkh.json", "main")
+        let gov_team = gh
+            .get_file("data/govteam.json", "main")
             .await
-            .map_err(|e| LDNError::Load(format!("Failed to retrieve rkh /// {}", e)))?;
+            .map_err(|e| LDNError::Load(format!("Failed to retrieve gov team /// {}", e)))?;
 
-        let rkh = &rkh.items[0]
+        let gov_team = &gov_team.items[0]
             .content
             .clone()
-            .and_then(|f| base64::decode_rkh(&f.replace("\n", "")))
+            .and_then(|f| base64::decode_gov_team(&f.replace("\n", "")))
             .and_then(|f| Some(f));
 
-        if let Some(rkh) = rkh {
-            return Ok(rkh.clone());
+        if let Some(gov_team) = gov_team {
+            return Ok(gov_team.clone());
         } else {
-            return Err(LDNError::Load(format!("Failed to retrieve notaries ///")));
+            return Err(LDNError::Load(format!("Failed to retrieve gov team ///")));
         }
     }
 
@@ -802,7 +802,7 @@ impl LDNApplication {
             let validated_at = application_file.lifecycle.validated_at.clone();
             let app_state = application_file.lifecycle.get_state();
             let active_request_id = application_file.lifecycle.active_request.clone();
-            let valid_rkh = Self::fetch_rkh().await?;
+            let valid_gov_team = Self::fetch_gov().await?;
             let bot_user = get_env_var_or_default("BOT_USER", "filplus-github-bot-read-write[bot]");
 
             let res: bool = match app_state {
@@ -836,8 +836,8 @@ impl LDNApplication {
                         } else if actor != bot_user {
                             log::warn!("- Not ready to sign - actor is not the bot user");
                             false
-                        } else if !valid_rkh.is_valid(&validated_by) {
-                            log::warn!("- Not ready to sign - valid_rkh is not valid");
+                        } else if !valid_gov_team.is_valid(&validated_by) {
+                            log::warn!("- Not ready to sign - valid_gov_team is not valid");
                             false
                         } else {
                             log::info!("- Validated!");
@@ -851,7 +851,7 @@ impl LDNApplication {
                 AppState::StartSignDatacap => {
                     if !validated_at.is_empty()
                         && !validated_by.is_empty()
-                        && valid_rkh.is_valid(&validated_by)
+                        && valid_gov_team.is_valid(&validated_by)
                     {
                         log::info!("- Validated!");
                         true
@@ -862,16 +862,16 @@ impl LDNApplication {
                         if validated_by.is_empty() {
                             log::warn!("- AppState: StartSignDatacap, validation failed: validated_by is empty");
                         }
-                        if !valid_rkh.is_valid(&validated_by) {
-                            log::warn!("- AppState: StartSignDatacap, validation failed: valid_rkh is not valid");
+                        if !valid_gov_team.is_valid(&validated_by) {
+                            log::warn!("- AppState: StartSignDatacap, validation failed: valid_gov_team is not valid");
                         }
                         false
                     }
                 }
                 AppState::Granted => {
                     if !validated_at.is_empty()
                         && !validated_by.is_empty()
-                        && valid_rkh.is_valid(&validated_by)
+                        && valid_gov_team.is_valid(&validated_by)
                     {
                         log::info!("- Application is granted");
                         true
@@ -886,9 +886,9 @@ impl LDNApplication {
                                 "- AppState: Granted, validation failed: validated_by is empty"
                             );
                         }
-                        if !valid_rkh.is_valid(&validated_by) {
+                        if !valid_gov_team.is_valid(&validated_by) {
                             log::warn!(
-                                "- AppState: Granted, validation failed: valid_rkh is not valid"
+                                "- AppState: Granted, validation failed: valid_gov_team is not valid"
                             );
                         }
                         false
@@ -1298,10 +1298,10 @@ Your Datacap Allocation Request has been {} by the Notary
         Ok(true)
     }
 
-    pub async fn fetch_rkh_and_notary_gh_users() -> Result<(Vec<String>, Vec<String>), LDNError> {
-        let rkh_list = Self::fetch_rkh()
+    pub async fn fetch_gov_and_notary_gh_users() -> Result<(Vec<String>, Vec<String>), LDNError> {
+        let gov_team_list = Self::fetch_gov()
             .await
-            .map_err(|e| LDNError::Load(format!("Failed to retrieve rkh: {}", e)))?;
+            .map_err(|e| LDNError::Load(format!("Failed to retrieve gov team: {}", e)))?;
 
         let notary_list = Self::fetch_notaries()
             .await
@@ -1314,7 +1314,7 @@ Your Datacap Allocation Request has been {} by the Notary
             .filter(|username| !username.is_empty())
             .collect();
 
-        Ok((rkh_list.rkh, notary_gh_names))
+        Ok((gov_team_list.gov_team, notary_gh_names))
     }
 
     async fn add_error_label(issue_number: String, comment: String) -> Result<(), LDNError> {
