YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

// THIS FILE IS AUTOGENERATED FROM yb/master/master_replication.proto

#include "yb/master/master_replication.pb.h"

#include "yb/master/master_replication.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_master_MasterReplication_ValidateReplicationInfo,

  "Bytes received by yb.master.MasterReplication.ValidateReplicationInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.ValidateReplicationInfo() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_ValidateReplicationInfo,

  "Bytes sent in response to yb.master.MasterReplication.ValidateReplicationInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.ValidateReplicationInfo() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_ValidateReplicationInfo,

  "Microseconds spent handling yb.master.MasterReplication.ValidateReplicationInfo() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.ValidateReplicationInfo() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_CreateCDCStream,

  "Bytes received by yb.master.MasterReplication.CreateCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.CreateCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_CreateCDCStream,

  "Bytes sent in response to yb.master.MasterReplication.CreateCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.CreateCDCStream() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_CreateCDCStream,

  "Microseconds spent handling yb.master.MasterReplication.CreateCDCStream() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.CreateCDCStream() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_DeleteCDCStream,

  "Bytes received by yb.master.MasterReplication.DeleteCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.DeleteCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_DeleteCDCStream,

  "Bytes sent in response to yb.master.MasterReplication.DeleteCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.DeleteCDCStream() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_DeleteCDCStream,

  "Microseconds spent handling yb.master.MasterReplication.DeleteCDCStream() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.DeleteCDCStream() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_ListCDCStreams,

  "Bytes received by yb.master.MasterReplication.ListCDCStreams() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.ListCDCStreams() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_ListCDCStreams,

  "Bytes sent in response to yb.master.MasterReplication.ListCDCStreams() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.ListCDCStreams() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_ListCDCStreams,

  "Microseconds spent handling yb.master.MasterReplication.ListCDCStreams() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.ListCDCStreams() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_GetCDCStream,

  "Bytes received by yb.master.MasterReplication.GetCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.GetCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_GetCDCStream,

  "Bytes sent in response to yb.master.MasterReplication.GetCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.GetCDCStream() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_GetCDCStream,

  "Microseconds spent handling yb.master.MasterReplication.GetCDCStream() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.GetCDCStream() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_GetCDCDBStreamInfo,

  "Bytes received by yb.master.MasterReplication.GetCDCDBStreamInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.GetCDCDBStreamInfo() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_GetCDCDBStreamInfo,

  "Bytes sent in response to yb.master.MasterReplication.GetCDCDBStreamInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.GetCDCDBStreamInfo() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_GetCDCDBStreamInfo,

  "Microseconds spent handling yb.master.MasterReplication.GetCDCDBStreamInfo() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.GetCDCDBStreamInfo() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_UpdateCDCStream,

  "Bytes received by yb.master.MasterReplication.UpdateCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.UpdateCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_UpdateCDCStream,

  "Bytes sent in response to yb.master.MasterReplication.UpdateCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.UpdateCDCStream() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_UpdateCDCStream,

  "Microseconds spent handling yb.master.MasterReplication.UpdateCDCStream() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.UpdateCDCStream() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_SetupUniverseReplication,

  "Bytes received by yb.master.MasterReplication.SetupUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.SetupUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_SetupUniverseReplication,

  "Bytes sent in response to yb.master.MasterReplication.SetupUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.SetupUniverseReplication() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_SetupUniverseReplication,

  "Microseconds spent handling yb.master.MasterReplication.SetupUniverseReplication() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.SetupUniverseReplication() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_DeleteUniverseReplication,

  "Bytes received by yb.master.MasterReplication.DeleteUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.DeleteUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_DeleteUniverseReplication,

  "Bytes sent in response to yb.master.MasterReplication.DeleteUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.DeleteUniverseReplication() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_DeleteUniverseReplication,

  "Microseconds spent handling yb.master.MasterReplication.DeleteUniverseReplication() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.DeleteUniverseReplication() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_AlterUniverseReplication,

  "Bytes received by yb.master.MasterReplication.AlterUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.AlterUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_AlterUniverseReplication,

  "Bytes sent in response to yb.master.MasterReplication.AlterUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.AlterUniverseReplication() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_AlterUniverseReplication,

  "Microseconds spent handling yb.master.MasterReplication.AlterUniverseReplication() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.AlterUniverseReplication() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_SetUniverseReplicationEnabled,

  "Bytes received by yb.master.MasterReplication.SetUniverseReplicationEnabled() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.SetUniverseReplicationEnabled() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_SetUniverseReplicationEnabled,

  "Bytes sent in response to yb.master.MasterReplication.SetUniverseReplicationEnabled() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.SetUniverseReplicationEnabled() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_SetUniverseReplicationEnabled,

  "Microseconds spent handling yb.master.MasterReplication.SetUniverseReplicationEnabled() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.SetUniverseReplicationEnabled() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_GetUniverseReplication,

  "Bytes received by yb.master.MasterReplication.GetUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.GetUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_GetUniverseReplication,

  "Bytes sent in response to yb.master.MasterReplication.GetUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.GetUniverseReplication() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_GetUniverseReplication,

  "Microseconds spent handling yb.master.MasterReplication.GetUniverseReplication() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.GetUniverseReplication() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_IsSetupUniverseReplicationDone,

  "Bytes received by yb.master.MasterReplication.IsSetupUniverseReplicationDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.IsSetupUniverseReplicationDone() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_IsSetupUniverseReplicationDone,

  "Bytes sent in response to yb.master.MasterReplication.IsSetupUniverseReplicationDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.IsSetupUniverseReplicationDone() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_IsSetupUniverseReplicationDone,

  "Microseconds spent handling yb.master.MasterReplication.IsSetupUniverseReplicationDone() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.IsSetupUniverseReplicationDone() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterReplication_UpdateConsumerOnProducerSplit,

  "Bytes received by yb.master.MasterReplication.UpdateConsumerOnProducerSplit() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterReplication.UpdateConsumerOnProducerSplit() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterReplication_UpdateConsumerOnProducerSplit,

  "Bytes sent in response to yb.master.MasterReplication.UpdateConsumerOnProducerSplit() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterReplication.UpdateConsumerOnProducerSplit() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterReplication_UpdateConsumerOnProducerSplit,

  "Microseconds spent handling yb.master.MasterReplication.UpdateConsumerOnProducerSplit() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterReplication.UpdateConsumerOnProducerSplit() RPC requests",

  60000000LU, 2);

