YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// THIS FILE IS AUTOGENERATED FROM yb/tserver/tserver_service.proto

#include "yb/tserver/tserver_service.pb.h"

#include "yb/tserver/tserver_service.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_tserver_TabletServerService_Write,

  "Bytes received by yb.tserver.TabletServerService.Write() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.Write() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_Write,

  "Bytes sent in response to yb.tserver.TabletServerService.Write() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.Write() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_Write,

  "Microseconds spent handling yb.tserver.TabletServerService.Write() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.Write() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_Read,

  "Bytes received by yb.tserver.TabletServerService.Read() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.Read() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_Read,

  "Bytes sent in response to yb.tserver.TabletServerService.Read() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.Read() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_Read,

  "Microseconds spent handling yb.tserver.TabletServerService.Read() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.Read() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_VerifyTableRowRange,

  "Bytes received by yb.tserver.TabletServerService.VerifyTableRowRange() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.VerifyTableRowRange() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_VerifyTableRowRange,

  "Bytes sent in response to yb.tserver.TabletServerService.VerifyTableRowRange() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.VerifyTableRowRange() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_VerifyTableRowRange,

  "Microseconds spent handling yb.tserver.TabletServerService.VerifyTableRowRange() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.VerifyTableRowRange() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_NoOp,

  "Bytes received by yb.tserver.TabletServerService.NoOp() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.NoOp() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_NoOp,

  "Bytes sent in response to yb.tserver.TabletServerService.NoOp() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.NoOp() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_NoOp,

  "Microseconds spent handling yb.tserver.TabletServerService.NoOp() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.NoOp() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_ListTablets,

  "Bytes received by yb.tserver.TabletServerService.ListTablets() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.ListTablets() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_ListTablets,

  "Bytes sent in response to yb.tserver.TabletServerService.ListTablets() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.ListTablets() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_ListTablets,

  "Microseconds spent handling yb.tserver.TabletServerService.ListTablets() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.ListTablets() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_GetLogLocation,

  "Bytes received by yb.tserver.TabletServerService.GetLogLocation() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.GetLogLocation() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_GetLogLocation,

  "Bytes sent in response to yb.tserver.TabletServerService.GetLogLocation() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.GetLogLocation() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_GetLogLocation,

  "Microseconds spent handling yb.tserver.TabletServerService.GetLogLocation() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.GetLogLocation() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_Checksum,

  "Bytes received by yb.tserver.TabletServerService.Checksum() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.Checksum() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_Checksum,

  "Bytes sent in response to yb.tserver.TabletServerService.Checksum() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.Checksum() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_Checksum,

  "Microseconds spent handling yb.tserver.TabletServerService.Checksum() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.Checksum() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_ListTabletsForTabletServer,

  "Bytes received by yb.tserver.TabletServerService.ListTabletsForTabletServer() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.ListTabletsForTabletServer() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_ListTabletsForTabletServer,

  "Bytes sent in response to yb.tserver.TabletServerService.ListTabletsForTabletServer() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.ListTabletsForTabletServer() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_ListTabletsForTabletServer,

  "Microseconds spent handling yb.tserver.TabletServerService.ListTabletsForTabletServer() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.ListTabletsForTabletServer() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_ImportData,

  "Bytes received by yb.tserver.TabletServerService.ImportData() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.ImportData() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_ImportData,

  "Bytes sent in response to yb.tserver.TabletServerService.ImportData() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.ImportData() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_ImportData,

  "Microseconds spent handling yb.tserver.TabletServerService.ImportData() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.ImportData() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_UpdateTransaction,

  "Bytes received by yb.tserver.TabletServerService.UpdateTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.UpdateTransaction() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_UpdateTransaction,

  "Bytes sent in response to yb.tserver.TabletServerService.UpdateTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.UpdateTransaction() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_UpdateTransaction,

  "Microseconds spent handling yb.tserver.TabletServerService.UpdateTransaction() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.UpdateTransaction() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_GetTransactionStatus,

  "Bytes received by yb.tserver.TabletServerService.GetTransactionStatus() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.GetTransactionStatus() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_GetTransactionStatus,

  "Bytes sent in response to yb.tserver.TabletServerService.GetTransactionStatus() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.GetTransactionStatus() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_GetTransactionStatus,

  "Microseconds spent handling yb.tserver.TabletServerService.GetTransactionStatus() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.GetTransactionStatus() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_GetTransactionStatusAtParticipant,

  "Bytes received by yb.tserver.TabletServerService.GetTransactionStatusAtParticipant() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.GetTransactionStatusAtParticipant() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_GetTransactionStatusAtParticipant,

  "Bytes sent in response to yb.tserver.TabletServerService.GetTransactionStatusAtParticipant() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.GetTransactionStatusAtParticipant() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_GetTransactionStatusAtParticipant,

  "Microseconds spent handling yb.tserver.TabletServerService.GetTransactionStatusAtParticipant() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.GetTransactionStatusAtParticipant() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_AbortTransaction,

  "Bytes received by yb.tserver.TabletServerService.AbortTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.AbortTransaction() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_AbortTransaction,

  "Bytes sent in response to yb.tserver.TabletServerService.AbortTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.AbortTransaction() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_AbortTransaction,

  "Microseconds spent handling yb.tserver.TabletServerService.AbortTransaction() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.AbortTransaction() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_Truncate,

  "Bytes received by yb.tserver.TabletServerService.Truncate() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.Truncate() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_Truncate,

  "Bytes sent in response to yb.tserver.TabletServerService.Truncate() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.Truncate() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_Truncate,

  "Microseconds spent handling yb.tserver.TabletServerService.Truncate() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.Truncate() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_GetTabletStatus,

  "Bytes received by yb.tserver.TabletServerService.GetTabletStatus() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.GetTabletStatus() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_GetTabletStatus,

  "Bytes sent in response to yb.tserver.TabletServerService.GetTabletStatus() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.GetTabletStatus() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_GetTabletStatus,

  "Microseconds spent handling yb.tserver.TabletServerService.GetTabletStatus() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.GetTabletStatus() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_GetMasterAddresses,

  "Bytes received by yb.tserver.TabletServerService.GetMasterAddresses() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.GetMasterAddresses() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_GetMasterAddresses,

  "Bytes sent in response to yb.tserver.TabletServerService.GetMasterAddresses() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.GetMasterAddresses() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_GetMasterAddresses,

  "Microseconds spent handling yb.tserver.TabletServerService.GetMasterAddresses() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.GetMasterAddresses() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_Publish,

  "Bytes received by yb.tserver.TabletServerService.Publish() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.Publish() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_Publish,

  "Bytes sent in response to yb.tserver.TabletServerService.Publish() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.Publish() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_Publish,

  "Microseconds spent handling yb.tserver.TabletServerService.Publish() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.Publish() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_IsTabletServerReady,

  "Bytes received by yb.tserver.TabletServerService.IsTabletServerReady() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.IsTabletServerReady() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_IsTabletServerReady,

  "Bytes sent in response to yb.tserver.TabletServerService.IsTabletServerReady() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.IsTabletServerReady() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_IsTabletServerReady,

  "Microseconds spent handling yb.tserver.TabletServerService.IsTabletServerReady() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.IsTabletServerReady() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_TakeTransaction,

  "Bytes received by yb.tserver.TabletServerService.TakeTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.TakeTransaction() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_TakeTransaction,

  "Bytes sent in response to yb.tserver.TabletServerService.TakeTransaction() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.TakeTransaction() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_TakeTransaction,

  "Microseconds spent handling yb.tserver.TabletServerService.TakeTransaction() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.TakeTransaction() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_GetSplitKey,

  "Bytes received by yb.tserver.TabletServerService.GetSplitKey() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.GetSplitKey() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_GetSplitKey,

  "Bytes sent in response to yb.tserver.TabletServerService.GetSplitKey() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.GetSplitKey() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_GetSplitKey,

  "Microseconds spent handling yb.tserver.TabletServerService.GetSplitKey() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.GetSplitKey() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_tserver_TabletServerService_GetSharedData,

  "Bytes received by yb.tserver.TabletServerService.GetSharedData() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.tserver.TabletServerService.GetSharedData() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_tserver_TabletServerService_GetSharedData,

  "Bytes sent in response to yb.tserver.TabletServerService.GetSharedData() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.tserver.TabletServerService.GetSharedData() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_tserver_TabletServerService_GetSharedData,

  "Microseconds spent handling yb.tserver.TabletServerService.GetSharedData() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.tserver.TabletServerService.GetSharedData() RPC requests",

  60000000LU, 2);

