Line data    Source code

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