YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

// THIS FILE IS AUTOGENERATED FROM yb/consensus/consensus.proto

#include "yb/consensus/consensus.proxy.h"

#include "yb/consensus/consensus.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_consensus_ConsensusService_UpdateConsensus,

  "Bytes sent by yb.consensus.ConsensusService.UpdateConsensus() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.UpdateConsensus() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_UpdateConsensus,

  "Bytes received in response to yb.consensus.ConsensusService.UpdateConsensus() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.UpdateConsensus() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_MultiRaftUpdateConsensus,

  "Bytes sent by yb.consensus.ConsensusService.MultiRaftUpdateConsensus() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.MultiRaftUpdateConsensus() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_MultiRaftUpdateConsensus,

  "Bytes received in response to yb.consensus.ConsensusService.MultiRaftUpdateConsensus() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.MultiRaftUpdateConsensus() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_RequestConsensusVote,

  "Bytes sent by yb.consensus.ConsensusService.RequestConsensusVote() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.RequestConsensusVote() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_RequestConsensusVote,

  "Bytes received in response to yb.consensus.ConsensusService.RequestConsensusVote() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.RequestConsensusVote() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_ChangeConfig,

  "Bytes sent by yb.consensus.ConsensusService.ChangeConfig() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.ChangeConfig() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_ChangeConfig,

  "Bytes received in response to yb.consensus.ConsensusService.ChangeConfig() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.ChangeConfig() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_UnsafeChangeConfig,

  "Bytes sent by yb.consensus.ConsensusService.UnsafeChangeConfig() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.UnsafeChangeConfig() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_UnsafeChangeConfig,

  "Bytes received in response to yb.consensus.ConsensusService.UnsafeChangeConfig() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.UnsafeChangeConfig() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_GetNodeInstance,

  "Bytes sent by yb.consensus.ConsensusService.GetNodeInstance() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.GetNodeInstance() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_GetNodeInstance,

  "Bytes received in response to yb.consensus.ConsensusService.GetNodeInstance() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.GetNodeInstance() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_RunLeaderElection,

  "Bytes sent by yb.consensus.ConsensusService.RunLeaderElection() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.RunLeaderElection() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_RunLeaderElection,

  "Bytes received in response to yb.consensus.ConsensusService.RunLeaderElection() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.RunLeaderElection() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_LeaderElectionLost,

  "Bytes sent by yb.consensus.ConsensusService.LeaderElectionLost() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.LeaderElectionLost() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_LeaderElectionLost,

  "Bytes received in response to yb.consensus.ConsensusService.LeaderElectionLost() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.LeaderElectionLost() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_LeaderStepDown,

  "Bytes sent by yb.consensus.ConsensusService.LeaderStepDown() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.LeaderStepDown() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_LeaderStepDown,

  "Bytes received in response to yb.consensus.ConsensusService.LeaderStepDown() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.LeaderStepDown() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_GetLastOpId,

  "Bytes sent by yb.consensus.ConsensusService.GetLastOpId() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.GetLastOpId() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_GetLastOpId,

  "Bytes received in response to yb.consensus.ConsensusService.GetLastOpId() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.GetLastOpId() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_GetConsensusState,

  "Bytes sent by yb.consensus.ConsensusService.GetConsensusState() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.GetConsensusState() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_GetConsensusState,

  "Bytes received in response to yb.consensus.ConsensusService.GetConsensusState() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.GetConsensusState() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_consensus_ConsensusService_StartRemoteBootstrap,

  "Bytes sent by yb.consensus.ConsensusService.StartRemoteBootstrap() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.consensus.ConsensusService.StartRemoteBootstrap() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_consensus_ConsensusService_StartRemoteBootstrap,

  "Bytes received in response to yb.consensus.ConsensusService.StartRemoteBootstrap() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.consensus.ConsensusService.StartRemoteBootstrap() RPC requests");

