gitks/server/repository.rs

//! Copyright (c) 2022-2026 GitDataAi All rights reserved.

use crate::pb::repository_service_client::RepositoryServiceClient;
use crate::pb::*;

use super::{GitksService, git_cmd, into_status, repository_maint};
use tokio_stream::wrappers::ReceiverStream;

remote_client!(
    remote_repository_client,
    RepositoryServiceClient<tonic::transport::Channel>,
    "repository"
);

fn default_branch_name(gb: &crate::bare::GitBare) -> String {
    git_cmd(gb, &["symbolic-ref", "HEAD"])
        .ok()
        .and_then(|o| {
            String::from_utf8_lossy(&o.stdout)
                .trim()
                .strip_prefix("refs/heads/")
                .map(|b| b.to_string())
        })
        .unwrap_or_default()
}

#[tonic::async_trait]
impl repository_service_server::RepositoryService for GitksService {
    async fn get_repository(
        &self,
        request: tonic::Request<GetRepositoryRequest>,
    ) -> Result<tonic::Response<Repository>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/GetRepository");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.get_repository", %repo);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), false).await?
                {
                    m.record("ok");
                    return client.get_repository(inner).await;
                }
                crate::metrics::record_rpc_error(&m, &err);
                return Err(err);
            }
            Err(err) => {
                crate::metrics::record_rpc_error(&m, &err);
                return Err(err);
            }
        };
        let bare = gb.bare_dir.join("HEAD").exists();
        let object_format = gb.object_format();
        m.record("ok");
        Ok(tonic::Response::new(Repository {
            header: inner.repository,
            bare,
            object_format: object_format as i32,
            default_branch: default_branch_name(&gb),
            ..Default::default()
        }))
    }

    async fn init_repository(
        &self,
        request: tonic::Request<InitRepositoryRequest>,
    ) -> Result<tonic::Response<Repository>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/InitRepository");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.init_repository", %repo);
        let _enter = span.enter();
        let bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
        let gb = crate::bare::GitBare::new(bare_dir);
        gb.init_repository(inner.bare).map_err(into_status)?;
        if let Some(ref hm) = self.hook_manager {
            hm.install_hooks(&gb.bare_dir).map_err(into_status)?;
        }
        tracing::info!(%repo, bare = inner.bare, "repository initialized");
        self.notify_ref_update(&repo, "HEAD", "", "");
        m.record("ok");
        Ok(tonic::Response::new(Repository {
            header: inner.repository,
            bare: inner.bare,
            ..Default::default()
        }))
    }

    async fn delete_repository(
        &self,
        request: tonic::Request<DeleteRepositoryRequest>,
    ) -> Result<tonic::Response<()>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/DeleteRepository");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.delete_repository", %repo);
        let _enter = span.enter();
        let bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
        if !bare_dir.exists()
            && let Some(mut client) =
                remote_repository_client(self, inner.repository.as_ref(), true).await?
        {
            m.record("ok");
            return client.delete_repository(inner).await;
        }
        tracing::warn!(%repo, path = %bare_dir.display(), "deleting repository");
        std::fs::remove_dir_all(&bare_dir).map_err(|e| tonic::Status::internal(e.to_string()))?;
        tracing::info!(%repo, "repository deleted");
        self.notify_ref_update(&repo, "", "", "");
        crate::rate_limit::remove_repository(&repo);
        m.record("ok");
        Ok(tonic::Response::new(()))
    }

    async fn repository_exists(
        &self,
        request: tonic::Request<RepositoryExistsRequest>,
    ) -> Result<tonic::Response<RepositoryExistsResponse>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.repository_exists", %repo);
        let _enter = span.enter();
        let bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
        let exists = bare_dir.exists() && bare_dir.is_dir() && bare_dir.join("HEAD").exists();
        if !exists
            && let Some(mut client) =
                remote_repository_client(self, inner.repository.as_ref(), false).await?
        {
            return client.repository_exists(inner).await;
        }
        Ok(tonic::Response::new(RepositoryExistsResponse { exists }))
    }

    async fn get_object_format(
        &self,
        request: tonic::Request<RepositoryObjectFormatRequest>,
    ) -> Result<tonic::Response<RepositoryObjectFormatResponse>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.get_object_format", %repo);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), false).await?
                {
                    return client.get_object_format(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        Ok(tonic::Response::new(RepositoryObjectFormatResponse {
            object_format: gb.object_format() as i32,
        }))
    }

    async fn get_default_branch(
        &self,
        request: tonic::Request<GetDefaultBranchRequest>,
    ) -> Result<tonic::Response<GetDefaultBranchResponse>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.get_default_branch", %repo);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), false).await?
                {
                    return client.get_default_branch(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        Ok(tonic::Response::new(GetDefaultBranchResponse {
            name: default_branch_name(&gb),
        }))
    }

    async fn set_default_branch(
        &self,
        request: tonic::Request<SetDefaultBranchRequest>,
    ) -> Result<tonic::Response<()>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let name = inner.name.clone();
        let span = tracing::info_span!("repo.set_default_branch", %repo, %name);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), true).await?
                {
                    return client.set_default_branch(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        crate::sanitize::validate_ref_name(&inner.name)
            .map_err(|e| tonic::Status::invalid_argument(e.to_string()))?;
        let refname = format!("refs/heads/{}", inner.name);
        git_cmd(&gb, &["symbolic-ref", "HEAD", &refname])?;
        tracing::info!(%repo, %name, "default branch set");
        self.notify_ref_update(&repo, &refname, "", "");
        Ok(tonic::Response::new(()))
    }

    async fn get_repository_config(
        &self,
        request: tonic::Request<GetRepositoryConfigRequest>,
    ) -> Result<tonic::Response<GetRepositoryConfigResponse>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.get_repository_config", %repo);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), false).await?
                {
                    return client.get_repository_config(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        let mut entries = Vec::new();
        if inner.keys.is_empty() {
            let out = git_cmd(&gb, &["config", "--list"])?;
            for line in String::from_utf8_lossy(&out.stdout).lines() {
                if let Some((k, v)) = line.split_once('=') {
                    entries.push(RepositoryConfigEntry {
                        key: k.trim().to_string(),
                        values: vec![v.trim().to_string()],
                    });
                }
            }
        } else {
            for key in &inner.keys {
                crate::sanitize::validate_config_key(key)
                    .map_err(|e| tonic::Status::invalid_argument(e.to_string()))?;
                let out = git_cmd(&gb, &["config", "--get-all", key])?;
                let vals: Vec<String> = String::from_utf8_lossy(&out.stdout)
                    .lines()
                    .map(|l| l.trim().to_string())
                    .filter(|l| !l.is_empty())
                    .collect();
                if !vals.is_empty() {
                    entries.push(RepositoryConfigEntry {
                        key: key.clone(),
                        values: vals,
                    });
                }
            }
        }
        Ok(tonic::Response::new(GetRepositoryConfigResponse {
            entries,
        }))
    }

    async fn set_repository_config(
        &self,
        request: tonic::Request<SetRepositoryConfigRequest>,
    ) -> Result<tonic::Response<()>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.set_repository_config", %repo);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), true).await?
                {
                    return client.set_repository_config(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        for entry in &inner.entries {
            crate::sanitize::validate_config_key(&entry.key)
                .map_err(|e| tonic::Status::invalid_argument(e.to_string()))?;
            if entry.values.is_empty() {
                git_cmd(&gb, &["config", "--unset-all", &entry.key])?;
            } else {
                git_cmd(
                    &gb,
                    &["config", "--replace-all", &entry.key, &entry.values[0]],
                )?;
                for v in entry.values.iter().skip(1) {
                    git_cmd(&gb, &["config", "--add", &entry.key, v])?;
                }
            }
        }
        self.notify_ref_update(&repo, "", "", "");
        Ok(tonic::Response::new(()))
    }

    async fn get_repository_statistics(
        &self,
        request: tonic::Request<RepositoryStatisticsRequest>,
    ) -> Result<tonic::Response<RepositoryStatistics>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.get_repository_statistics", %repo);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), false).await?
                {
                    return client.get_repository_statistics(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        Ok(tonic::Response::new(repository_maint::get_statistics(&gb)))
    }

    async fn check_repository_health(
        &self,
        request: tonic::Request<RepositoryHealthRequest>,
    ) -> Result<tonic::Response<RepositoryHealthResponse>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.check_repository_health", %repo);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), false).await?
                {
                    return client.check_repository_health(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        let resp = repository_maint::check_health(&gb, inner.connectivity_only)?;
        tracing::info!(%repo, ok = resp.ok, errors = resp.errors.len(), warnings = resp.warnings.len(), "health check done");
        Ok(tonic::Response::new(resp))
    }

    async fn garbage_collect(
        &self,
        request: tonic::Request<GarbageCollectRequest>,
    ) -> Result<tonic::Response<RepositoryMaintenanceResponse>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.garbage_collect", %repo);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), true).await?
                {
                    return client.garbage_collect(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        let resp = repository_maint::run_gc(&gb, inner.prune, inner.aggressive)?;
        tracing::info!(%repo, ok = resp.ok, "gc done");
        Ok(tonic::Response::new(resp))
    }

    async fn repack(
        &self,
        request: tonic::Request<RepackRequest>,
    ) -> Result<tonic::Response<RepositoryMaintenanceResponse>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.repack", %repo);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), true).await?
                {
                    return client.repack(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        let resp = repository_maint::run_repack(
            &gb,
            inner.full,
            inner.write_bitmaps,
            inner.write_multi_pack_index,
        )?;
        tracing::info!(%repo, ok = resp.ok, "repack done");
        Ok(tonic::Response::new(resp))
    }

    async fn write_commit_graph(
        &self,
        request: tonic::Request<WriteCommitGraphRequest>,
    ) -> Result<tonic::Response<RepositoryMaintenanceResponse>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.write_commit_graph", %repo);
        let _enter = span.enter();
        let gb = match self.resolve(inner.repository.as_ref()) {
            Ok(gb) => gb,
            Err(err) if err.code() == tonic::Code::NotFound => {
                if let Some(mut client) =
                    remote_repository_client(self, inner.repository.as_ref(), true).await?
                {
                    return client.write_commit_graph(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        let resp = repository_maint::run_commit_graph_write(&gb, inner.split, inner.replace)?;
        tracing::info!(%repo, ok = resp.ok, "commit-graph write done");
        Ok(tonic::Response::new(resp))
    }

    async fn list_hooks(
        &self,
        request: tonic::Request<ListHooksRequest>,
    ) -> Result<tonic::Response<ListHooksResponse>, tonic::Status> {
        let inner = request.into_inner();
        let gb = self.resolve(inner.repository.as_ref())?;
        let hook_mgr = self.hook_manager.as_ref();
        let hooks = if let Some(hm) = hook_mgr {
            hm.list_hooks(&gb.bare_dir)
                .map_err(|e| tonic::Status::internal(e.to_string()))?
        } else {
            Vec::new()
        };
        let resp = ListHooksResponse {
            hooks: hooks
                .into_iter()
                .map(|h| crate::pb::HookInfo {
                    hook_type: h.hook_type,
                    level: h.level.to_string(),
                    path: h.path,
                })
                .collect(),
        };
        Ok(tonic::Response::new(resp))
    }

    async fn set_custom_hook(
        &self,
        request: tonic::Request<SetCustomHookRequest>,
    ) -> Result<tonic::Response<()>, tonic::Status> {
        let inner = request.into_inner();
        let gb = self.resolve(inner.repository.as_ref())?;
        let hook_mgr = self.hook_manager.as_ref();
        if let Some(hm) = hook_mgr {
            hm.set_custom_hook(&gb.bare_dir, &inner.hook_name, &inner.content)
                .map_err(|e| tonic::Status::internal(e.to_string()))?;
        } else {
            return Err(tonic::Status::failed_precondition("hooks not enabled"));
        }
        tracing::info!(repo = %gb.bare_dir.display(), hook = %inner.hook_name, "custom hook set");
        Ok(tonic::Response::new(()))
    }

    async fn remove_custom_hook(
        &self,
        request: tonic::Request<RemoveCustomHookRequest>,
    ) -> Result<tonic::Response<()>, tonic::Status> {
        let inner = request.into_inner();
        let gb = self.resolve(inner.repository.as_ref())?;
        let hook_mgr = self.hook_manager.as_ref();
        if let Some(hm) = hook_mgr {
            hm.remove_custom_hook(&gb.bare_dir, &inner.hook_name)
                .map_err(|e| tonic::Status::internal(e.to_string()))?;
        } else {
            return Err(tonic::Status::failed_precondition("hooks not enabled"));
        }
        tracing::info!(repo = %gb.bare_dir.display(), hook = %inner.hook_name, "custom hook removed");
        Ok(tonic::Response::new(()))
    }

    async fn create_snapshot(
        &self,
        request: tonic::Request<CreateSnapshotRequest>,
    ) -> Result<tonic::Response<CreateSnapshotResponse>, tonic::Status> {
        let inner = request.into_inner();
        let gb = self.resolve(inner.repository.as_ref())?;
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.create_snapshot", %repo);
        let _enter = span.enter();

        let storage = crate::snapshot::storage::LocalSnapshotStorage::new(
            self.repo_prefix.join("+gitks-snapshots"),
        );
        let snapshot_id = crate::snapshot::ops::create_and_store_snapshot(&gb, &repo, &storage)
            .map_err(|e| tonic::Status::internal(e.to_string()))?;

        let head_oid = crate::snapshot::ops::get_head_oid_internal(&gb)
            .map_err(|e| tonic::Status::internal(e.to_string()))?;

        use crate::snapshot::storage::SnapshotStorageBackend;
        let actual_size = storage
            .read_snapshot(&snapshot_id)
            .map(|d| d.len() as u64)
            .unwrap_or(0);

        tracing::info!(%repo, snapshot_id = %snapshot_id, size_bytes = actual_size, "snapshot created");
        Ok(tonic::Response::new(CreateSnapshotResponse {
            snapshot_id,
            size_bytes: actual_size,
            head_oid,
        }))
    }

    async fn restore_snapshot(
        &self,
        request: tonic::Request<RestoreSnapshotRequest>,
    ) -> Result<tonic::Response<()>, tonic::Status> {
        let inner = request.into_inner();
        let target_repo = self.repo_label(inner.target_repository.as_ref());
        let span = tracing::info_span!("repo.restore_snapshot", %target_repo);
        let _enter = span.enter();

        let storage = crate::snapshot::storage::LocalSnapshotStorage::new(
            self.repo_prefix.join("+gitks-snapshots"),
        );

        let target_path = self.resolve_for_init(inner.target_repository.as_ref())?;

        crate::snapshot::ops::restore_from_storage(&target_path, &inner.snapshot_id, &storage)
            .map_err(|e| tonic::Status::internal(e.to_string()))?;

        tracing::info!(%target_repo, snapshot_id = %inner.snapshot_id, "snapshot restored");
        self.notify_ref_update(&target_repo, "HEAD", "", "");
        Ok(tonic::Response::new(()))
    }

    async fn list_snapshots(
        &self,
        request: tonic::Request<ListSnapshotsRequest>,
    ) -> Result<tonic::Response<ListSnapshotsResponse>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());

        let storage = crate::snapshot::storage::LocalSnapshotStorage::new(
            self.repo_prefix.join("+gitks-snapshots"),
        );
        use crate::snapshot::storage::SnapshotStorageBackend;
        let snapshots = storage
            .list_snapshots(&repo)
            .map_err(tonic::Status::internal)?;

        let limit = (inner.limit > 0).then_some(inner.limit as usize);
        let resp = ListSnapshotsResponse {
            snapshots: snapshots
                .into_iter()
                .take(limit.unwrap_or(usize::MAX))
                .map(|s| crate::pb::SnapshotInfo {
                    snapshot_id: s.snapshot_id,
                    relative_path: s.relative_path,
                    size_bytes: s.size_bytes,
                    created_at: s.created_at,
                    head_oid: s.head_oid,
                })
                .collect(),
        };
        Ok(tonic::Response::new(resp))
    }

    async fn delete_snapshot(
        &self,
        request: tonic::Request<DeleteSnapshotRequest>,
    ) -> Result<tonic::Response<()>, tonic::Status> {
        let inner = request.into_inner();

        let storage = crate::snapshot::storage::LocalSnapshotStorage::new(
            self.repo_prefix.join("+gitks-snapshots"),
        );
        use crate::snapshot::storage::SnapshotStorageBackend;
        storage
            .delete_snapshot(&inner.snapshot_id)
            .map_err(tonic::Status::internal)?;

        tracing::info!(snapshot_id = %inner.snapshot_id, "snapshot deleted");
        Ok(tonic::Response::new(()))
    }

    type FetchRepositoryDataStream =
        ReceiverStream<Result<FetchRepositoryDataResponse, tonic::Status>>;

    async fn move_repository(
        &self,
        request: tonic::Request<MoveRepositoryRequest>,
    ) -> Result<tonic::Response<MoveRepositoryResponse>, tonic::Status> {
        let inner = request.into_inner();
        let source_repo = self.repo_label(inner.source_repository.as_ref());
        let span = tracing::info_span!("repo.move_repository", %source_repo);
        let _enter = span.enter();

        let gb = self.resolve(inner.source_repository.as_ref())?;

        let target_path = self.resolve_for_init(inner.target_repository.as_ref())?;
        // Prevent accidental self-move that would destroy the source repository.
        if target_path == gb.bare_dir {
            return Err(tonic::Status::invalid_argument(
                "source and target repository paths are the same",
            ));
        }

        let bundle_data = crate::snapshot::ops::create_snapshot(&gb)
            .map_err(|e| tonic::Status::internal(e.to_string()))?;

        let target_gb = crate::bare::GitBare::new(target_path.clone());
        target_gb
            .init_repository(true)
            .map_err(|e| tonic::Status::internal(e.to_string()))?;

        crate::snapshot::ops::restore_snapshot(&target_path, &bundle_data)
            .map_err(|e| tonic::Status::internal(e.to_string()))?;

        if let Some(ref hm) = self.hook_manager {
            hm.install_hooks(&target_path)
                .map_err(|e| tonic::Status::internal(e.to_string()))?;
        }

        let source_path = gb.bare_dir.clone();
        std::fs::remove_dir_all(&source_path)
            .map_err(|e| tonic::Status::internal(e.to_string()))?;

        self.notify_ref_update(&source_repo, "HEAD", "", "");

        tracing::info!(source = %source_repo, "repository moved successfully");
        Ok(tonic::Response::new(MoveRepositoryResponse {
            state: MoveRepositoryState::MoveStateCompleted as i32,
            error_message: String::new(),
        }))
    }

    async fn fetch_repository_data(
        &self,
        request: tonic::Request<FetchRepositoryDataRequest>,
    ) -> Result<tonic::Response<Self::FetchRepositoryDataStream>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.fetch_repository_data", %repo);
        let _enter = span.enter();

        let gb = self.resolve(inner.repository.as_ref())?;
        let bundle_data = crate::snapshot::ops::create_snapshot(&gb)
            .map_err(|e| tonic::Status::internal(e.to_string()))?;

        let (tx, rx) = tokio::sync::mpsc::channel(16);
        tokio::spawn(async move {
            const CHUNK_SIZE: usize = 65536;
            let total = bundle_data.len();
            if total == 0 {
                let _ = tx
                    .send(Ok(FetchRepositoryDataResponse {
                        data: vec![],
                        done: true,
                    }))
                    .await;
                return;
            }
            for offset in (0..total).step_by(CHUNK_SIZE) {
                let end = offset.saturating_add(CHUNK_SIZE).min(total);
                let chunk_data = bundle_data[offset..end].to_vec();
                let is_done = end >= total;
                if tx
                    .send(Ok(FetchRepositoryDataResponse {
                        data: chunk_data,
                        done: is_done,
                    }))
                    .await
                    .is_err()
                {
                    break;
                }
            }
        });

        Ok(tonic::Response::new(ReceiverStream::new(rx)))
    }

    async fn find_merge_base(
        &self,
        request: tonic::Request<FindMergeBaseRequest>,
    ) -> Result<tonic::Response<FindMergeBaseResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/FindMergeBase");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.find_merge_base(inner).map_err(into_status)?;
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn write_ref(
        &self,
        request: tonic::Request<WriteRefRequest>,
    ) -> Result<tonic::Response<WriteRefResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/WriteRef");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.write_ref(inner).map_err(into_status)?;
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn search_files_by_content(
        &self,
        request: tonic::Request<SearchFilesByContentRequest>,
    ) -> Result<tonic::Response<SearchFilesByContentResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/SearchFilesByContent");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.search_files_by_content(inner).map_err(into_status)?;
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn search_files_by_name(
        &self,
        request: tonic::Request<SearchFilesByNameRequest>,
    ) -> Result<tonic::Response<SearchFilesByNameResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/SearchFilesByName");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.search_files_by_name(inner).map_err(into_status)?;
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn objects_size(
        &self,
        request: tonic::Request<ObjectsSizeRequest>,
    ) -> Result<tonic::Response<ObjectsSizeResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/ObjectsSize");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.objects_size(inner).map_err(into_status)?;
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn repository_size(
        &self,
        request: tonic::Request<RepositorySizeRequest>,
    ) -> Result<tonic::Response<RepositorySizeResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/RepositorySize");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.repository_size().map_err(into_status)?;
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn fetch_remote(
        &self,
        request: tonic::Request<FetchRemoteRequest>,
    ) -> Result<tonic::Response<FetchRemoteResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/FetchRemote");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.fetch_remote(inner).map_err(into_status)?;
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn create_repository_from_url(
        &self,
        request: tonic::Request<CreateRepositoryFromUrlRequest>,
    ) -> Result<tonic::Response<CreateRepositoryFromUrlResponse>, tonic::Status> {
        let m =
            crate::metrics::RequestMetrics::new("gitks.RepositoryService/CreateRepositoryFromURL");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
        let gb = crate::bare::GitBare::new(bare_dir);
        gb.create_repository_from_url(&inner.remote_url, inner.mirror)
            .map_err(into_status)?;
        if let Some(ref hm) = self.hook_manager {
            hm.install_hooks(&gb.bare_dir).map_err(into_status)?;
        }
        self.notify_ref_update(&self.repo_label(inner.repository.as_ref()), "HEAD", "", "");
        m.record("ok");
        Ok(tonic::Response::new(CreateRepositoryFromUrlResponse {
            repository: Some(Repository {
                header: inner.repository,
                bare: true,
                ..Default::default()
            }),
        }))
    }

    async fn find_license(
        &self,
        request: tonic::Request<FindLicenseRequest>,
    ) -> Result<tonic::Response<FindLicenseResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/FindLicense");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.find_license().map_err(into_status)?;
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn optimize_repository(
        &self,
        request: tonic::Request<OptimizeRepositoryRequest>,
    ) -> Result<tonic::Response<OptimizeRepositoryResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/OptimizeRepository");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.optimize_repository(inner).map_err(into_status)?;
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn get_raw_changes(
        &self,
        request: tonic::Request<GetRawChangesRequest>,
    ) -> Result<tonic::Response<GetRawChangesResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/GetRawChanges");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.get_raw_changes(inner).map_err(into_status)?;
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn get_language_stats(
        &self,
        request: tonic::Request<GetLanguageStatsRequest>,
    ) -> Result<tonic::Response<GetLanguageStatsResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/GetLanguageStats");
        let inner = request.into_inner();
        let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("repo.get_language_stats", %repo);
        let _enter = span.enter();
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.get_language_stats(inner).map_err(into_status)?;
        tracing::info!(%repo, languages = resp.languages.len(), "language stats done");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }
}