Line data    Source code

       1              : use safekeeper_api::models::{
       2              :     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            0 :     pub(crate) async fn delete_timeline(
      73            0 :         &self,
      74            0 :         tenant_id: TenantId,
      75            0 :         timeline_id: TimelineId,
      76            0 :     ) -> Result<TimelineStatus> {
      77            0 :         measured_request!(
      78            0 :             "delete_timeline",
      79            0 :             crate::metrics::Method::Delete,
      80            0 :             &self.node_id_label,
      81            0 :             self.inner.delete_timeline(tenant_id, timeline_id).await
      82            0 :         )
      83            0 :     }
      84              : 
      85            0 :     pub(crate) async fn pull_timeline(
      86            0 :         &self,
      87            0 :         req: &PullTimelineRequest,
      88            0 :     ) -> Result<PullTimelineResponse> {
      89            0 :         measured_request!(
      90            0 :             "pull_timeline",
      91            0 :             crate::metrics::Method::Post,
      92            0 :             &self.node_id_label,
      93            0 :             self.inner.pull_timeline(req).await
      94            0 :         )
      95            0 :     }
      96              : 
      97            0 :     pub(crate) async fn get_utilization(&self) -> Result<SafekeeperUtilization> {
      98            0 :         measured_request!(
      99            0 :             "utilization",
     100            0 :             crate::metrics::Method::Get,
     101            0 :             &self.node_id_label,
     102            0 :             self.inner.utilization().await
     103            0 :         )
     104            0 :     }
     105              : }