gitks/server/merge.rs

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

use super::{GitksService, into_status};

remote_client!(
    remote_merge_client,
    MergeServiceClient<tonic::transport::Channel>,
    "merge"
);

#[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 m = crate::metrics::RequestMetrics::new("gitks.MergeService/CheckMerge");
        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!("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?
                {
                    m.record("ok");
                    return client.check_merge(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 resp = gb.check_merge(inner).map_err(into_status)?;
        tracing::info!(%repo, status = resp.status, "check_merge done");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn merge(
        &self,
        request: tonic::Request<MergeRequest>,
    ) -> Result<tonic::Response<MergeResult>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.MergeService/Merge");
        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 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?
                {
                    m.record("ok");
                    return client.merge(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 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), "", "");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn list_merge_conflicts(
        &self,
        request: tonic::Request<ListMergeConflictsRequest>,
    ) -> Result<tonic::Response<ListMergeConflictsResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.MergeService/ListMergeConflicts");
        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!("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?
                {
                    m.record("ok");
                    return client.list_merge_conflicts(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 resp = gb.list_merge_conflicts(inner).map_err(into_status)?;
        tracing::info!(%repo, conflicts = resp.conflicts.len(), "list_merge_conflicts done");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn resolve_merge_conflicts(
        &self,
        request: tonic::Request<ResolveMergeConflictsRequest>,
    ) -> Result<tonic::Response<MergeResult>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.MergeService/ResolveMergeConflicts");
        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 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?
                {
                    m.record("ok");
                    return client.resolve_merge_conflicts(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 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), "", "");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn rebase(
        &self,
        request: tonic::Request<RebaseRequest>,
    ) -> Result<tonic::Response<RebaseResult>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.MergeService/Rebase");
        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 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?
                {
                    m.record("ok");
                    return client.rebase(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 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), "", "");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }
}