Line data    Source code

       1              : use safekeeper_api::models::{
       2              :     self, PullTimelineRequest, PullTimelineResponse, SafekeeperUtilization, TimelineCreateRequest,
       3              :     TimelineStatus,
       4              : };
       5              : use safekeeper_client::mgmt_api::{Client, Result};
       6              : use utils::id::{NodeId, TenantId, TimelineId};
       7              : use utils::logging::SecretString;
       8              : 
       9              : use crate::metrics::PageserverRequestLabelGroup;
      10              : 
      11              : /// Thin wrapper around [`safekeeper_client::mgmt_api::Client`]. It allows the storage
      12              : /// controller to collect metrics in a non-intrusive manner.
      13              : ///
      14              : /// Analogous to [`crate::pageserver_client::PageserverClient`].
      15              : #[derive(Debug, Clone)]
      16              : pub(crate) struct SafekeeperClient {
      17              :     inner: Client,
      18              :     node_id_label: String,
      19              : }
      20              : 
      21              : macro_rules! measured_request {
      22              :     ($name:literal, $method:expr, $node_id: expr, $invoke:expr) => {{
      23              :         let labels = PageserverRequestLabelGroup {
      24              :             pageserver_id: $node_id,
      25              :             path: $name,
      26              :             method: $method,
      27              :         };
      28              : 
      29              :         let latency = &crate::metrics::METRICS_REGISTRY
      30              :             .metrics_group
      31              :             .storage_controller_safekeeper_request_latency;
      32              :         let _timer_guard = latency.start_timer(labels.clone());
      33              : 
      34              :         let res = $invoke;
      35              : 
      36              :         if res.is_err() {
      37              :             let error_counters = &crate::metrics::METRICS_REGISTRY
      38              :                 .metrics_group
      39              :                 .storage_controller_pageserver_request_error;
      40              :             error_counters.inc(labels)
      41              :         }
      42              : 
      43              :         res
      44              :     }};
      45              : }
      46              : 
      47              : impl SafekeeperClient {
      48            0 :     pub(crate) fn new(
      49            0 :         node_id: NodeId,
      50            0 :         raw_client: reqwest::Client,
      51            0 :         mgmt_api_endpoint: String,
      52            0 :         jwt: Option<SecretString>,
      53            0 :     ) -> Self {
      54            0 :         Self {
      55            0 :             inner: Client::new(raw_client, mgmt_api_endpoint, jwt),
      56            0 :             node_id_label: node_id.0.to_string(),
      57            0 :         }
      58            0 :     }
      59              : 
      60            0 :     pub(crate) async fn create_timeline(
      61            0 :         &self,
      62            0 :         req: &TimelineCreateRequest,
      63            0 :     ) -> Result<TimelineStatus> {
      64            0 :         measured_request!(
      65            0 :             "create_timeline",
      66            0 :             crate::metrics::Method::Post,
      67            0 :             &self.node_id_label,
      68            0 :             self.inner.create_timeline(req).await
      69            0 :         )
      70            0 :     }
      71              : 
      72              :     #[allow(unused)]
      73            0 :     pub(crate) async fn exclude_timeline(
      74            0 :         &self,
      75            0 :         tenant_id: TenantId,
      76            0 :         timeline_id: TimelineId,
      77            0 :         req: &models::TimelineMembershipSwitchRequest,
      78            0 :     ) -> Result<models::TimelineDeleteResult> {
      79            0 :         measured_request!(
      80            0 :             "exclude_timeline",
      81            0 :             crate::metrics::Method::Post,
      82            0 :             &self.node_id_label,
      83            0 :             self.inner
      84            0 :                 .exclude_timeline(tenant_id, timeline_id, req)
      85            0 :                 .await
      86            0 :         )
      87            0 :     }
      88              : 
      89            0 :     pub(crate) async fn delete_timeline(
      90            0 :         &self,
      91            0 :         tenant_id: TenantId,
      92            0 :         timeline_id: TimelineId,
      93            0 :     ) -> Result<models::TimelineDeleteResult> {
      94            0 :         measured_request!(
      95            0 :             "delete_timeline",
      96            0 :             crate::metrics::Method::Delete,
      97            0 :             &self.node_id_label,
      98            0 :             self.inner.delete_timeline(tenant_id, timeline_id).await
      99            0 :         )
     100            0 :     }
     101              : 
     102            0 :     pub(crate) async fn pull_timeline(
     103            0 :         &self,
     104            0 :         req: &PullTimelineRequest,
     105            0 :     ) -> Result<PullTimelineResponse> {
     106            0 :         measured_request!(
     107            0 :             "pull_timeline",
     108            0 :             crate::metrics::Method::Post,
     109            0 :             &self.node_id_label,
     110            0 :             self.inner.pull_timeline(req).await
     111            0 :         )
     112            0 :     }
     113              : 
     114              :     #[allow(unused)]
     115            0 :     pub(crate) async fn bump_timeline_term(
     116            0 :         &self,
     117            0 :         tenant_id: TenantId,
     118            0 :         timeline_id: TimelineId,
     119            0 :         req: &models::TimelineTermBumpRequest,
     120            0 :     ) -> Result<models::TimelineTermBumpResponse> {
     121            0 :         measured_request!(
     122            0 :             "term_bump",
     123            0 :             crate::metrics::Method::Post,
     124            0 :             &self.node_id_label,
     125            0 :             self.inner
     126            0 :                 .bump_timeline_term(tenant_id, timeline_id, req)
     127            0 :                 .await
     128            0 :         )
     129            0 :     }
     130              : 
     131            0 :     pub(crate) async fn get_utilization(&self) -> Result<SafekeeperUtilization> {
     132            0 :         measured_request!(
     133            0 :             "utilization",
     134            0 :             crate::metrics::Method::Get,
     135            0 :             &self.node_id_label,
     136            0 :             self.inner.utilization().await
     137            0 :         )
     138            0 :     }
     139              : }