YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

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

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

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

  "Bytes received by yb.master.MasterCluster.ListTabletServers() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.ListTabletServers() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_ListTabletServers,

  "Bytes sent in response to yb.master.MasterCluster.ListTabletServers() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.ListTabletServers() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_ListTabletServers,

  "Microseconds spent handling yb.master.MasterCluster.ListTabletServers() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.ListTabletServers() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_ListLiveTabletServers,

  "Bytes received by yb.master.MasterCluster.ListLiveTabletServers() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.ListLiveTabletServers() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_ListLiveTabletServers,

  "Bytes sent in response to yb.master.MasterCluster.ListLiveTabletServers() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.ListLiveTabletServers() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_ListLiveTabletServers,

  "Microseconds spent handling yb.master.MasterCluster.ListLiveTabletServers() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.ListLiveTabletServers() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_ListMasters,

  "Bytes received by yb.master.MasterCluster.ListMasters() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.ListMasters() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_ListMasters,

  "Bytes sent in response to yb.master.MasterCluster.ListMasters() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.ListMasters() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_ListMasters,

  "Microseconds spent handling yb.master.MasterCluster.ListMasters() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.ListMasters() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_ListMasterRaftPeers,

  "Bytes received by yb.master.MasterCluster.ListMasterRaftPeers() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.ListMasterRaftPeers() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_ListMasterRaftPeers,

  "Bytes sent in response to yb.master.MasterCluster.ListMasterRaftPeers() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.ListMasterRaftPeers() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_ListMasterRaftPeers,

  "Microseconds spent handling yb.master.MasterCluster.ListMasterRaftPeers() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.ListMasterRaftPeers() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_GetMasterRegistration,

  "Bytes received by yb.master.MasterCluster.GetMasterRegistration() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.GetMasterRegistration() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_GetMasterRegistration,

  "Bytes sent in response to yb.master.MasterCluster.GetMasterRegistration() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.GetMasterRegistration() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_GetMasterRegistration,

  "Microseconds spent handling yb.master.MasterCluster.GetMasterRegistration() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.GetMasterRegistration() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_IsMasterLeaderServiceReady,

  "Bytes received by yb.master.MasterCluster.IsMasterLeaderServiceReady() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.IsMasterLeaderServiceReady() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_IsMasterLeaderServiceReady,

  "Bytes sent in response to yb.master.MasterCluster.IsMasterLeaderServiceReady() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.IsMasterLeaderServiceReady() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_IsMasterLeaderServiceReady,

  "Microseconds spent handling yb.master.MasterCluster.IsMasterLeaderServiceReady() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.IsMasterLeaderServiceReady() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_DumpState,

  "Bytes received by yb.master.MasterCluster.DumpState() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.DumpState() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_DumpState,

  "Bytes sent in response to yb.master.MasterCluster.DumpState() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.DumpState() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_DumpState,

  "Microseconds spent handling yb.master.MasterCluster.DumpState() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.DumpState() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_ChangeLoadBalancerState,

  "Bytes received by yb.master.MasterCluster.ChangeLoadBalancerState() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.ChangeLoadBalancerState() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_ChangeLoadBalancerState,

  "Bytes sent in response to yb.master.MasterCluster.ChangeLoadBalancerState() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.ChangeLoadBalancerState() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_ChangeLoadBalancerState,

  "Microseconds spent handling yb.master.MasterCluster.ChangeLoadBalancerState() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.ChangeLoadBalancerState() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_GetLoadBalancerState,

  "Bytes received by yb.master.MasterCluster.GetLoadBalancerState() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.GetLoadBalancerState() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_GetLoadBalancerState,

  "Bytes sent in response to yb.master.MasterCluster.GetLoadBalancerState() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.GetLoadBalancerState() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_GetLoadBalancerState,

  "Microseconds spent handling yb.master.MasterCluster.GetLoadBalancerState() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.GetLoadBalancerState() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_RemovedMasterUpdate,

  "Bytes received by yb.master.MasterCluster.RemovedMasterUpdate() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.RemovedMasterUpdate() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_RemovedMasterUpdate,

  "Bytes sent in response to yb.master.MasterCluster.RemovedMasterUpdate() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.RemovedMasterUpdate() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_RemovedMasterUpdate,

  "Microseconds spent handling yb.master.MasterCluster.RemovedMasterUpdate() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.RemovedMasterUpdate() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_SetPreferredZones,

  "Bytes received by yb.master.MasterCluster.SetPreferredZones() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.SetPreferredZones() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_SetPreferredZones,

  "Bytes sent in response to yb.master.MasterCluster.SetPreferredZones() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.SetPreferredZones() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_SetPreferredZones,

  "Microseconds spent handling yb.master.MasterCluster.SetPreferredZones() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.SetPreferredZones() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_GetMasterClusterConfig,

  "Bytes received by yb.master.MasterCluster.GetMasterClusterConfig() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.GetMasterClusterConfig() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_GetMasterClusterConfig,

  "Bytes sent in response to yb.master.MasterCluster.GetMasterClusterConfig() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.GetMasterClusterConfig() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_GetMasterClusterConfig,

  "Microseconds spent handling yb.master.MasterCluster.GetMasterClusterConfig() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.GetMasterClusterConfig() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_ChangeMasterClusterConfig,

  "Bytes received by yb.master.MasterCluster.ChangeMasterClusterConfig() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.ChangeMasterClusterConfig() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_ChangeMasterClusterConfig,

  "Bytes sent in response to yb.master.MasterCluster.ChangeMasterClusterConfig() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.ChangeMasterClusterConfig() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_ChangeMasterClusterConfig,

  "Microseconds spent handling yb.master.MasterCluster.ChangeMasterClusterConfig() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.ChangeMasterClusterConfig() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_GetLoadMoveCompletion,

  "Bytes received by yb.master.MasterCluster.GetLoadMoveCompletion() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.GetLoadMoveCompletion() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_GetLoadMoveCompletion,

  "Bytes sent in response to yb.master.MasterCluster.GetLoadMoveCompletion() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.GetLoadMoveCompletion() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_GetLoadMoveCompletion,

  "Microseconds spent handling yb.master.MasterCluster.GetLoadMoveCompletion() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.GetLoadMoveCompletion() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_GetLeaderBlacklistCompletion,

  "Bytes received by yb.master.MasterCluster.GetLeaderBlacklistCompletion() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.GetLeaderBlacklistCompletion() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_GetLeaderBlacklistCompletion,

  "Bytes sent in response to yb.master.MasterCluster.GetLeaderBlacklistCompletion() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.GetLeaderBlacklistCompletion() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_GetLeaderBlacklistCompletion,

  "Microseconds spent handling yb.master.MasterCluster.GetLeaderBlacklistCompletion() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.GetLeaderBlacklistCompletion() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_IsLoadBalanced,

  "Bytes received by yb.master.MasterCluster.IsLoadBalanced() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.IsLoadBalanced() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_IsLoadBalanced,

  "Bytes sent in response to yb.master.MasterCluster.IsLoadBalanced() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.IsLoadBalanced() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_IsLoadBalanced,

  "Microseconds spent handling yb.master.MasterCluster.IsLoadBalanced() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.IsLoadBalanced() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_IsLoadBalancerIdle,

  "Bytes received by yb.master.MasterCluster.IsLoadBalancerIdle() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.IsLoadBalancerIdle() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_IsLoadBalancerIdle,

  "Bytes sent in response to yb.master.MasterCluster.IsLoadBalancerIdle() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.IsLoadBalancerIdle() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_IsLoadBalancerIdle,

  "Microseconds spent handling yb.master.MasterCluster.IsLoadBalancerIdle() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.IsLoadBalancerIdle() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_master_MasterCluster_AreLeadersOnPreferredOnly,

  "Bytes received by yb.master.MasterCluster.AreLeadersOnPreferredOnly() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.master.MasterCluster.AreLeadersOnPreferredOnly() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_master_MasterCluster_AreLeadersOnPreferredOnly,

  "Bytes sent in response to yb.master.MasterCluster.AreLeadersOnPreferredOnly() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.master.MasterCluster.AreLeadersOnPreferredOnly() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_master_MasterCluster_AreLeadersOnPreferredOnly,

  "Microseconds spent handling yb.master.MasterCluster.AreLeadersOnPreferredOnly() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.master.MasterCluster.AreLeadersOnPreferredOnly() RPC requests",

  60000000LU, 2);

