YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

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

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

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

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_UpdateConsensus,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_UpdateConsensus,

  "Microseconds spent handling yb.consensus.ConsensusService.UpdateConsensus() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.UpdateConsensus() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_MultiRaftUpdateConsensus,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_MultiRaftUpdateConsensus,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_MultiRaftUpdateConsensus,

  "Microseconds spent handling yb.consensus.ConsensusService.MultiRaftUpdateConsensus() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.MultiRaftUpdateConsensus() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_RequestConsensusVote,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_RequestConsensusVote,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_RequestConsensusVote,

  "Microseconds spent handling yb.consensus.ConsensusService.RequestConsensusVote() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.RequestConsensusVote() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_ChangeConfig,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_ChangeConfig,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_ChangeConfig,

  "Microseconds spent handling yb.consensus.ConsensusService.ChangeConfig() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.ChangeConfig() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_UnsafeChangeConfig,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_UnsafeChangeConfig,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_UnsafeChangeConfig,

  "Microseconds spent handling yb.consensus.ConsensusService.UnsafeChangeConfig() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.UnsafeChangeConfig() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_GetNodeInstance,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_GetNodeInstance,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_GetNodeInstance,

  "Microseconds spent handling yb.consensus.ConsensusService.GetNodeInstance() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.GetNodeInstance() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_RunLeaderElection,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_RunLeaderElection,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_RunLeaderElection,

  "Microseconds spent handling yb.consensus.ConsensusService.RunLeaderElection() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.RunLeaderElection() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_LeaderElectionLost,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_LeaderElectionLost,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_LeaderElectionLost,

  "Microseconds spent handling yb.consensus.ConsensusService.LeaderElectionLost() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.LeaderElectionLost() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_LeaderStepDown,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_LeaderStepDown,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_LeaderStepDown,

  "Microseconds spent handling yb.consensus.ConsensusService.LeaderStepDown() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.LeaderStepDown() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_GetLastOpId,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_GetLastOpId,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_GetLastOpId,

  "Microseconds spent handling yb.consensus.ConsensusService.GetLastOpId() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.GetLastOpId() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_GetConsensusState,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_GetConsensusState,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_GetConsensusState,

  "Microseconds spent handling yb.consensus.ConsensusService.GetConsensusState() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.GetConsensusState() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_consensus_ConsensusService_StartRemoteBootstrap,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_consensus_ConsensusService_StartRemoteBootstrap,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_consensus_ConsensusService_StartRemoteBootstrap,

  "Microseconds spent handling yb.consensus.ConsensusService.StartRemoteBootstrap() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.consensus.ConsensusService.StartRemoteBootstrap() RPC requests",

  60000000LU, 2);

namespace yb {

namespace consensus {

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

  InitMethods(entity);

}

ConsensusServiceIf::~ConsensusServiceIf() {

}

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

  auto index = call->method_index();

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

}

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

  return "yb.consensus.ConsensusService";

}

