gitmono-dev · genedna · Oct 18, 2024 · Oct 18, 2024
diff --git a/ceres/src/api_service/mod.rs b/ceres/src/api_service/mod.rs
@@ -238,9 +238,8 @@ pub trait ApiHandler: Send + Sync {
         let root_tree = self.get_root_tree().await;
         let mut search_tree = root_tree.clone();
         let mut update_tree = vec![root_tree];
-        let component_num = relative_path.components().count();
 
-        for (index, component) in relative_path.components().enumerate() {
+        for component in relative_path.components() {
             // root tree already found
             if component != Component::RootDir {
                 let target_name = component.as_os_str().to_str().unwrap();
@@ -252,10 +251,7 @@ pub trait ApiHandler: Send + Sync {
                 if let Some(search_res) = search_res {
                     let res = self.get_tree_by_hash(&search_res.id.to_plain_str()).await;
                     search_tree = res.clone();
-                    // skip last component
-                    if index != component_num - 1 {
-                        update_tree.push(res);
-                    }
+                    update_tree.push(res);
                 } else {
                     return Err(GitError::CustomError(
                         "Path not exist, please create path first!".to_string(),

diff --git a/ceres/src/api_service/mono_api_service.rs b/ceres/src/api_service/mono_api_service.rs
@@ -7,6 +7,7 @@ use axum::async_trait;
 use callisto::db_enums::{ConvType, MergeStatus};
 use callisto::{mega_blob, mega_tree, raw_blob};
 use common::errors::MegaError;
+use common::model::PageParams;
 use jupiter::context::Context;
 use jupiter::storage::batch_save_model;
 use jupiter::utils::converter::generate_git_keep_with_timestamp;
@@ -195,7 +196,11 @@ impl ApiHandler for MonoApiService {
 }
 
 impl MonoApiService {
-    pub async fn mr_list(&self, status: &str) -> Result<Vec<MrInfoItem>, MegaError> {
+    pub async fn mr_list(
+        &self,
+        status: &str,
+        pagination: PageParams,
+    ) -> Result<(Vec<MrInfoItem>, u64), MegaError> {
         let status = if status == "open" {
             vec![MergeStatus::Open]
         } else if status == "closed" {
@@ -204,8 +209,11 @@ impl MonoApiService {
             vec![MergeStatus::Open, MergeStatus::Closed, MergeStatus::Merged]
         };
         let storage = self.context.services.mono_storage.clone();
-        let mr_list = storage.get_mr_by_status(status).await.unwrap();
-        Ok(mr_list.into_iter().map(|m| m.into()).collect())
+        let (mr_list, total) = storage
+            .get_mr_by_status(status, pagination.page, pagination.per_page)
+            .await
+            .unwrap();
+        Ok((mr_list.into_iter().map(|m| m.into()).collect(), total))
     }
 
     pub async fn mr_detail(&self, mr_link: &str) -> Result<Option<MRDetail>, MegaError> {
@@ -280,19 +288,13 @@ impl MonoApiService {
         let refs = storage.get_ref(&mr.path).await.unwrap().unwrap();
 
         if mr.from_hash == refs.ref_commit_hash {
-            // update mr
-            mr.merge();
             let commit: Commit = storage
                 .get_commit_by_hash(&mr.to_hash)
                 .await
                 .unwrap()
                 .unwrap()
                 .into();
-            // add conversation
-            storage
-                .add_mr_conversation(&mr.mr_link, 0, ConvType::Merged, None)
-                .await
-                .unwrap();
+
             if mr.path != "/" {
                 let path = PathBuf::from(mr.path.clone());
                 // beacuse only parent tree is needed so we skip current directory
@@ -307,6 +309,13 @@ impl MonoApiService {
                 storage.remove_refs(&mr.path).await.unwrap();
                 // TODO: self.clean_dangling_commits().await;
             }
+            // update mr
+            mr.merge();
+            // add conversation
+            storage
+                .add_mr_conversation(&mr.mr_link, 0, ConvType::Merged, None)
+                .await
+                .unwrap();
             // update mr status last
             storage.update_mr(mr.clone().into()).await.unwrap();
         } else {

diff --git a/ceres/src/lfs/handler.rs b/ceres/src/lfs/handler.rs
@@ -16,7 +16,6 @@ use futures::Stream;
 use jupiter::context::Context;
 use jupiter::storage::lfs_db_storage::LfsDbStorage;
 use rand::prelude::*;
-use sea_orm::ActiveValue::Set;
 use sea_orm::{DatabaseTransaction, EntityTrait, IntoActiveModel, TransactionTrait};
 use tokio_stream::wrappers::ReceiverStream;
 
@@ -603,9 +602,9 @@ async fn lfs_add_lock(
             let d = serde_json::to_string(&locks_from_data).unwrap();
 
             // must turn into `ActiveModel` before modify, or update failed.
-            let mut val = val.into_active_model();
-            val.data = Set(d);
-            let res = storage.update_lock(val).await;
+            // let mut val = val.into_active_model();
+            // val.data = Set(d);
+            let res = storage.update_lock(val, &d).await;
             match res.is_ok() {
                 true => Ok(()),
                 false => Err(GitLFSError::GeneralError("".to_string())),
@@ -757,9 +756,7 @@ async fn delete_lock(
 
             // Update remaining locks.
             let data = serde_json::to_string(&new_locks).unwrap();
-            let mut val = val.into_active_model();
-            val.data = Set(data);
-            let res = storage.update_lock(val).await;
+            let res = storage.update_lock(val, &data).await;
             match res.is_ok() {
                 true => Ok(lock_to_delete),
                 false => Err(GitLFSError::GeneralError("".to_string())),

diff --git a/ceres/src/pack/import_repo.rs b/ceres/src/pack/import_repo.rs
@@ -59,14 +59,14 @@ impl PackHandler for ImportRepo {
         let storage = self.context.services.git_db_storage.clone();
         let mut entry_list = vec![];
         let mut join_tasks = vec![];
+        let repo_id = self.repo.repo_id;
         for entry in receiver {
             entry_list.push(entry);
-            if entry_list.len() >= 1000 {
+            if entry_list.len() >= 10000 {
                 let stg_clone = storage.clone();
-                let repo_clone = self.repo.clone();
                 let handle = tokio::spawn(async move {
                     stg_clone
-                        .save_entry(repo_clone.repo_id, entry_list)
+                        .save_entry(repo_id, entry_list)
                         .await
                         .unwrap();
                 });
@@ -76,7 +76,7 @@ impl PackHandler for ImportRepo {
         }
         join_all(join_tasks).await;
         storage
-            .save_entry(self.repo.repo_id, entry_list)
+            .save_entry(repo_id, entry_list)
             .await
             .unwrap();
         self.attach_to_monorepo_parent().await.unwrap();

diff --git a/ceres/src/pack/monorepo.rs b/ceres/src/pack/monorepo.rs
@@ -341,7 +341,7 @@ impl MonoRepo {
                 let comment = self.comment_for_force_update(&mr.to_hash, &self.to_hash);
                 mr.to_hash = self.to_hash.clone();
                 storage
-                    .add_mr_conversation(&mr.mr_link, 0, ConvType::Comment, Some(comment))
+                    .add_mr_conversation(&mr.mr_link, 0, ConvType::ForcePush, Some(comment))
                     .await
                     .unwrap();
             } else {
@@ -353,7 +353,7 @@ impl MonoRepo {
                 .add_mr_conversation(
                     &mr.mr_link,
                     0,
-                    ConvType::Comment,
+                    ConvType::Closed,
                     Some("Mega closed MR due to conflict".to_string()),
                 )
                 .await

diff --git a/common/src/model.rs b/common/src/model.rs
@@ -48,3 +48,31 @@ impl<T> CommonResult<T> {
         }
     }
 }
+
+#[derive(Deserialize)]
+pub struct PageParams {
+    pub page: u64,
+    pub per_page: u64,
+}
+
+impl Default for PageParams {
+    fn default() -> Self {
+        PageParams {
+            page: 1,
+            per_page: 20,
+        }
+    }
+}
+
+#[derive(Deserialize)]
+pub struct RequestParams<T> {
+    pub pagination: PageParams,
+    pub additional: T,
+}
+
+#[derive(PartialEq, Eq, Debug, Clone, Default, Serialize, Deserialize)]
+
+pub struct CommonPage<T> {
+    pub total: u64,
+    pub items: Vec<T>,
+}
diff --git a/jupiter/Cargo.toml b/jupiter/Cargo.toml
@@ -31,7 +31,7 @@ futures = { workspace = true }
 serde_json = { workspace = true }
 idgenerator = { workspace = true }
 serde = { workspace = true }
-handlebars = "6.0.0"
+tokio = { workspace = true, features = ["macros"] }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros"] }
diff --git a/jupiter/callisto/src/db_enums.rs b/jupiter/callisto/src/db_enums.rs
@@ -76,6 +76,7 @@ pub enum ConvType {
     Approve,
     MergeQueue,
     Merged,
+    Closed,
 }
 
 impl Display for ConvType {
@@ -90,6 +91,7 @@ impl Display for ConvType {
             ConvType::Approve => "Approve",
             ConvType::MergeQueue => "MergeQueue",
             ConvType::Merged => "Merged",
+            ConvType::Closed => "Closed",
         };
         write!(f, "{}", s)
     }

diff --git a/jupiter/src/storage/git_db_storage.rs b/jupiter/src/storage/git_db_storage.rs
@@ -1,4 +1,4 @@
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 use futures::{stream, Stream, StreamExt};
 use sea_orm::sea_query::Expr;
@@ -7,6 +7,7 @@ use sea_orm::{
     IntoActiveModel, QueryFilter, QueryTrait, Set,
 };
 use sea_orm::{PaginatorTrait, QueryOrder};
+use tokio::sync::Mutex;
 
 use callisto::{git_blob, git_commit, git_repo, git_tag, git_tree, import_refs, raw_blob};
 use common::errors::MegaError;
@@ -44,7 +45,11 @@ impl GitDbStorage {
         }
     }
 
-    pub async fn save_ref(&self, repo_id: i64, mut refs: import_refs::Model) -> Result<(), MegaError> {
+    pub async fn save_ref(
+        &self,
+        repo_id: i64,
+        mut refs: import_refs::Model,
+    ) -> Result<(), MegaError> {
         refs.repo_id = repo_id;
         let a_model = refs.into_active_model();
         import_refs::Entity::insert(a_model)
@@ -129,7 +134,7 @@ impl GitDbStorage {
                 async move {
                     let raw_obj = entry.process_entry();
                     let model = raw_obj.convert_to_git_model();
-                    let mut git_objects = git_objects.lock().unwrap();
+                    let mut git_objects = git_objects.lock().await;
 
                     match model {
                         GitObjectModel::Commit(mut commit) => {
@@ -156,8 +161,7 @@ impl GitDbStorage {
 
         let git_objects = Arc::try_unwrap(git_objects)
             .expect("Failed to unwrap Arc")
-            .into_inner()
-            .unwrap();
+            .into_inner();
         batch_save_model(self.get_connection(), git_objects.commits)
             .await
             .unwrap();

diff --git a/jupiter/src/storage/lfs_db_storage.rs b/jupiter/src/storage/lfs_db_storage.rs
@@ -1,7 +1,8 @@
 use std::sync::Arc;
 
 use sea_orm::{
-    ColumnTrait, DatabaseConnection, EntityTrait, InsertResult, IntoActiveModel, QueryFilter, QueryOrder,
+    ColumnTrait, DatabaseConnection, EntityTrait, InsertResult, IntoActiveModel, QueryFilter,
+    QueryOrder, Set,
 };
 
 use callisto::{lfs_locks, lfs_objects, lfs_split_relations};
@@ -120,9 +121,12 @@ impl LfsDbStorage {
 
     pub async fn update_lock(
         &self,
-        lfs_lock: lfs_locks::ActiveModel,
+        lfs_lock: lfs_locks::Model,
+        data: &str,
     ) -> Result<lfs_locks::Model, MegaError> {
-        Ok(lfs_locks::Entity::update(lfs_lock)
+        let mut val = lfs_lock.into_active_model();
+        val.data = Set(data.to_owned());
+        Ok(lfs_locks::Entity::update(val)
             .exec(self.get_connection())
             .await
             .unwrap())

diff --git a/jupiter/src/storage/mono_storage.rs b/jupiter/src/storage/mono_storage.rs
@@ -3,8 +3,7 @@ use std::sync::{Arc, Mutex};
 use futures::{stream, StreamExt};
 use sea_orm::ActiveValue::NotSet;
 use sea_orm::{
-    ActiveModelTrait, ColumnTrait, DatabaseConnection, EntityTrait, IntoActiveModel, QueryFilter,
-    QueryOrder, QuerySelect,
+    ActiveModelTrait, ColumnTrait, DatabaseConnection, EntityTrait, IntoActiveModel, PaginatorTrait, QueryFilter, QueryOrder, QuerySelect
 };
 
 use callisto::db_enums::{ConvType, MergeStatus};
@@ -119,14 +118,15 @@ impl MonoStorage {
     pub async fn get_mr_by_status(
         &self,
         status: Vec<MergeStatus>,
-    ) -> Result<Vec<mega_mr::Model>, MegaError> {
-        let model = mega_mr::Entity::find()
+        page: u64,
+        per_page: u64,
+    ) -> Result<(Vec<mega_mr::Model>, u64), MegaError> {
+        let paginator = mega_mr::Entity::find()
             .filter(mega_mr::Column::Status.is_in(status))
             .order_by_desc(mega_mr::Column::CreatedAt)
-            .all(self.get_connection())
-            .await
-            .unwrap();
-        Ok(model)
+            .paginate(self.get_connection(),per_page);
+        let num_pages = paginator.num_items().await?;
+        Ok(paginator.fetch_page(page -1).await.map(|m| (m, num_pages))?)
     }
 
     pub async fn get_mr(&self, mr_link: &str) -> Result<Option<mega_mr::Model>, MegaError> {

diff --git a/mega/Cargo.toml b/mega/Cargo.toml
@@ -36,13 +36,6 @@ shadow-rs = { workspace = true }
 ctrlc = { workspace = true }
 
 [dev-dependencies]
-reqwest = { workspace = true, features = ["stream", "json"] }
-russh = { workspace = true }
-russh-keys = { workspace = true }
-async-trait = { workspace = true }
-bytes = { workspace = true }
-go-defer = { workspace = true }
-git2 = { workspace = true }
 tempfile = { workspace = true }
 serial_test = "3.1.1"
 lazy_static = {workspace = true}

diff --git a/mono/Cargo.toml b/mono/Cargo.toml
@@ -56,20 +56,9 @@ shadow-rs = { workspace = true }
 oauth2 = "4.4.2"
 async-session = "3.0.0"
 http = "1.1.0"
-sea-orm = { workspace = true, features = [] }
 cedar-policy = { workspace = true }
 
 [dev-dependencies]
-reqwest = { workspace = true, features = ["stream", "json"] }
-russh = { workspace = true }
-russh-keys = { workspace = true }
-async-trait = { workspace = true }
-bytes = { workspace = true }
-go-defer = { workspace = true }
-git2 = { workspace = true }
-tempfile = { workspace = true }
-rand = { workspace = true }
-
 
 [build-dependencies]
 shadow-rs = { workspace = true }
diff --git a/mono/src/api/mod.rs b/mono/src/api/mod.rs
@@ -16,6 +16,7 @@ use jupiter::{context::Context, storage::user_storage::UserStorage};
 pub mod api_router;
 pub mod error;
 pub mod lfs;
+pub mod model;
 pub mod mr_router;
 pub mod oauth;
 pub mod user;

diff --git a/mono/src/api/model.rs b/mono/src/api/model.rs
@@ -0,0 +1,7 @@
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub struct MRStatusParams {
+    pub status: String,
+}
+