YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

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

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

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

#include "yb/rpc/proxy.h"

#include "yb/rpc/outbound_call.h"

#include "yb/util/metrics.h"

#include "yb/util/net/sockaddr.h"

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_ListTabletServers,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_ListTabletServers,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_ListLiveTabletServers,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_ListLiveTabletServers,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_ListMasters,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_ListMasters,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_ListMasterRaftPeers,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_ListMasterRaftPeers,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_GetMasterRegistration,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_GetMasterRegistration,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_IsMasterLeaderServiceReady,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_IsMasterLeaderServiceReady,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_DumpState,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_DumpState,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_ChangeLoadBalancerState,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_ChangeLoadBalancerState,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_GetLoadBalancerState,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_GetLoadBalancerState,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_RemovedMasterUpdate,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_RemovedMasterUpdate,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_SetPreferredZones,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_SetPreferredZones,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_GetMasterClusterConfig,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_GetMasterClusterConfig,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_ChangeMasterClusterConfig,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_ChangeMasterClusterConfig,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_GetLoadMoveCompletion,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_GetLoadMoveCompletion,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_GetLeaderBlacklistCompletion,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_GetLeaderBlacklistCompletion,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_IsLoadBalanced,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_IsLoadBalanced,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_IsLoadBalancerIdle,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_IsLoadBalancerIdle,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterCluster_AreLeadersOnPreferredOnly,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterCluster_AreLeadersOnPreferredOnly,

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

  yb::MetricUnit::kBytes,

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

namespace yb {

namespace master {

namespace {

const std::string kFullMasterClusterName = "yb.master.MasterCluster";

::yb::rpc::ProxyMetricsPtr CreateMasterClusterMetrics(const scoped_refptr<MetricEntity>& entity) {

  auto result = std::make_shared<::yb::rpc::ProxyMetricsImpl<18>>();

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kListTabletServers)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_ListTabletServers.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_ListTabletServers.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kListLiveTabletServers)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_ListLiveTabletServers.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_ListLiveTabletServers.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kListMasters)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_ListMasters.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_ListMasters.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kListMasterRaftPeers)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_ListMasterRaftPeers.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_ListMasterRaftPeers.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kGetMasterRegistration)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_GetMasterRegistration.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_GetMasterRegistration.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kIsMasterLeaderServiceReady)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_IsMasterLeaderServiceReady.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_IsMasterLeaderServiceReady.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kDumpState)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_DumpState.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_DumpState.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kChangeLoadBalancerState)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_ChangeLoadBalancerState.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_ChangeLoadBalancerState.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kGetLoadBalancerState)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_GetLoadBalancerState.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_GetLoadBalancerState.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kRemovedMasterUpdate)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_RemovedMasterUpdate.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_RemovedMasterUpdate.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kSetPreferredZones)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_SetPreferredZones.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_SetPreferredZones.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kGetMasterClusterConfig)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_GetMasterClusterConfig.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_GetMasterClusterConfig.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kChangeMasterClusterConfig)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_ChangeMasterClusterConfig.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_ChangeMasterClusterConfig.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kGetLoadMoveCompletion)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_GetLoadMoveCompletion.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_GetLoadMoveCompletion.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kGetLeaderBlacklistCompletion)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_GetLeaderBlacklistCompletion.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_GetLeaderBlacklistCompletion.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kIsLoadBalanced)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_IsLoadBalanced.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_IsLoadBalanced.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kIsLoadBalancerIdle)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_IsLoadBalancerIdle.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_IsLoadBalancerIdle.Instantiate(entity)

  };

  result->value[to_underlying(MasterClusterRpcMethodIndexes::kAreLeadersOnPreferredOnly)] = {

      METRIC_proxy_request_bytes_yb_master_MasterCluster_AreLeadersOnPreferredOnly.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterCluster_AreLeadersOnPreferredOnly.Instantiate(entity)

  };

  return result;

}

} // namespace

