@@ -8,15 +8,14 @@ use rand::prelude::*;
 use tokio_stream::wrappers::ReceiverStream;
 
 use callisto::lfs_locks;
-use common::config::PackConfig;
 use common::errors::{GitLFSError, MegaError};
 use jupiter::storage::Storage;
 use jupiter::storage::lfs_db_storage::LfsDbStorage;
 
 use crate::lfs::lfs_structs::{
-    BatchRequest, BatchResponse, ChunkDownloadObject, Link, Lock, LockList, LockListQuery,
-    LockRequest, MetaObject, ObjectError, Operation, RequestObject, ResCondition, ResponseObject,
-    TransferMode, UnlockRequest, VerifiableLockList, VerifiableLockRequest,
+    BatchRequest, BatchResponse, Lock, LockList, LockListQuery, LockRequest, MetaObject,
+    ObjectError, Operation, RequestObject, ResCondition, ResponseObject, TransferMode,
+    UnlockRequest, VerifiableLockList, VerifiableLockRequest,
 };
 
 pub async fn lfs_retrieve_lock(
@@ -210,8 +209,7 @@ pub async fn lfs_process_batch(
                 }
             }
         };
-        let enable_split = meta.splited && config.local.enable_split;
-        let file_exist = file_storage.exist_object(&meta.oid, enable_split).await;
+        let file_exist = file_storage.exist_object(&meta.oid).await;
         let download_url = file_storage
             .download_url(&meta.oid, listen_addr)
             .await
@@ -240,70 +238,13 @@ pub async fn lfs_process_batch(
     })
 }
 