std::string ConsensusServiceIf::static_service_name() {

  return "yb.consensus.ConsensusService";

}

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

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kUpdateConsensus)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::ConsensusRequestPB, ::yb::consensus::ConsensusResponsePB>>(

          std::move(call), [this](const ::yb::consensus::ConsensusRequestPB* req, ::yb::consensus::ConsensusResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_UpdateConsensus.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_UpdateConsensus.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_UpdateConsensus.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kMultiRaftUpdateConsensus)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::MultiRaftConsensusRequestPB, ::yb::consensus::MultiRaftConsensusResponsePB>>(

          std::move(call), [this](const ::yb::consensus::MultiRaftConsensusRequestPB* req, ::yb::consensus::MultiRaftConsensusResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_MultiRaftUpdateConsensus.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_MultiRaftUpdateConsensus.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_MultiRaftUpdateConsensus.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kRequestConsensusVote)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::VoteRequestPB, ::yb::consensus::VoteResponsePB>>(

          std::move(call), [this](const ::yb::consensus::VoteRequestPB* req, ::yb::consensus::VoteResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_RequestConsensusVote.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_RequestConsensusVote.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_RequestConsensusVote.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kChangeConfig)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::ChangeConfigRequestPB, ::yb::consensus::ChangeConfigResponsePB>>(

          std::move(call), [this](const ::yb::consensus::ChangeConfigRequestPB* req, ::yb::consensus::ChangeConfigResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_ChangeConfig.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_ChangeConfig.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_ChangeConfig.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kUnsafeChangeConfig)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::UnsafeChangeConfigRequestPB, ::yb::consensus::UnsafeChangeConfigResponsePB>>(

          std::move(call), [this](const ::yb::consensus::UnsafeChangeConfigRequestPB* req, ::yb::consensus::UnsafeChangeConfigResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_UnsafeChangeConfig.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_UnsafeChangeConfig.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_UnsafeChangeConfig.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kGetNodeInstance)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::GetNodeInstanceRequestPB, ::yb::consensus::GetNodeInstanceResponsePB>>(

          std::move(call), [this](const ::yb::consensus::GetNodeInstanceRequestPB* req, ::yb::consensus::GetNodeInstanceResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_GetNodeInstance.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_GetNodeInstance.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_GetNodeInstance.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kRunLeaderElection)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::RunLeaderElectionRequestPB, ::yb::consensus::RunLeaderElectionResponsePB>>(

          std::move(call), [this](const ::yb::consensus::RunLeaderElectionRequestPB* req, ::yb::consensus::RunLeaderElectionResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_RunLeaderElection.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_RunLeaderElection.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_RunLeaderElection.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kLeaderElectionLost)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::LeaderElectionLostRequestPB, ::yb::consensus::LeaderElectionLostResponsePB>>(

          std::move(call), [this](const ::yb::consensus::LeaderElectionLostRequestPB* req, ::yb::consensus::LeaderElectionLostResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_LeaderElectionLost.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_LeaderElectionLost.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_LeaderElectionLost.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kLeaderStepDown)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::LeaderStepDownRequestPB, ::yb::consensus::LeaderStepDownResponsePB>>(

          std::move(call), [this](const ::yb::consensus::LeaderStepDownRequestPB* req, ::yb::consensus::LeaderStepDownResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_LeaderStepDown.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_LeaderStepDown.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_LeaderStepDown.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kGetLastOpId)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::GetLastOpIdRequestPB, ::yb::consensus::GetLastOpIdResponsePB>>(

          std::move(call), [this](const ::yb::consensus::GetLastOpIdRequestPB* req, ::yb::consensus::GetLastOpIdResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_GetLastOpId.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_GetLastOpId.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_GetLastOpId.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kGetConsensusState)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::GetConsensusStateRequestPB, ::yb::consensus::GetConsensusStateResponsePB>>(

          std::move(call), [this](const ::yb::consensus::GetConsensusStateRequestPB* req, ::yb::consensus::GetConsensusStateResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_GetConsensusState.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_GetConsensusState.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_GetConsensusState.Instantiate(entity))

  };

  methods_[static_cast<size_t>(ConsensusServiceRpcMethodIndexes::kStartRemoteBootstrap)] = {

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

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::consensus::StartRemoteBootstrapRequestPB, ::yb::consensus::StartRemoteBootstrapResponsePB>>(

          std::move(call), [this](const ::yb::consensus::StartRemoteBootstrapRequestPB* req, ::yb::consensus::StartRemoteBootstrapResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_consensus_ConsensusService_StartRemoteBootstrap.Instantiate(entity),

        METRIC_service_response_bytes_yb_consensus_ConsensusService_StartRemoteBootstrap.Instantiate(entity),

        METRIC_handler_latency_yb_consensus_ConsensusService_StartRemoteBootstrap.Instantiate(entity))

  };

}

} // namespace consensus

} // namespace yb