MasterClusterProxy::MasterClusterProxy(

    ::yb::rpc::ProxyCache* cache, const ::yb::HostPort& remote,

    const ::yb::rpc::Protocol* protocol,

    const ::yb::MonoDelta& resolve_cache_timeout)

    : ProxyBase(kFullMasterClusterName, &CreateMasterClusterMetrics,

                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status MasterClusterProxy::ListTabletServers(

    const ::yb::master::ListTabletServersRequestPB &req, ::yb::master::ListTabletServersResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kListTabletServers)), req, resp, controller);

}

void MasterClusterProxy::ListTabletServersAsync(

    const ::yb::master::ListTabletServersRequestPB &req, ::yb::master::ListTabletServersResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kListTabletServers)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::ListLiveTabletServers(

    const ::yb::master::ListLiveTabletServersRequestPB &req, ::yb::master::ListLiveTabletServersResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kListLiveTabletServers)), req, resp, controller);

}

void MasterClusterProxy::ListLiveTabletServersAsync(

    const ::yb::master::ListLiveTabletServersRequestPB &req, ::yb::master::ListLiveTabletServersResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kListLiveTabletServers)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::ListMasters(

    const ::yb::master::ListMastersRequestPB &req, ::yb::master::ListMastersResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kListMasters)), req, resp, controller);

}

void MasterClusterProxy::ListMastersAsync(

    const ::yb::master::ListMastersRequestPB &req, ::yb::master::ListMastersResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kListMasters)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::ListMasterRaftPeers(

    const ::yb::master::ListMasterRaftPeersRequestPB &req, ::yb::master::ListMasterRaftPeersResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kListMasterRaftPeers)), req, resp, controller);

}

void MasterClusterProxy::ListMasterRaftPeersAsync(

    const ::yb::master::ListMasterRaftPeersRequestPB &req, ::yb::master::ListMasterRaftPeersResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kListMasterRaftPeers)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::GetMasterRegistration(

    const ::yb::master::GetMasterRegistrationRequestPB &req, ::yb::master::GetMasterRegistrationResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetMasterRegistration)), req, resp, controller);

}

void MasterClusterProxy::GetMasterRegistrationAsync(

    const ::yb::master::GetMasterRegistrationRequestPB &req, ::yb::master::GetMasterRegistrationResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetMasterRegistration)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::IsMasterLeaderServiceReady(

    const ::yb::master::IsMasterLeaderReadyRequestPB &req, ::yb::master::IsMasterLeaderReadyResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kIsMasterLeaderServiceReady)), req, resp, controller);

}

void MasterClusterProxy::IsMasterLeaderServiceReadyAsync(

    const ::yb::master::IsMasterLeaderReadyRequestPB &req, ::yb::master::IsMasterLeaderReadyResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kIsMasterLeaderServiceReady)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::DumpState(

    const ::yb::master::DumpMasterStateRequestPB &req, ::yb::master::DumpMasterStateResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kDumpState)), req, resp, controller);

}

void MasterClusterProxy::DumpStateAsync(

    const ::yb::master::DumpMasterStateRequestPB &req, ::yb::master::DumpMasterStateResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kDumpState)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::ChangeLoadBalancerState(

    const ::yb::master::ChangeLoadBalancerStateRequestPB &req, ::yb::master::ChangeLoadBalancerStateResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kChangeLoadBalancerState)), req, resp, controller);

}

void MasterClusterProxy::ChangeLoadBalancerStateAsync(

    const ::yb::master::ChangeLoadBalancerStateRequestPB &req, ::yb::master::ChangeLoadBalancerStateResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kChangeLoadBalancerState)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::GetLoadBalancerState(

    const ::yb::master::GetLoadBalancerStateRequestPB &req, ::yb::master::GetLoadBalancerStateResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetLoadBalancerState)), req, resp, controller);

}

void MasterClusterProxy::GetLoadBalancerStateAsync(

    const ::yb::master::GetLoadBalancerStateRequestPB &req, ::yb::master::GetLoadBalancerStateResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetLoadBalancerState)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::RemovedMasterUpdate(

    const ::yb::master::RemovedMasterUpdateRequestPB &req, ::yb::master::RemovedMasterUpdateResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kRemovedMasterUpdate)), req, resp, controller);

}