namespace yb {

namespace consensus {

namespace {

const std::string kFullConsensusServiceName = "yb.consensus.ConsensusService";

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

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

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kUpdateConsensus)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_UpdateConsensus.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_UpdateConsensus.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kMultiRaftUpdateConsensus)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_MultiRaftUpdateConsensus.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_MultiRaftUpdateConsensus.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kRequestConsensusVote)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_RequestConsensusVote.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_RequestConsensusVote.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kChangeConfig)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_ChangeConfig.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_ChangeConfig.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kUnsafeChangeConfig)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_UnsafeChangeConfig.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_UnsafeChangeConfig.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kGetNodeInstance)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_GetNodeInstance.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_GetNodeInstance.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kRunLeaderElection)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_RunLeaderElection.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_RunLeaderElection.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kLeaderElectionLost)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_LeaderElectionLost.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_LeaderElectionLost.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kLeaderStepDown)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_LeaderStepDown.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_LeaderStepDown.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kGetLastOpId)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_GetLastOpId.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_GetLastOpId.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kGetConsensusState)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_GetConsensusState.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_GetConsensusState.Instantiate(entity)

  };

  result->value[to_underlying(ConsensusServiceRpcMethodIndexes::kStartRemoteBootstrap)] = {

      METRIC_proxy_request_bytes_yb_consensus_ConsensusService_StartRemoteBootstrap.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_consensus_ConsensusService_StartRemoteBootstrap.Instantiate(entity)

  };

  return result;

}

} // namespace

ConsensusServiceProxy::ConsensusServiceProxy(

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

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

    const ::yb::MonoDelta& resolve_cache_timeout)

    : ProxyBase(kFullConsensusServiceName, &CreateConsensusServiceMetrics,

                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status ConsensusServiceProxy::UpdateConsensus(

    const ::yb::consensus::ConsensusRequestPB &req, ::yb::consensus::ConsensusResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "UpdateConsensus");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kUpdateConsensus)), req, resp, controller);

}

void ConsensusServiceProxy::UpdateConsensusAsync(

    const ::yb::consensus::ConsensusRequestPB &req, ::yb::consensus::ConsensusResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "UpdateConsensus");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kUpdateConsensus)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::MultiRaftUpdateConsensus(

    const ::yb::consensus::MultiRaftConsensusRequestPB &req, ::yb::consensus::MultiRaftConsensusResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "MultiRaftUpdateConsensus");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kMultiRaftUpdateConsensus)), req, resp, controller);

}

void ConsensusServiceProxy::MultiRaftUpdateConsensusAsync(

    const ::yb::consensus::MultiRaftConsensusRequestPB &req, ::yb::consensus::MultiRaftConsensusResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "MultiRaftUpdateConsensus");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kMultiRaftUpdateConsensus)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::RequestConsensusVote(

    const ::yb::consensus::VoteRequestPB &req, ::yb::consensus::VoteResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "RequestConsensusVote");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kRequestConsensusVote)), req, resp, controller);

}

void ConsensusServiceProxy::RequestConsensusVoteAsync(

    const ::yb::consensus::VoteRequestPB &req, ::yb::consensus::VoteResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "RequestConsensusVote");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kRequestConsensusVote)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::ChangeConfig(

    const ::yb::consensus::ChangeConfigRequestPB &req, ::yb::consensus::ChangeConfigResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "ChangeConfig");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kChangeConfig)), req, resp, controller);

}

void ConsensusServiceProxy::ChangeConfigAsync(

    const ::yb::consensus::ChangeConfigRequestPB &req, ::yb::consensus::ChangeConfigResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "ChangeConfig");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kChangeConfig)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::UnsafeChangeConfig(

    const ::yb::consensus::UnsafeChangeConfigRequestPB &req, ::yb::consensus::UnsafeChangeConfigResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "UnsafeChangeConfig");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kUnsafeChangeConfig)), req, resp, controller);

}

