gitks/server/repository.rs

use crate::pb::*;

use super::{GitksService, git_cmd, into_status, repository_maint};

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 inner = request.into_inner();
        let gb = self.resolve(inner.repository.as_ref())?;
        let bare = gb.bare_dir.join("HEAD").exists();
        let object_format = gb.object_format();
        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 inner = request.into_inner();
        let bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
        let gb = crate::bare::GitBare { bare_dir };
        gb.init_repository(inner.bare).map_err(into_status)?;
        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 inner = request.into_inner();
        let bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
        std::fs::remove_dir_all(&bare_dir).map_err(|e| tonic::Status::internal(e.to_string()))?;
        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 bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
        let exists = bare_dir.exists() && bare_dir.is_dir() && bare_dir.join("HEAD").exists();
        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 gb = self.resolve(inner.repository.as_ref())?;
        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 gb = self.resolve(inner.repository.as_ref())?;
        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 gb = self.resolve(inner.repository.as_ref())?;
        let refname = format!("refs/heads/{}", inner.name);
        let out = git_cmd(&gb, &["symbolic-ref", "HEAD", &refname])?;
        if !out.status.success() {
            return Err(tonic::Status::internal(
                String::from_utf8_lossy(&out.stderr).trim().to_string(),
            ));
        }
        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 gb = self.resolve(inner.repository.as_ref())?;
        let mut entries = Vec::new();
        if inner.keys.is_empty() {
            let out = git_cmd(&gb, &["config", "--list"])?;
            if !out.status.success() {
                return Err(tonic::Status::internal(
                    String::from_utf8_lossy(&out.stderr).trim().to_string(),
                ));
            }
            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 {
                let out = git_cmd(&gb, &["config", "--get-all", key])?;
                if out.status.success() {
                    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 gb = self.resolve(inner.repository.as_ref())?;
        for entry in &inner.entries {
            if entry.values.is_empty() {
                git_cmd(&gb, &["config", "--unset-all", &entry.key])?;
            } else {
                let _ = git_cmd(
                    &gb,
                    &["config", "--replace-all", &entry.key, &entry.values[0]],
                );
                for v in entry.values.iter().skip(1) {
                    let _ = git_cmd(&gb, &["config", "--add", &entry.key, v]);
                }
            }
        }
        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 gb = self.resolve(inner.repository.as_ref())?;
        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 gb = self.resolve(inner.repository.as_ref())?;
        Ok(tonic::Response::new(repository_maint::check_health(
            &gb,
            inner.connectivity_only,
        )?))
    }

    async fn garbage_collect(
        &self,
        request: tonic::Request<GarbageCollectRequest>,
    ) -> Result<tonic::Response<RepositoryMaintenanceResponse>, tonic::Status> {
        let inner = request.into_inner();
        let gb = self.resolve(inner.repository.as_ref())?;
        Ok(tonic::Response::new(repository_maint::run_gc(
            &gb,
            inner.prune,
            inner.aggressive,
        )?))
    }

    async fn repack(
        &self,
        request: tonic::Request<RepackRequest>,
    ) -> Result<tonic::Response<RepositoryMaintenanceResponse>, tonic::Status> {
        let inner = request.into_inner();
        let gb = self.resolve(inner.repository.as_ref())?;
        Ok(tonic::Response::new(repository_maint::run_repack(
            &gb,
            inner.full,
            inner.write_bitmaps,
            inner.write_multi_pack_index,
        )?))
    }

    async fn write_commit_graph(
        &self,
        request: tonic::Request<WriteCommitGraphRequest>,
    ) -> Result<tonic::Response<RepositoryMaintenanceResponse>, tonic::Status> {
        let inner = request.into_inner();
        let gb = self.resolve(inner.repository.as_ref())?;
        Ok(tonic::Response::new(
            repository_maint::run_commit_graph_write(&gb, inner.split, inner.replace)?,
        ))
    }
}