YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// THIS FILE IS AUTOGENERATED FROM yb/cdc/cdc_service.proto

#include "yb/cdc/cdc_service.pb.h"

#include "yb/cdc/cdc_service.service.h"

#include <glog/logging.h>

#include "yb/rpc/inbound_call.h"

#include "yb/rpc/local_call.h"

#include "yb/rpc/remote_method.h"

#include "yb/rpc/rpc_context.h"

#include "yb/rpc/rpc_service.h"

#include "yb/rpc/service_if.h"

#include "yb/util/metrics.h"

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_cdc_CDCService_CreateCDCStream,

  "Bytes received by yb.cdc.CDCService.CreateCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.cdc.CDCService.CreateCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_cdc_CDCService_CreateCDCStream,

  "Bytes sent in response to yb.cdc.CDCService.CreateCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.cdc.CDCService.CreateCDCStream() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_cdc_CDCService_CreateCDCStream,

  "Microseconds spent handling yb.cdc.CDCService.CreateCDCStream() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.cdc.CDCService.CreateCDCStream() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_cdc_CDCService_DeleteCDCStream,

  "Bytes received by yb.cdc.CDCService.DeleteCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.cdc.CDCService.DeleteCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_cdc_CDCService_DeleteCDCStream,

  "Bytes sent in response to yb.cdc.CDCService.DeleteCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.cdc.CDCService.DeleteCDCStream() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_cdc_CDCService_DeleteCDCStream,

  "Microseconds spent handling yb.cdc.CDCService.DeleteCDCStream() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.cdc.CDCService.DeleteCDCStream() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_cdc_CDCService_ListTablets,

  "Bytes received by yb.cdc.CDCService.ListTablets() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.cdc.CDCService.ListTablets() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_cdc_CDCService_ListTablets,

  "Bytes sent in response to yb.cdc.CDCService.ListTablets() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.cdc.CDCService.ListTablets() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_cdc_CDCService_ListTablets,

  "Microseconds spent handling yb.cdc.CDCService.ListTablets() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.cdc.CDCService.ListTablets() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_cdc_CDCService_GetChanges,

  "Bytes received by yb.cdc.CDCService.GetChanges() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.cdc.CDCService.GetChanges() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_cdc_CDCService_GetChanges,

  "Bytes sent in response to yb.cdc.CDCService.GetChanges() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.cdc.CDCService.GetChanges() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_cdc_CDCService_GetChanges,

  "Microseconds spent handling yb.cdc.CDCService.GetChanges() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.cdc.CDCService.GetChanges() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_cdc_CDCService_GetCheckpoint,

  "Bytes received by yb.cdc.CDCService.GetCheckpoint() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.cdc.CDCService.GetCheckpoint() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_cdc_CDCService_GetCheckpoint,

  "Bytes sent in response to yb.cdc.CDCService.GetCheckpoint() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.cdc.CDCService.GetCheckpoint() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_cdc_CDCService_GetCheckpoint,

  "Microseconds spent handling yb.cdc.CDCService.GetCheckpoint() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.cdc.CDCService.GetCheckpoint() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_cdc_CDCService_UpdateCdcReplicatedIndex,

  "Bytes received by yb.cdc.CDCService.UpdateCdcReplicatedIndex() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.cdc.CDCService.UpdateCdcReplicatedIndex() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_cdc_CDCService_UpdateCdcReplicatedIndex,

  "Bytes sent in response to yb.cdc.CDCService.UpdateCdcReplicatedIndex() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.cdc.CDCService.UpdateCdcReplicatedIndex() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_cdc_CDCService_UpdateCdcReplicatedIndex,

  "Microseconds spent handling yb.cdc.CDCService.UpdateCdcReplicatedIndex() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.cdc.CDCService.UpdateCdcReplicatedIndex() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_cdc_CDCService_BootstrapProducer,

  "Bytes received by yb.cdc.CDCService.BootstrapProducer() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.cdc.CDCService.BootstrapProducer() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_cdc_CDCService_BootstrapProducer,

  "Bytes sent in response to yb.cdc.CDCService.BootstrapProducer() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.cdc.CDCService.BootstrapProducer() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_cdc_CDCService_BootstrapProducer,

  "Microseconds spent handling yb.cdc.CDCService.BootstrapProducer() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.cdc.CDCService.BootstrapProducer() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_cdc_CDCService_GetLatestEntryOpId,

  "Bytes received by yb.cdc.CDCService.GetLatestEntryOpId() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.cdc.CDCService.GetLatestEntryOpId() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_cdc_CDCService_GetLatestEntryOpId,

  "Bytes sent in response to yb.cdc.CDCService.GetLatestEntryOpId() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.cdc.CDCService.GetLatestEntryOpId() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_cdc_CDCService_GetLatestEntryOpId,

  "Microseconds spent handling yb.cdc.CDCService.GetLatestEntryOpId() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.cdc.CDCService.GetLatestEntryOpId() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_cdc_CDCService_GetCDCDBStreamInfo,

  "Bytes received by yb.cdc.CDCService.GetCDCDBStreamInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.cdc.CDCService.GetCDCDBStreamInfo() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_cdc_CDCService_GetCDCDBStreamInfo,

  "Bytes sent in response to yb.cdc.CDCService.GetCDCDBStreamInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.cdc.CDCService.GetCDCDBStreamInfo() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_cdc_CDCService_GetCDCDBStreamInfo,

  "Microseconds spent handling yb.cdc.CDCService.GetCDCDBStreamInfo() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.cdc.CDCService.GetCDCDBStreamInfo() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_cdc_CDCService_SetCDCCheckpoint,

  "Bytes received by yb.cdc.CDCService.SetCDCCheckpoint() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.cdc.CDCService.SetCDCCheckpoint() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_cdc_CDCService_SetCDCCheckpoint,

  "Bytes sent in response to yb.cdc.CDCService.SetCDCCheckpoint() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.cdc.CDCService.SetCDCCheckpoint() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_cdc_CDCService_SetCDCCheckpoint,

  "Microseconds spent handling yb.cdc.CDCService.SetCDCCheckpoint() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.cdc.CDCService.SetCDCCheckpoint() RPC requests",

  60000000LU, 2);