void MasterClusterProxy::RemovedMasterUpdateAsync(

    const ::yb::master::RemovedMasterUpdateRequestPB &req, ::yb::master::RemovedMasterUpdateResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kRemovedMasterUpdate)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::SetPreferredZones(

    const ::yb::master::SetPreferredZonesRequestPB &req, ::yb::master::SetPreferredZonesResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kSetPreferredZones)), req, resp, controller);

}

void MasterClusterProxy::SetPreferredZonesAsync(

    const ::yb::master::SetPreferredZonesRequestPB &req, ::yb::master::SetPreferredZonesResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kSetPreferredZones)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::GetMasterClusterConfig(

    const ::yb::master::GetMasterClusterConfigRequestPB &req, ::yb::master::GetMasterClusterConfigResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetMasterClusterConfig)), req, resp, controller);

}

void MasterClusterProxy::GetMasterClusterConfigAsync(

    const ::yb::master::GetMasterClusterConfigRequestPB &req, ::yb::master::GetMasterClusterConfigResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetMasterClusterConfig)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::ChangeMasterClusterConfig(

    const ::yb::master::ChangeMasterClusterConfigRequestPB &req, ::yb::master::ChangeMasterClusterConfigResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kChangeMasterClusterConfig)), req, resp, controller);

}

void MasterClusterProxy::ChangeMasterClusterConfigAsync(

    const ::yb::master::ChangeMasterClusterConfigRequestPB &req, ::yb::master::ChangeMasterClusterConfigResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kChangeMasterClusterConfig)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::GetLoadMoveCompletion(

    const ::yb::master::GetLoadMovePercentRequestPB &req, ::yb::master::GetLoadMovePercentResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetLoadMoveCompletion)), req, resp, controller);

}

void MasterClusterProxy::GetLoadMoveCompletionAsync(

    const ::yb::master::GetLoadMovePercentRequestPB &req, ::yb::master::GetLoadMovePercentResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetLoadMoveCompletion)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::GetLeaderBlacklistCompletion(

    const ::yb::master::GetLeaderBlacklistPercentRequestPB &req, ::yb::master::GetLoadMovePercentResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetLeaderBlacklistCompletion)), req, resp, controller);

}

void MasterClusterProxy::GetLeaderBlacklistCompletionAsync(

    const ::yb::master::GetLeaderBlacklistPercentRequestPB &req, ::yb::master::GetLoadMovePercentResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kGetLeaderBlacklistCompletion)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::IsLoadBalanced(

    const ::yb::master::IsLoadBalancedRequestPB &req, ::yb::master::IsLoadBalancedResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kIsLoadBalanced)), req, resp, controller);

}

void MasterClusterProxy::IsLoadBalancedAsync(

    const ::yb::master::IsLoadBalancedRequestPB &req, ::yb::master::IsLoadBalancedResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kIsLoadBalanced)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::IsLoadBalancerIdle(

    const ::yb::master::IsLoadBalancerIdleRequestPB &req, ::yb::master::IsLoadBalancerIdleResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kIsLoadBalancerIdle)), req, resp, controller);

}

void MasterClusterProxy::IsLoadBalancerIdleAsync(

    const ::yb::master::IsLoadBalancerIdleRequestPB &req, ::yb::master::IsLoadBalancerIdleResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kIsLoadBalancerIdle)), req, resp, controller, std::move(callback));

}

::yb::Status MasterClusterProxy::AreLeadersOnPreferredOnly(

    const ::yb::master::AreLeadersOnPreferredOnlyRequestPB &req, ::yb::master::AreLeadersOnPreferredOnlyResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kAreLeadersOnPreferredOnly)), req, resp, controller);

}

void MasterClusterProxy::AreLeadersOnPreferredOnlyAsync(

    const ::yb::master::AreLeadersOnPreferredOnlyRequestPB &req, ::yb::master::AreLeadersOnPreferredOnlyResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

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

  proxy().AsyncRequest(

      &method, metrics<18>(static_cast<size_t>(MasterClusterRpcMethodIndexes::kAreLeadersOnPreferredOnly)), req, resp, controller, std::move(callback));

}

} // namespace master

} // namespace yb