namespace yb {

namespace tserver {

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

  InitMethods(entity);

}

TabletServerServiceIf::~TabletServerServiceIf() {

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

  auto index = call->method_index();

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

}

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

  return "yb.tserver.TabletServerService";

}

std::string TabletServerServiceIf::static_service_name() {

  return "yb.tserver.TabletServerService";

}

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

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kWrite)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "Write"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::WriteRequestPB, ::yb::tserver::WriteResponsePB>>(

          std::move(call), [this](const ::yb::tserver::WriteRequestPB* req, ::yb::tserver::WriteResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_Write.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_Write.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_Write.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kRead)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "Read"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::ReadRequestPB, ::yb::tserver::ReadResponsePB>>(

          std::move(call), [this](const ::yb::tserver::ReadRequestPB* req, ::yb::tserver::ReadResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_Read.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_Read.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_Read.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kVerifyTableRowRange)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "VerifyTableRowRange"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::VerifyTableRowRangeRequestPB, ::yb::tserver::VerifyTableRowRangeResponsePB>>(

          std::move(call), [this](const ::yb::tserver::VerifyTableRowRangeRequestPB* req, ::yb::tserver::VerifyTableRowRangeResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_VerifyTableRowRange.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_VerifyTableRowRange.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_VerifyTableRowRange.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kNoOp)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "NoOp"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::NoOpRequestPB, ::yb::tserver::NoOpResponsePB>>(

          std::move(call), [this](const ::yb::tserver::NoOpRequestPB* req, ::yb::tserver::NoOpResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_NoOp.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_NoOp.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_NoOp.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kListTablets)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "ListTablets"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::ListTabletsRequestPB, ::yb::tserver::ListTabletsResponsePB>>(

          std::move(call), [this](const ::yb::tserver::ListTabletsRequestPB* req, ::yb::tserver::ListTabletsResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_ListTablets.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_ListTablets.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_ListTablets.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetLogLocation)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "GetLogLocation"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::GetLogLocationRequestPB, ::yb::tserver::GetLogLocationResponsePB>>(

          std::move(call), [this](const ::yb::tserver::GetLogLocationRequestPB* req, ::yb::tserver::GetLogLocationResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_GetLogLocation.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_GetLogLocation.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_GetLogLocation.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kChecksum)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "Checksum"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::ChecksumRequestPB, ::yb::tserver::ChecksumResponsePB>>(

          std::move(call), [this](const ::yb::tserver::ChecksumRequestPB* req, ::yb::tserver::ChecksumResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_Checksum.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_Checksum.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_Checksum.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kListTabletsForTabletServer)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "ListTabletsForTabletServer"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::ListTabletsForTabletServerRequestPB, ::yb::tserver::ListTabletsForTabletServerResponsePB>>(

          std::move(call), [this](const ::yb::tserver::ListTabletsForTabletServerRequestPB* req, ::yb::tserver::ListTabletsForTabletServerResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_ListTabletsForTabletServer.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_ListTabletsForTabletServer.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_ListTabletsForTabletServer.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kImportData)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "ImportData"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::ImportDataRequestPB, ::yb::tserver::ImportDataResponsePB>>(

          std::move(call), [this](const ::yb::tserver::ImportDataRequestPB* req, ::yb::tserver::ImportDataResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_ImportData.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_ImportData.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_ImportData.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kUpdateTransaction)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "UpdateTransaction"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::UpdateTransactionRequestPB, ::yb::tserver::UpdateTransactionResponsePB>>(

          std::move(call), [this](const ::yb::tserver::UpdateTransactionRequestPB* req, ::yb::tserver::UpdateTransactionResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_UpdateTransaction.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_UpdateTransaction.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_UpdateTransaction.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetTransactionStatus)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "GetTransactionStatus"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::GetTransactionStatusRequestPB, ::yb::tserver::GetTransactionStatusResponsePB>>(

          std::move(call), [this](const ::yb::tserver::GetTransactionStatusRequestPB* req, ::yb::tserver::GetTransactionStatusResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_GetTransactionStatus.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_GetTransactionStatus.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_GetTransactionStatus.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetTransactionStatusAtParticipant)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "GetTransactionStatusAtParticipant"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::GetTransactionStatusAtParticipantRequestPB, ::yb::tserver::GetTransactionStatusAtParticipantResponsePB>>(

          std::move(call), [this](const ::yb::tserver::GetTransactionStatusAtParticipantRequestPB* req, ::yb::tserver::GetTransactionStatusAtParticipantResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_GetTransactionStatusAtParticipant.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_GetTransactionStatusAtParticipant.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_GetTransactionStatusAtParticipant.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kAbortTransaction)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "AbortTransaction"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::AbortTransactionRequestPB, ::yb::tserver::AbortTransactionResponsePB>>(

          std::move(call), [this](const ::yb::tserver::AbortTransactionRequestPB* req, ::yb::tserver::AbortTransactionResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_AbortTransaction.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_AbortTransaction.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_AbortTransaction.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kTruncate)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "Truncate"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::TruncateRequestPB, ::yb::tserver::TruncateResponsePB>>(

          std::move(call), [this](const ::yb::tserver::TruncateRequestPB* req, ::yb::tserver::TruncateResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_Truncate.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_Truncate.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_Truncate.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetTabletStatus)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "GetTabletStatus"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::GetTabletStatusRequestPB, ::yb::tserver::GetTabletStatusResponsePB>>(

          std::move(call), [this](const ::yb::tserver::GetTabletStatusRequestPB* req, ::yb::tserver::GetTabletStatusResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_GetTabletStatus.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_GetTabletStatus.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_GetTabletStatus.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetMasterAddresses)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "GetMasterAddresses"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::GetMasterAddressesRequestPB, ::yb::tserver::GetMasterAddressesResponsePB>>(

          std::move(call), [this](const ::yb::tserver::GetMasterAddressesRequestPB* req, ::yb::tserver::GetMasterAddressesResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_GetMasterAddresses.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_GetMasterAddresses.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_GetMasterAddresses.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kPublish)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "Publish"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::PublishRequestPB, ::yb::tserver::PublishResponsePB>>(

          std::move(call), [this](const ::yb::tserver::PublishRequestPB* req, ::yb::tserver::PublishResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_Publish.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_Publish.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_Publish.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kIsTabletServerReady)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "IsTabletServerReady"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::IsTabletServerReadyRequestPB, ::yb::tserver::IsTabletServerReadyResponsePB>>(

          std::move(call), [this](const ::yb::tserver::IsTabletServerReadyRequestPB* req, ::yb::tserver::IsTabletServerReadyResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_IsTabletServerReady.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_IsTabletServerReady.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_IsTabletServerReady.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kTakeTransaction)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "TakeTransaction"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::TakeTransactionRequestPB, ::yb::tserver::TakeTransactionResponsePB>>(

          std::move(call), [this](const ::yb::tserver::TakeTransactionRequestPB* req, ::yb::tserver::TakeTransactionResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_TakeTransaction.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_TakeTransaction.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_TakeTransaction.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetSplitKey)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "GetSplitKey"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::GetSplitKeyRequestPB, ::yb::tserver::GetSplitKeyResponsePB>>(

          std::move(call), [this](const ::yb::tserver::GetSplitKeyRequestPB* req, ::yb::tserver::GetSplitKeyResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_GetSplitKey.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_GetSplitKey.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_GetSplitKey.Instantiate(entity))

  };

  methods_[static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetSharedData)] = {

    .method = ::yb::rpc::RemoteMethod("yb.tserver.TabletServerService", "GetSharedData"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::tserver::GetSharedDataRequestPB, ::yb::tserver::GetSharedDataResponsePB>>(

          std::move(call), [this](const ::yb::tserver::GetSharedDataRequestPB* req, ::yb::tserver::GetSharedDataResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_tserver_TabletServerService_GetSharedData.Instantiate(entity),

        METRIC_service_response_bytes_yb_tserver_TabletServerService_GetSharedData.Instantiate(entity),

        METRIC_handler_latency_yb_tserver_TabletServerService_GetSharedData.Instantiate(entity))

  };

}

} // namespace tserver

} // namespace yb