namespace yb {

namespace cdc {

void SetupError(::yb::cdc::CDCErrorPB* error, const Status& status);

CDCServiceIf::CDCServiceIf(const scoped_refptr<MetricEntity>& entity) {

  InitMethods(entity);

}

CDCServiceIf::~CDCServiceIf() {

}

void CDCServiceIf::FillEndpoints(const ::yb::rpc::RpcServicePtr& service, ::yb::rpc::RpcEndpointMap* map) {

  map->emplace(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kCreateCDCStream)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(CDCServiceRpcMethodIndexes::kCreateCDCStream)));

  map->emplace(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kDeleteCDCStream)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(CDCServiceRpcMethodIndexes::kDeleteCDCStream)));

  map->emplace(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kListTablets)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(CDCServiceRpcMethodIndexes::kListTablets)));

  map->emplace(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetChanges)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetChanges)));

  map->emplace(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetCheckpoint)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetCheckpoint)));

  map->emplace(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kUpdateCdcReplicatedIndex)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(CDCServiceRpcMethodIndexes::kUpdateCdcReplicatedIndex)));

  map->emplace(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kBootstrapProducer)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(CDCServiceRpcMethodIndexes::kBootstrapProducer)));

  map->emplace(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetLatestEntryOpId)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetLatestEntryOpId)));

  map->emplace(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetCDCDBStreamInfo)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetCDCDBStreamInfo)));

  map->emplace(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kSetCDCCheckpoint)].method.serialized_body(), std::make_pair(service, static_cast<size_t>(CDCServiceRpcMethodIndexes::kSetCDCCheckpoint)));

}

void CDCServiceIf::Handle(::yb::rpc::InboundCallPtr call) {

  auto index = call->method_index();

  methods_[index].handler(std::move(call));

}

std::string CDCServiceIf::service_name() const {

  return "yb.cdc.CDCService";

}

std::string CDCServiceIf::static_service_name() {

  return "yb.cdc.CDCService";

}