namespace yb {

namespace master {

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

  InitMethods(entity);

}

MasterReplicationIf::~MasterReplicationIf() {

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

  auto index = call->method_index();

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

}

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

  return "yb.master.MasterService";

}

std::string MasterReplicationIf::static_service_name() {

  return "yb.master.MasterService";

}

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

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kValidateReplicationInfo)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "ValidateReplicationInfo"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ValidateReplicationInfoRequestPB, ::yb::master::ValidateReplicationInfoResponsePB>>(

          std::move(call), [this](const ::yb::master::ValidateReplicationInfoRequestPB* req, ::yb::master::ValidateReplicationInfoResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_ValidateReplicationInfo.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_ValidateReplicationInfo.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_ValidateReplicationInfo.Instantiate(entity))

  };

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

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "CreateCDCStream"),

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

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

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

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_CreateCDCStream.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_CreateCDCStream.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_CreateCDCStream.Instantiate(entity))

  };

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

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "DeleteCDCStream"),

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

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

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

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_DeleteCDCStream.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_DeleteCDCStream.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_DeleteCDCStream.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kListCDCStreams)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "ListCDCStreams"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ListCDCStreamsRequestPB, ::yb::master::ListCDCStreamsResponsePB>>(

          std::move(call), [this](const ::yb::master::ListCDCStreamsRequestPB* req, ::yb::master::ListCDCStreamsResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_ListCDCStreams.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_ListCDCStreams.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_ListCDCStreams.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kGetCDCStream)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "GetCDCStream"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetCDCStreamRequestPB, ::yb::master::GetCDCStreamResponsePB>>(

          std::move(call), [this](const ::yb::master::GetCDCStreamRequestPB* req, ::yb::master::GetCDCStreamResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_GetCDCStream.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_GetCDCStream.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_GetCDCStream.Instantiate(entity))

  };

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

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "GetCDCDBStreamInfo"),

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

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

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

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_GetCDCDBStreamInfo.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_GetCDCDBStreamInfo.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_GetCDCDBStreamInfo.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kUpdateCDCStream)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "UpdateCDCStream"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::UpdateCDCStreamRequestPB, ::yb::master::UpdateCDCStreamResponsePB>>(

          std::move(call), [this](const ::yb::master::UpdateCDCStreamRequestPB* req, ::yb::master::UpdateCDCStreamResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_UpdateCDCStream.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_UpdateCDCStream.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_UpdateCDCStream.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kSetupUniverseReplication)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "SetupUniverseReplication"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::SetupUniverseReplicationRequestPB, ::yb::master::SetupUniverseReplicationResponsePB>>(

          std::move(call), [this](const ::yb::master::SetupUniverseReplicationRequestPB* req, ::yb::master::SetupUniverseReplicationResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_SetupUniverseReplication.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_SetupUniverseReplication.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_SetupUniverseReplication.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kDeleteUniverseReplication)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "DeleteUniverseReplication"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::DeleteUniverseReplicationRequestPB, ::yb::master::DeleteUniverseReplicationResponsePB>>(

          std::move(call), [this](const ::yb::master::DeleteUniverseReplicationRequestPB* req, ::yb::master::DeleteUniverseReplicationResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_DeleteUniverseReplication.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_DeleteUniverseReplication.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_DeleteUniverseReplication.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kAlterUniverseReplication)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "AlterUniverseReplication"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::AlterUniverseReplicationRequestPB, ::yb::master::AlterUniverseReplicationResponsePB>>(

          std::move(call), [this](const ::yb::master::AlterUniverseReplicationRequestPB* req, ::yb::master::AlterUniverseReplicationResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_AlterUniverseReplication.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_AlterUniverseReplication.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_AlterUniverseReplication.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kSetUniverseReplicationEnabled)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "SetUniverseReplicationEnabled"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::SetUniverseReplicationEnabledRequestPB, ::yb::master::SetUniverseReplicationEnabledResponsePB>>(

          std::move(call), [this](const ::yb::master::SetUniverseReplicationEnabledRequestPB* req, ::yb::master::SetUniverseReplicationEnabledResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_SetUniverseReplicationEnabled.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_SetUniverseReplicationEnabled.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_SetUniverseReplicationEnabled.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kGetUniverseReplication)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "GetUniverseReplication"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetUniverseReplicationRequestPB, ::yb::master::GetUniverseReplicationResponsePB>>(

          std::move(call), [this](const ::yb::master::GetUniverseReplicationRequestPB* req, ::yb::master::GetUniverseReplicationResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_GetUniverseReplication.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_GetUniverseReplication.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_GetUniverseReplication.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kIsSetupUniverseReplicationDone)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "IsSetupUniverseReplicationDone"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::IsSetupUniverseReplicationDoneRequestPB, ::yb::master::IsSetupUniverseReplicationDoneResponsePB>>(

          std::move(call), [this](const ::yb::master::IsSetupUniverseReplicationDoneRequestPB* req, ::yb::master::IsSetupUniverseReplicationDoneResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_IsSetupUniverseReplicationDone.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_IsSetupUniverseReplicationDone.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_IsSetupUniverseReplicationDone.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterReplicationRpcMethodIndexes::kUpdateConsumerOnProducerSplit)] = {

    .method = ::yb::rpc::RemoteMethod("yb.master.MasterService", "UpdateConsumerOnProducerSplit"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::UpdateConsumerOnProducerSplitRequestPB, ::yb::master::UpdateConsumerOnProducerSplitResponsePB>>(

          std::move(call), [this](const ::yb::master::UpdateConsumerOnProducerSplitRequestPB* req, ::yb::master::UpdateConsumerOnProducerSplitResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterReplication_UpdateConsumerOnProducerSplit.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterReplication_UpdateConsumerOnProducerSplit.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterReplication_UpdateConsumerOnProducerSplit.Instantiate(entity))

  };

}

} // namespace master

} // namespace yb