namespace yb {

namespace master {

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

  InitMethods(entity);

}

MasterClusterIf::~MasterClusterIf() {

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

  auto index = call->method_index();

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

}

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

  return "yb.master.MasterService";

}

std::string MasterClusterIf::static_service_name() {

  return "yb.master.MasterService";

}

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

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kListTabletServers)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ListTabletServersRequestPB, ::yb::master::ListTabletServersResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_ListTabletServers.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_ListTabletServers.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_ListTabletServers.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kListLiveTabletServers)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ListLiveTabletServersRequestPB, ::yb::master::ListLiveTabletServersResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_ListLiveTabletServers.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_ListLiveTabletServers.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_ListLiveTabletServers.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kListMasters)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ListMastersRequestPB, ::yb::master::ListMastersResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_ListMasters.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_ListMasters.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_ListMasters.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kListMasterRaftPeers)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ListMasterRaftPeersRequestPB, ::yb::master::ListMasterRaftPeersResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_ListMasterRaftPeers.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_ListMasterRaftPeers.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_ListMasterRaftPeers.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetMasterRegistration)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetMasterRegistrationRequestPB, ::yb::master::GetMasterRegistrationResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_GetMasterRegistration.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_GetMasterRegistration.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_GetMasterRegistration.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kIsMasterLeaderServiceReady)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::IsMasterLeaderReadyRequestPB, ::yb::master::IsMasterLeaderReadyResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_IsMasterLeaderServiceReady.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_IsMasterLeaderServiceReady.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_IsMasterLeaderServiceReady.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kDumpState)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::DumpMasterStateRequestPB, ::yb::master::DumpMasterStateResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_DumpState.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_DumpState.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_DumpState.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kChangeLoadBalancerState)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ChangeLoadBalancerStateRequestPB, ::yb::master::ChangeLoadBalancerStateResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_ChangeLoadBalancerState.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_ChangeLoadBalancerState.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_ChangeLoadBalancerState.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetLoadBalancerState)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetLoadBalancerStateRequestPB, ::yb::master::GetLoadBalancerStateResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_GetLoadBalancerState.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_GetLoadBalancerState.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_GetLoadBalancerState.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kRemovedMasterUpdate)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::RemovedMasterUpdateRequestPB, ::yb::master::RemovedMasterUpdateResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_RemovedMasterUpdate.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_RemovedMasterUpdate.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_RemovedMasterUpdate.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kSetPreferredZones)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::SetPreferredZonesRequestPB, ::yb::master::SetPreferredZonesResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_SetPreferredZones.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_SetPreferredZones.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_SetPreferredZones.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetMasterClusterConfig)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetMasterClusterConfigRequestPB, ::yb::master::GetMasterClusterConfigResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_GetMasterClusterConfig.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_GetMasterClusterConfig.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_GetMasterClusterConfig.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kChangeMasterClusterConfig)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::ChangeMasterClusterConfigRequestPB, ::yb::master::ChangeMasterClusterConfigResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_ChangeMasterClusterConfig.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_ChangeMasterClusterConfig.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_ChangeMasterClusterConfig.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetLoadMoveCompletion)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetLoadMovePercentRequestPB, ::yb::master::GetLoadMovePercentResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_GetLoadMoveCompletion.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_GetLoadMoveCompletion.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_GetLoadMoveCompletion.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetLeaderBlacklistCompletion)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::GetLeaderBlacklistPercentRequestPB, ::yb::master::GetLoadMovePercentResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_GetLeaderBlacklistCompletion.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_GetLeaderBlacklistCompletion.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_GetLeaderBlacklistCompletion.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kIsLoadBalanced)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::IsLoadBalancedRequestPB, ::yb::master::IsLoadBalancedResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_IsLoadBalanced.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_IsLoadBalanced.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_IsLoadBalanced.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kIsLoadBalancerIdle)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::IsLoadBalancerIdleRequestPB, ::yb::master::IsLoadBalancerIdleResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_IsLoadBalancerIdle.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_IsLoadBalancerIdle.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_IsLoadBalancerIdle.Instantiate(entity))

  };

  methods_[static_cast<size_t>(MasterClusterRpcMethodIndexes::kAreLeadersOnPreferredOnly)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::master::AreLeadersOnPreferredOnlyRequestPB, ::yb::master::AreLeadersOnPreferredOnlyResponsePB>>(

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

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

      });

    },

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

        METRIC_service_request_bytes_yb_master_MasterCluster_AreLeadersOnPreferredOnly.Instantiate(entity),

        METRIC_service_response_bytes_yb_master_MasterCluster_AreLeadersOnPreferredOnly.Instantiate(entity),

        METRIC_handler_latency_yb_master_MasterCluster_AreLeadersOnPreferredOnly.Instantiate(entity))

  };

}

} // namespace master

} // namespace yb