void ConsensusServiceProxy::UnsafeChangeConfigAsync(

    const ::yb::consensus::UnsafeChangeConfigRequestPB &req, ::yb::consensus::UnsafeChangeConfigResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "UnsafeChangeConfig");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kUnsafeChangeConfig)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::GetNodeInstance(

    const ::yb::consensus::GetNodeInstanceRequestPB &req, ::yb::consensus::GetNodeInstanceResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "GetNodeInstance");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kGetNodeInstance)), req, resp, controller);

}

void ConsensusServiceProxy::GetNodeInstanceAsync(

    const ::yb::consensus::GetNodeInstanceRequestPB &req, ::yb::consensus::GetNodeInstanceResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "GetNodeInstance");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kGetNodeInstance)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::RunLeaderElection(

    const ::yb::consensus::RunLeaderElectionRequestPB &req, ::yb::consensus::RunLeaderElectionResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "RunLeaderElection");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kRunLeaderElection)), req, resp, controller);

}

void ConsensusServiceProxy::RunLeaderElectionAsync(

    const ::yb::consensus::RunLeaderElectionRequestPB &req, ::yb::consensus::RunLeaderElectionResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "RunLeaderElection");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kRunLeaderElection)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::LeaderElectionLost(

    const ::yb::consensus::LeaderElectionLostRequestPB &req, ::yb::consensus::LeaderElectionLostResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "LeaderElectionLost");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kLeaderElectionLost)), req, resp, controller);

}

void ConsensusServiceProxy::LeaderElectionLostAsync(

    const ::yb::consensus::LeaderElectionLostRequestPB &req, ::yb::consensus::LeaderElectionLostResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "LeaderElectionLost");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kLeaderElectionLost)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::LeaderStepDown(

    const ::yb::consensus::LeaderStepDownRequestPB &req, ::yb::consensus::LeaderStepDownResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "LeaderStepDown");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kLeaderStepDown)), req, resp, controller);

}

void ConsensusServiceProxy::LeaderStepDownAsync(

    const ::yb::consensus::LeaderStepDownRequestPB &req, ::yb::consensus::LeaderStepDownResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "LeaderStepDown");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kLeaderStepDown)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::GetLastOpId(

    const ::yb::consensus::GetLastOpIdRequestPB &req, ::yb::consensus::GetLastOpIdResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "GetLastOpId");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kGetLastOpId)), req, resp, controller);

}

void ConsensusServiceProxy::GetLastOpIdAsync(

    const ::yb::consensus::GetLastOpIdRequestPB &req, ::yb::consensus::GetLastOpIdResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "GetLastOpId");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kGetLastOpId)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::GetConsensusState(

    const ::yb::consensus::GetConsensusStateRequestPB &req, ::yb::consensus::GetConsensusStateResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "GetConsensusState");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kGetConsensusState)), req, resp, controller);

}

void ConsensusServiceProxy::GetConsensusStateAsync(

    const ::yb::consensus::GetConsensusStateRequestPB &req, ::yb::consensus::GetConsensusStateResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "GetConsensusState");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kGetConsensusState)), req, resp, controller, std::move(callback));

}

::yb::Status ConsensusServiceProxy::StartRemoteBootstrap(

    const ::yb::consensus::StartRemoteBootstrapRequestPB &req, ::yb::consensus::StartRemoteBootstrapResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "StartRemoteBootstrap");

  return proxy().SyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kStartRemoteBootstrap)), req, resp, controller);

}

void ConsensusServiceProxy::StartRemoteBootstrapAsync(

    const ::yb::consensus::StartRemoteBootstrapRequestPB &req, ::yb::consensus::StartRemoteBootstrapResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.consensus.ConsensusService", "StartRemoteBootstrap");

  proxy().AsyncRequest(

      &method, metrics<12>(static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kStartRemoteBootstrap)), req, resp, controller, std::move(callback));

}

} // namespace consensus

} // namespace yb