gitks/server/refs.rs

use crate::pb::ref_service_server::RefService;
use crate::pb::*;

use super::GitksService;

#[tonic::async_trait]
impl RefService for GitksService {
    async fn find_default_branch_name(
        &self,
        request: tonic::Request<FindDefaultBranchNameRequest>,
    ) -> Result<tonic::Response<FindDefaultBranchNameResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RefService/FindDefaultBranchName");
        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!("ref.find_default_branch_name", %repo);
        let _enter = span.enter();
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.find_default_branch_name().map_err(super::into_status)?;
        tracing::info!(%repo, "find_default_branch_name done");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn ref_exists(
        &self,
        request: tonic::Request<RefExistsRequest>,
    ) -> Result<tonic::Response<RefExistsResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RefService/RefExists");
        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 ref_name = inner.ref_name.clone();
        let span = tracing::info_span!("ref.ref_exists", %repo, %ref_name);
        let _enter = span.enter();
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.ref_exists(inner).map_err(super::into_status)?;
        tracing::info!(%repo, %ref_name, exists = resp.exists, "ref_exists done");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn update_references(
        &self,
        request: tonic::Request<UpdateReferencesRequest>,
    ) -> Result<tonic::Response<UpdateReferencesResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RefService/UpdateReferences");
        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 updates_count = inner.updates.len();
        let span = tracing::info_span!("ref.update_references", %repo, %updates_count);
        let _enter = span.enter();
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.update_references(inner).map_err(super::into_status)?;
        tracing::info!(%repo, %updates_count, failed = resp.failed_refs.len(), "update_references done");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn delete_refs(
        &self,
        request: tonic::Request<DeleteRefsRequest>,
    ) -> Result<tonic::Response<DeleteRefsResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RefService/DeleteRefs");
        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 ref_count = inner.ref_names.len();
        let span = tracing::info_span!("ref.delete_refs", %repo, %ref_count);
        let _enter = span.enter();
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.delete_refs(inner).map_err(super::into_status)?;
        tracing::info!(%repo, %ref_count, failed = resp.failed_refs.len(), "delete_refs done");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn find_refs_by_oid(
        &self,
        request: tonic::Request<FindRefsByOidRequest>,
    ) -> Result<tonic::Response<FindRefsByOidResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RefService/FindRefsByOID");
        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 oid = inner.oid.clone();
        let span = tracing::info_span!("ref.find_refs_by_oid", %repo, %oid);
        let _enter = span.enter();
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.find_refs_by_oid(inner).map_err(super::into_status)?;
        tracing::info!(%repo, %oid, count = resp.refs.len(), "find_refs_by_oid done");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }

    async fn list_refs(
        &self,
        request: tonic::Request<ListRefsRequest>,
    ) -> Result<tonic::Response<ListRefsResponse>, tonic::Status> {
        let m = crate::metrics::RequestMetrics::new("gitks.RefService/ListRefs");
        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 prefixes = inner.prefixes.len();
        let pattern = inner.pattern.clone();
        let span = tracing::info_span!("ref.list_refs", %repo, %prefixes, %pattern);
        let _enter = span.enter();
        let gb = self.resolve(inner.repository.as_ref())?;
        let resp = gb.list_all_refs(inner).map_err(super::into_status)?;
        tracing::info!(%repo, count = resp.refs.len(), "list_refs done");
        m.record("ok");
        Ok(tonic::Response::new(resp))
    }
}