void CDCServiceIf::InitMethods(const scoped_refptr<MetricEntity>& entity) {

  methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kCreateCDCStream)] = {

    .method = ::yb::rpc::RemoteMethod("yb.cdc.CDCService", "CreateCDCStream"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kCreateCDCStream)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::cdc::CreateCDCStreamRequestPB, ::yb::cdc::CreateCDCStreamResponsePB>>(

          std::move(call), [this](const ::yb::cdc::CreateCDCStreamRequestPB* req, ::yb::cdc::CreateCDCStreamResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        CreateCDCStream(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_cdc_CDCService_CreateCDCStream.Instantiate(entity),

        METRIC_service_response_bytes_yb_cdc_CDCService_CreateCDCStream.Instantiate(entity),

        METRIC_handler_latency_yb_cdc_CDCService_CreateCDCStream.Instantiate(entity))

  };

  methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kDeleteCDCStream)] = {

    .method = ::yb::rpc::RemoteMethod("yb.cdc.CDCService", "DeleteCDCStream"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kDeleteCDCStream)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::cdc::DeleteCDCStreamRequestPB, ::yb::cdc::DeleteCDCStreamResponsePB>>(

          std::move(call), [this](const ::yb::cdc::DeleteCDCStreamRequestPB* req, ::yb::cdc::DeleteCDCStreamResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        DeleteCDCStream(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_cdc_CDCService_DeleteCDCStream.Instantiate(entity),

        METRIC_service_response_bytes_yb_cdc_CDCService_DeleteCDCStream.Instantiate(entity),

        METRIC_handler_latency_yb_cdc_CDCService_DeleteCDCStream.Instantiate(entity))

  };

  methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kListTablets)] = {

    .method = ::yb::rpc::RemoteMethod("yb.cdc.CDCService", "ListTablets"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kListTablets)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::cdc::ListTabletsRequestPB, ::yb::cdc::ListTabletsResponsePB>>(

          std::move(call), [this](const ::yb::cdc::ListTabletsRequestPB* req, ::yb::cdc::ListTabletsResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        ListTablets(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_cdc_CDCService_ListTablets.Instantiate(entity),

        METRIC_service_response_bytes_yb_cdc_CDCService_ListTablets.Instantiate(entity),

        METRIC_handler_latency_yb_cdc_CDCService_ListTablets.Instantiate(entity))

  };

  methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetChanges)] = {

    .method = ::yb::rpc::RemoteMethod("yb.cdc.CDCService", "GetChanges"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetChanges)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::cdc::GetChangesRequestPB, ::yb::cdc::GetChangesResponsePB>>(

          std::move(call), [this](const ::yb::cdc::GetChangesRequestPB* req, ::yb::cdc::GetChangesResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetChanges(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_cdc_CDCService_GetChanges.Instantiate(entity),

        METRIC_service_response_bytes_yb_cdc_CDCService_GetChanges.Instantiate(entity),

        METRIC_handler_latency_yb_cdc_CDCService_GetChanges.Instantiate(entity))

  };

  methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetCheckpoint)] = {

    .method = ::yb::rpc::RemoteMethod("yb.cdc.CDCService", "GetCheckpoint"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetCheckpoint)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::cdc::GetCheckpointRequestPB, ::yb::cdc::GetCheckpointResponsePB>>(

          std::move(call), [this](const ::yb::cdc::GetCheckpointRequestPB* req, ::yb::cdc::GetCheckpointResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetCheckpoint(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_cdc_CDCService_GetCheckpoint.Instantiate(entity),

        METRIC_service_response_bytes_yb_cdc_CDCService_GetCheckpoint.Instantiate(entity),

        METRIC_handler_latency_yb_cdc_CDCService_GetCheckpoint.Instantiate(entity))

  };

  methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kUpdateCdcReplicatedIndex)] = {

    .method = ::yb::rpc::RemoteMethod("yb.cdc.CDCService", "UpdateCdcReplicatedIndex"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kUpdateCdcReplicatedIndex)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::cdc::UpdateCdcReplicatedIndexRequestPB, ::yb::cdc::UpdateCdcReplicatedIndexResponsePB>>(

          std::move(call), [this](const ::yb::cdc::UpdateCdcReplicatedIndexRequestPB* req, ::yb::cdc::UpdateCdcReplicatedIndexResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        UpdateCdcReplicatedIndex(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_cdc_CDCService_UpdateCdcReplicatedIndex.Instantiate(entity),

        METRIC_service_response_bytes_yb_cdc_CDCService_UpdateCdcReplicatedIndex.Instantiate(entity),

        METRIC_handler_latency_yb_cdc_CDCService_UpdateCdcReplicatedIndex.Instantiate(entity))

  };

  methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kBootstrapProducer)] = {

    .method = ::yb::rpc::RemoteMethod("yb.cdc.CDCService", "BootstrapProducer"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kBootstrapProducer)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::cdc::BootstrapProducerRequestPB, ::yb::cdc::BootstrapProducerResponsePB>>(

          std::move(call), [this](const ::yb::cdc::BootstrapProducerRequestPB* req, ::yb::cdc::BootstrapProducerResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        BootstrapProducer(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_cdc_CDCService_BootstrapProducer.Instantiate(entity),

        METRIC_service_response_bytes_yb_cdc_CDCService_BootstrapProducer.Instantiate(entity),

        METRIC_handler_latency_yb_cdc_CDCService_BootstrapProducer.Instantiate(entity))

  };

  methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetLatestEntryOpId)] = {

    .method = ::yb::rpc::RemoteMethod("yb.cdc.CDCService", "GetLatestEntryOpId"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetLatestEntryOpId)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::cdc::GetLatestEntryOpIdRequestPB, ::yb::cdc::GetLatestEntryOpIdResponsePB>>(

          std::move(call), [this](const ::yb::cdc::GetLatestEntryOpIdRequestPB* req, ::yb::cdc::GetLatestEntryOpIdResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetLatestEntryOpId(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_cdc_CDCService_GetLatestEntryOpId.Instantiate(entity),

        METRIC_service_response_bytes_yb_cdc_CDCService_GetLatestEntryOpId.Instantiate(entity),

        METRIC_handler_latency_yb_cdc_CDCService_GetLatestEntryOpId.Instantiate(entity))

  };

  methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetCDCDBStreamInfo)] = {

    .method = ::yb::rpc::RemoteMethod("yb.cdc.CDCService", "GetCDCDBStreamInfo"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kGetCDCDBStreamInfo)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::cdc::GetCDCDBStreamInfoRequestPB, ::yb::cdc::GetCDCDBStreamInfoResponsePB>>(

          std::move(call), [this](const ::yb::cdc::GetCDCDBStreamInfoRequestPB* req, ::yb::cdc::GetCDCDBStreamInfoResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        GetCDCDBStreamInfo(req, resp, std::move(rpc_context));

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_cdc_CDCService_GetCDCDBStreamInfo.Instantiate(entity),

        METRIC_service_response_bytes_yb_cdc_CDCService_GetCDCDBStreamInfo.Instantiate(entity),

        METRIC_handler_latency_yb_cdc_CDCService_GetCDCDBStreamInfo.Instantiate(entity))

  };

  methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kSetCDCCheckpoint)] = {

    .method = ::yb::rpc::RemoteMethod("yb.cdc.CDCService", "SetCDCCheckpoint"),

    .handler = [this](::yb::rpc::InboundCallPtr call) {

      call->SetRpcMethodMetrics(methods_[static_cast<size_t>(CDCServiceRpcMethodIndexes::kSetCDCCheckpoint)].metrics);

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::cdc::SetCDCCheckpointRequestPB, ::yb::cdc::SetCDCCheckpointResponsePB>>(

          std::move(call), [this](const ::yb::cdc::SetCDCCheckpointRequestPB* req, ::yb::cdc::SetCDCCheckpointResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

        auto result = SetCDCCheckpoint(*req, rpc_context.GetClientDeadline());

        rpc_context.RespondTrivial(&result, resp);

      });

    },

    .metrics = ::yb::rpc::RpcMethodMetrics(

        METRIC_service_request_bytes_yb_cdc_CDCService_SetCDCCheckpoint.Instantiate(entity),

        METRIC_service_response_bytes_yb_cdc_CDCService_SetCDCCheckpoint.Instantiate(entity),

        METRIC_handler_latency_yb_cdc_CDCService_SetCDCCheckpoint.Instantiate(entity))

  };

}

} // namespace cdc

} // namespace yb