-/// if server enable split, then return a list of chunk ids.
-/// else return an error.
-pub async fn lfs_fetch_chunk_ids(
-    storage: &Storage,
-    oid: &str,
-    listen_addr: &str,
-) -> Result<Vec<ChunkDownloadObject>, GitLFSError> {
-    let config = storage.config().lfs.clone();
-
-    if !config.local.enable_split {
-        return Err(GitLFSError::GeneralError(
-            "Server didn't run in `split` mode, didn't support chunk ids".to_string(),
-        ));
-    }
-    let db_storage = storage.lfs_db_storage();
-
-    let meta = lfs_get_meta(db_storage.clone(), oid)
-        .await
-        .map_err(|_| GitLFSError::GeneralError("".to_string()))?
-        .unwrap();
-    assert!(meta.splited, "database didn't match the split mode");
-
-    let relations = db_storage
-        .get_lfs_relations(oid)
-        .await
-        .map_err(|_| GitLFSError::GeneralError("".to_string()))?;
-
-    if relations.is_empty() {
-        return Err(GitLFSError::GeneralError(
-            "oid didn't have chunks".to_string(),
-        ));
-    }
-    let mut response_objects = Vec::<ChunkDownloadObject>::new();
-
-    for relation in relations {
-        // Reuse RequestArgs to create a link
-        let req_obj = RequestObject {
-            oid: relation.sub_oid.clone(),
-            size: relation.size,
-            ..Default::default()
-        };
-        let download_url = storage
-            .lfs_file_storage()
-            .download_url(&req_obj.oid, listen_addr)
-            .await
-            .unwrap();
-        response_objects.push(ChunkDownloadObject {
-            sub_oid: relation.sub_oid,
-            size: relation.size,
-            offset: relation.offset,
-            link: Link::new(&download_url),
-        });
-    }
-    Ok(response_objects)
-}
-
 /// Upload object to storage.
 /// if server enable split, split the object and upload each part to storage, save the relationship to database.
 pub async fn lfs_upload_object(
     storage: &Storage,
     req_obj: &RequestObject,
     body_bytes: Vec<u8>,
 ) -> Result<(), GitLFSError> {
-    let config = storage.config().lfs.clone();
     let db_storage = storage.lfs_db_storage();
     let file_storage = storage.lfs_file_storage();
 
@@ -313,36 +254,14 @@ pub async fn lfs_upload_object(
     } else {
         return Err(GitLFSError::GeneralError(String::from("Not found ")));
     };
-    let split_size = match PackConfig::get_size_from_str(&config.local.split_size, || Ok(0)) {
-        Ok(split_size) => split_size,
-        Err(err) => return Err(GitLFSError::GeneralError(err)),
-    };
 
-    if config.local.enable_split && meta.splited {
-        // assert!(request_vars.size == body_bytes.len() as i64, "size didn't match: {} != {}", request_vars.size, body_bytes.len()); // TODO: git client, request_vars.size is `0`!!
-        // split object to blocks
-        match file_storage
-            .put_object_with_chunk(&meta.oid, &body_bytes, split_size)
-            .await
-        {
-            Ok(_) => {}
-            Err(_) => {
-                lfs_delete_meta(&db_storage, req_obj).await?;
-                // TODO: whether/how to delete the uploaded blocks.
-                return Err(GitLFSError::GeneralError(String::from(
-                    "Header not acceptable!",
-                )));
-            }
-        };
-    } else {
-        // normal mode
-        let res = file_storage.put_object(&meta.oid, body_bytes).await;
-        if res.is_err() {
-            lfs_delete_meta(&db_storage, req_obj).await.unwrap();
-            return Err(GitLFSError::GeneralError(String::from(
-                "Header not acceptable!",
-            )));
-        }
+    // normal mode
+    let res = file_storage.put_object(&meta.oid, body_bytes).await;
+    if res.is_err() {
+        lfs_delete_meta(&db_storage, req_obj).await.unwrap();
+        return Err(GitLFSError::GeneralError(String::from(
+            "Header not acceptable!",
+        )));
     }
     Ok(())
 }
@@ -358,53 +277,14 @@ pub async fn lfs_download_object(
 
     let meta = lfs_get_meta(db_storage.clone(), &oid).await?;
     match meta {
-        Some(meta) => {
-            if meta.splited {
-                // client didn't support split, splice the object and return it.
-                let relations = db_storage.get_lfs_relations(&meta.oid).await.unwrap();
-                if relations.is_empty() {
-                    return Err(GitLFSError::GeneralError(
-                        "oid didn't have chunks".to_string(),
-                    ));
-                }
-                let (tx, rx) = tokio::sync::mpsc::channel(1);
-                let oid = oid.clone();
-                tokio::spawn(async move {
-                    let chunks_len = relations.len();
-                    for relation in relations {
-                        let sub_bytes = file_storage.get_object(&relation.sub_oid).await.unwrap();
-                        if let Err(err) = tx.send(Ok(sub_bytes)).await {
-                            tracing::error!(
-                                "lfs object download failed, failed to send chunk [{}], error: {}",
-                                relation.offset,
-                                err
-                            );
-                            break;
-                        }
-                    }
-                    tracing::debug!(
-                        "lfs object download completed for oid: {}, {} chunks",
-                        oid,
-                        chunks_len
-                    );
-                });
-                Ok(ReceiverStream::new(rx))
-            } else {
-                let meta = lfs_get_meta(db_storage, &oid).await?.unwrap();
-                let bytes = file_storage.get_object(&meta.oid).await.unwrap();
-                let (tx, rx) = tokio::sync::mpsc::channel(1);
-                tx.send(Ok(bytes)).await.unwrap();
-                Ok(ReceiverStream::new(rx))
-            }
+        Some(_) => {
+            let meta = lfs_get_meta(db_storage, &oid).await?.unwrap();
+            let bytes = file_storage.get_object(&meta.oid).await.unwrap();
+            let (tx, rx) = tokio::sync::mpsc::channel(1);
+            tx.send(Ok(bytes)).await.unwrap();
+            Ok(ReceiverStream::new(rx))
         }
         None => {
-            // check if the oid is a part of a split object, if so, return the part.
-            if !lfs_check_sub_oid_exist(db_storage, &oid).await.unwrap() {
-                return Err(GitLFSError::GeneralError(
-                    "oid didn't belong to any object".to_string(),
-                ));
-            }
-
             let bytes = file_storage.get_object(&oid).await.unwrap();
             // because return type must be `ReceiverStream`, so we need to wrap the bytes into a stream.
             let (tx, rx) = tokio::sync::mpsc::channel(1);
@@ -414,46 +294,6 @@ pub async fn lfs_download_object(
     }
 }
 
-/// Download a chunk from a large object.
-/// It's used when server didn't have splited chunk, but client request a chunk.
-/// If the server enable split, then the chunk must be a splited chunk, rather than a random part of the object.
-pub async fn lfs_download_chunk(
-    storage: Storage,
-    origin_oid: &str,
-    chunk_oid: &String,
-    offset: u64,
-    size: u64,
-) -> Result<Bytes, GitLFSError> {
-    let config = &storage.config().lfs;
-    let db_storage = storage.lfs_db_storage();
-    let file_storage = storage.lfs_file_storage();
-
-    // check if the chunk is already exist.
-    if config.local.enable_split {
-        let relations = db_storage.get_lfs_relations(origin_oid).await.unwrap();
-        let chunk_relation = relations.iter().find(|r| &r.sub_oid == chunk_oid);
-        if chunk_relation.is_none() {
-            return Err(GitLFSError::GeneralError(
-                "Chunk not found in split object".to_string(),
-            ));
-        }
-        let chunk = file_storage.get_object(chunk_oid).await.unwrap();
-        Ok(chunk)
-    } else {
-        // return part of the original object.
-        let bytes = file_storage.get_object(origin_oid).await.unwrap();
-        let chunk_bytes = bytes[offset as usize..(offset + size) as usize].to_vec();
-        // check hash
-        let chunk_hash = hex::encode(ring::digest::digest(&ring::digest::SHA256, &chunk_bytes));
-        if chunk_hash != *chunk_oid {
-            return Err(GitLFSError::GeneralError(
-                "Chunk hash not match".to_string(),
-            ));
-        }
-        Ok(Bytes::from(chunk_bytes))
-    }
-}
-
 async fn lfs_get_filtered_locks(
     storage: LfsDbStorage,
     refspec: &str,
@@ -591,7 +431,6 @@ async fn lfs_delete_meta(
     req_obj: &RequestObject,
 ) -> Result<(), GitLFSError> {
     let res = storage.delete_lfs_object(req_obj.oid.to_owned()).await;
-    storage.delete_lfs_relations(&req_obj.oid).await.unwrap();
     match res {
         Ok(_) => Ok(()),
         Err(_) => Err(GitLFSError::GeneralError("".to_string())),
@@ -669,14 +508,6 @@ async fn delete_lock(
     }
 }
 
-async fn lfs_check_sub_oid_exist(
-    storage: LfsDbStorage,
-    sub_oid: &str,
-) -> Result<bool, GitLFSError> {
-    let result = storage.get_lfs_relations_ori_oid(sub_oid).await.unwrap();
-    Ok(!result.is_empty())
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
@@ -25,7 +25,6 @@ pub mod item_labels;
 pub mod label;
 pub mod lfs_locks;
 pub mod lfs_objects;
-pub mod lfs_split_relations;
 pub mod mega_blob;
 pub mod mega_cl;
 pub mod mega_cl_commits;
@@ -37,17 +36,9 @@ pub mod mega_refs;
 pub mod mega_tag;
 pub mod mega_tree;
 pub mod merge_queue;
-pub mod mq_storage;
 pub mod notes;
 pub mod path_check_configs;
-pub mod raw_blob;
 pub mod reactions;
-pub mod relay_lfs_info;
-pub mod relay_node;
-pub mod relay_nostr_event;
-pub mod relay_nostr_req;
-pub mod relay_path_mapping;
-pub mod relay_repo_info;
 pub mod sea_orm_active_enums;
 pub mod ssh_keys;
 pub mod tasks;
 
@@ -22,7 +22,6 @@ pub use super::item_labels::Entity as ItemLabels;
 pub use super::label::Entity as Label;
 pub use super::lfs_locks::Entity as LfsLocks;
 pub use super::lfs_objects::Entity as LfsObjects;
-pub use super::lfs_split_relations::Entity as LfsSplitRelations;
 pub use super::mega_blob::Entity as MegaBlob;
 pub use super::mega_cl::Entity as MegaCl;
 pub use super::mega_cl_commits::Entity as MegaClCommits;
@@ -34,17 +33,9 @@ pub use super::mega_refs::Entity as MegaRefs;
 pub use super::mega_tag::Entity as MegaTag;
 pub use super::mega_tree::Entity as MegaTree;
 pub use super::merge_queue::Entity as MergeQueue;
-pub use super::mq_storage::Entity as MqStorage;
 pub use super::notes::Entity as Notes;
 pub use super::path_check_configs::Entity as PathCheckConfigs;
-pub use super::raw_blob::Entity as RawBlob;
 pub use super::reactions::Entity as Reactions;
-pub use super::relay_lfs_info::Entity as RelayLfsInfo;
-pub use super::relay_node::Entity as RelayNode;
-pub use super::relay_nostr_event::Entity as RelayNostrEvent;
-pub use super::relay_nostr_req::Entity as RelayNostrReq;
-pub use super::relay_path_mapping::Entity as RelayPathMapping;
-pub use super::relay_repo_info::Entity as RelayRepoInfo;
 pub use super::ssh_keys::Entity as SshKeys;
 pub use super::tasks::Entity as Tasks;
 pub use super::vault::Entity as Vault;