gitks/server/merge.rs

use crate::pb::*;
use crate::pb::merge_service_client::MergeServiceClient;

use super::{GitksService, into_status};

async fn remote_merge_client(
    svc: &GitksService,
    header: Option<&RepositoryHeader>,
    is_write: bool,
) -> Result<Option<MergeServiceClient<tonic::transport::Channel>>, tonic::Status> {
    let header = match header {
        Some(h) => h,
        None => return Ok(None),
    };
    let Some(route) = svc.route_repository(header, is_write).await? else {
        return Ok(None);
    };
    tracing::info!(storage_name = %route.storage_name, relative_path = %route.relative_path, actor_name = %route.actor_name, grpc_addr = %route.grpc_addr, "forwarding merge rpc");
    let endpoint = super::remote_endpoint(&route.grpc_addr).await?;
    let client = MergeServiceClient::connect(endpoint)
        .await
        .map_err(|e| tonic::Status::unavailable(e.to_string()))?;
    Ok(Some(client))
}

#[tonic::async_trait]
impl merge_service_server::MergeService for GitksService {
    async fn check_merge(
        &self,
        request: tonic::Request<CheckMergeRequest>,
    ) -> Result<tonic::Response<MergeResult>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("merge.check_merge", %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_merge_client(self, inner.repository.as_ref(), false).await? {
                    return client.check_merge(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        let resp = gb.check_merge(inner).map_err(into_status)?;
        tracing::info!(%repo, status = resp.status, "check_merge done");
        Ok(tonic::Response::new(resp))
    }

    async fn merge(
        &self,
        request: tonic::Request<MergeRequest>,
    ) -> Result<tonic::Response<MergeResult>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let target = inner.target_branch.clone();
        let span = tracing::info_span!("merge.merge", %repo, %target);
        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_merge_client(self, inner.repository.as_ref(), true).await? {
                    return client.merge(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        let resp = gb.merge(inner).map_err(into_status)?;
        tracing::info!(%repo, %target, status = resp.status, "merge done");
        self.notify_ref_update(&repo, &format!("refs/heads/{}", target), "", "");
        Ok(tonic::Response::new(resp))
    }

    async fn list_merge_conflicts(
        &self,
        request: tonic::Request<ListMergeConflictsRequest>,
    ) -> Result<tonic::Response<ListMergeConflictsResponse>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let span = tracing::info_span!("merge.list_merge_conflicts", %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_merge_client(self, inner.repository.as_ref(), false).await? {
                    return client.list_merge_conflicts(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        let resp = gb.list_merge_conflicts(inner).map_err(into_status)?;
        tracing::info!(%repo, conflicts = resp.conflicts.len(), "list_merge_conflicts done");
        Ok(tonic::Response::new(resp))
    }

    async fn resolve_merge_conflicts(
        &self,
        request: tonic::Request<ResolveMergeConflictsRequest>,
    ) -> Result<tonic::Response<MergeResult>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let target = inner.target_branch.clone();
        let span = tracing::info_span!("merge.resolve_merge_conflicts", %repo, %target);
        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_merge_client(self, inner.repository.as_ref(), true).await? {
                    return client.resolve_merge_conflicts(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        let resp = gb.resolve_merge_conflicts(inner).map_err(into_status)?;
        tracing::info!(%repo, %target, status = resp.status, "merge conflicts resolved");
        self.notify_ref_update(&repo, &format!("refs/heads/{}", target), "", "");
        Ok(tonic::Response::new(resp))
    }

    async fn rebase(
        &self,
        request: tonic::Request<RebaseRequest>,
    ) -> Result<tonic::Response<RebaseResult>, tonic::Status> {
        let inner = request.into_inner();
        let repo = self.repo_label(inner.repository.as_ref());
        let branch = inner.branch.clone();
        let span = tracing::info_span!("merge.rebase", %repo, %branch);
        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_merge_client(self, inner.repository.as_ref(), true).await? {
                    return client.rebase(inner).await;
                }
                return Err(err);
            }
            Err(err) => return Err(err),
        };
        let resp = gb.rebase(inner).map_err(into_status)?;
        tracing::info!(%repo, %branch, status = resp.status, "rebase done");
        self.notify_ref_update(&repo, &format!("refs/heads/{}", branch), "", "");
        Ok(tonic::Response::new(resp))
    }
}