YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

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

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

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

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_Write,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_Read,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_Read,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_VerifyTableRowRange,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_VerifyTableRowRange,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_NoOp,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_NoOp,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_ListTablets,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_ListTablets,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_GetLogLocation,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_GetLogLocation,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_Checksum,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_Checksum,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_ListTabletsForTabletServer,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_ListTabletsForTabletServer,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_ImportData,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_ImportData,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_UpdateTransaction,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_UpdateTransaction,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_GetTransactionStatus,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_GetTransactionStatus,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_GetTransactionStatusAtParticipant,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_GetTransactionStatusAtParticipant,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_AbortTransaction,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_AbortTransaction,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_Truncate,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_Truncate,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_GetTabletStatus,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_GetTabletStatus,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_GetMasterAddresses,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_GetMasterAddresses,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_Publish,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_Publish,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_IsTabletServerReady,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_IsTabletServerReady,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_TakeTransaction,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_TakeTransaction,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_GetSplitKey,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_GetSplitKey,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_tserver_TabletServerService_GetSharedData,

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

  yb::MetricUnit::kBytes,

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

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_tserver_TabletServerService_GetSharedData,

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

  yb::MetricUnit::kBytes,

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

namespace yb {

namespace tserver {

namespace {

const std::string kFullTabletServerServiceName = "yb.tserver.TabletServerService";

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

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

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kWrite)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_Write.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_Write.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kRead)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_Read.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_Read.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kVerifyTableRowRange)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_VerifyTableRowRange.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_VerifyTableRowRange.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kNoOp)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_NoOp.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_NoOp.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kListTablets)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_ListTablets.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_ListTablets.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kGetLogLocation)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_GetLogLocation.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_GetLogLocation.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kChecksum)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_Checksum.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_Checksum.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kListTabletsForTabletServer)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_ListTabletsForTabletServer.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_ListTabletsForTabletServer.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kImportData)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_ImportData.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_ImportData.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kUpdateTransaction)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_UpdateTransaction.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_UpdateTransaction.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kGetTransactionStatus)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_GetTransactionStatus.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_GetTransactionStatus.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kGetTransactionStatusAtParticipant)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_GetTransactionStatusAtParticipant.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_GetTransactionStatusAtParticipant.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kAbortTransaction)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_AbortTransaction.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_AbortTransaction.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kTruncate)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_Truncate.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_Truncate.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kGetTabletStatus)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_GetTabletStatus.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_GetTabletStatus.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kGetMasterAddresses)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_GetMasterAddresses.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_GetMasterAddresses.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kPublish)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_Publish.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_Publish.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kIsTabletServerReady)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_IsTabletServerReady.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_IsTabletServerReady.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kTakeTransaction)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_TakeTransaction.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_TakeTransaction.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kGetSplitKey)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_GetSplitKey.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_GetSplitKey.Instantiate(entity)

  };

  result->value[to_underlying(TabletServerServiceRpcMethodIndexes::kGetSharedData)] = {

      METRIC_proxy_request_bytes_yb_tserver_TabletServerService_GetSharedData.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_tserver_TabletServerService_GetSharedData.Instantiate(entity)

  };

  return result;

}

} // namespace

TabletServerServiceProxy::TabletServerServiceProxy(

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

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

    const ::yb::MonoDelta& resolve_cache_timeout)

    : ProxyBase(kFullTabletServerServiceName, &CreateTabletServerServiceMetrics,

                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status TabletServerServiceProxy::Write(

    const ::yb::tserver::WriteRequestPB &req, ::yb::tserver::WriteResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kWrite)), req, resp, controller);

}

void TabletServerServiceProxy::WriteAsync(

    const ::yb::tserver::WriteRequestPB &req, ::yb::tserver::WriteResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kWrite)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::Read(

    const ::yb::tserver::ReadRequestPB &req, ::yb::tserver::ReadResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kRead)), req, resp, controller);

}

void TabletServerServiceProxy::ReadAsync(

    const ::yb::tserver::ReadRequestPB &req, ::yb::tserver::ReadResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kRead)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::VerifyTableRowRange(

    const ::yb::tserver::VerifyTableRowRangeRequestPB &req, ::yb::tserver::VerifyTableRowRangeResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kVerifyTableRowRange)), req, resp, controller);

}

void TabletServerServiceProxy::VerifyTableRowRangeAsync(

    const ::yb::tserver::VerifyTableRowRangeRequestPB &req, ::yb::tserver::VerifyTableRowRangeResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kVerifyTableRowRange)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::NoOp(

    const ::yb::tserver::NoOpRequestPB &req, ::yb::tserver::NoOpResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kNoOp)), req, resp, controller);

}

void TabletServerServiceProxy::NoOpAsync(

    const ::yb::tserver::NoOpRequestPB &req, ::yb::tserver::NoOpResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kNoOp)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::ListTablets(

    const ::yb::tserver::ListTabletsRequestPB &req, ::yb::tserver::ListTabletsResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kListTablets)), req, resp, controller);

}

void TabletServerServiceProxy::ListTabletsAsync(

    const ::yb::tserver::ListTabletsRequestPB &req, ::yb::tserver::ListTabletsResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kListTablets)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::GetLogLocation(

    const ::yb::tserver::GetLogLocationRequestPB &req, ::yb::tserver::GetLogLocationResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetLogLocation)), req, resp, controller);

}

void TabletServerServiceProxy::GetLogLocationAsync(

    const ::yb::tserver::GetLogLocationRequestPB &req, ::yb::tserver::GetLogLocationResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetLogLocation)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::Checksum(

    const ::yb::tserver::ChecksumRequestPB &req, ::yb::tserver::ChecksumResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kChecksum)), req, resp, controller);

}

void TabletServerServiceProxy::ChecksumAsync(

    const ::yb::tserver::ChecksumRequestPB &req, ::yb::tserver::ChecksumResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kChecksum)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::ListTabletsForTabletServer(

    const ::yb::tserver::ListTabletsForTabletServerRequestPB &req, ::yb::tserver::ListTabletsForTabletServerResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kListTabletsForTabletServer)), req, resp, controller);

}

void TabletServerServiceProxy::ListTabletsForTabletServerAsync(

    const ::yb::tserver::ListTabletsForTabletServerRequestPB &req, ::yb::tserver::ListTabletsForTabletServerResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kListTabletsForTabletServer)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::ImportData(

    const ::yb::tserver::ImportDataRequestPB &req, ::yb::tserver::ImportDataResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kImportData)), req, resp, controller);

}

void TabletServerServiceProxy::ImportDataAsync(

    const ::yb::tserver::ImportDataRequestPB &req, ::yb::tserver::ImportDataResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kImportData)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::UpdateTransaction(

    const ::yb::tserver::UpdateTransactionRequestPB &req, ::yb::tserver::UpdateTransactionResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kUpdateTransaction)), req, resp, controller);

}

void TabletServerServiceProxy::UpdateTransactionAsync(

    const ::yb::tserver::UpdateTransactionRequestPB &req, ::yb::tserver::UpdateTransactionResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kUpdateTransaction)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::GetTransactionStatus(

    const ::yb::tserver::GetTransactionStatusRequestPB &req, ::yb::tserver::GetTransactionStatusResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetTransactionStatus)), req, resp, controller);

}

void TabletServerServiceProxy::GetTransactionStatusAsync(

    const ::yb::tserver::GetTransactionStatusRequestPB &req, ::yb::tserver::GetTransactionStatusResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetTransactionStatus)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::GetTransactionStatusAtParticipant(

    const ::yb::tserver::GetTransactionStatusAtParticipantRequestPB &req, ::yb::tserver::GetTransactionStatusAtParticipantResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetTransactionStatusAtParticipant)), req, resp, controller);

}

void TabletServerServiceProxy::GetTransactionStatusAtParticipantAsync(

    const ::yb::tserver::GetTransactionStatusAtParticipantRequestPB &req, ::yb::tserver::GetTransactionStatusAtParticipantResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetTransactionStatusAtParticipant)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::AbortTransaction(

    const ::yb::tserver::AbortTransactionRequestPB &req, ::yb::tserver::AbortTransactionResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kAbortTransaction)), req, resp, controller);

}

void TabletServerServiceProxy::AbortTransactionAsync(

    const ::yb::tserver::AbortTransactionRequestPB &req, ::yb::tserver::AbortTransactionResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kAbortTransaction)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::Truncate(

    const ::yb::tserver::TruncateRequestPB &req, ::yb::tserver::TruncateResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kTruncate)), req, resp, controller);

}

void TabletServerServiceProxy::TruncateAsync(

    const ::yb::tserver::TruncateRequestPB &req, ::yb::tserver::TruncateResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kTruncate)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::GetTabletStatus(

    const ::yb::tserver::GetTabletStatusRequestPB &req, ::yb::tserver::GetTabletStatusResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetTabletStatus)), req, resp, controller);

}

void TabletServerServiceProxy::GetTabletStatusAsync(

    const ::yb::tserver::GetTabletStatusRequestPB &req, ::yb::tserver::GetTabletStatusResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetTabletStatus)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::GetMasterAddresses(

    const ::yb::tserver::GetMasterAddressesRequestPB &req, ::yb::tserver::GetMasterAddressesResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetMasterAddresses)), req, resp, controller);

}

void TabletServerServiceProxy::GetMasterAddressesAsync(

    const ::yb::tserver::GetMasterAddressesRequestPB &req, ::yb::tserver::GetMasterAddressesResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetMasterAddresses)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::Publish(

    const ::yb::tserver::PublishRequestPB &req, ::yb::tserver::PublishResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kPublish)), req, resp, controller);

}

void TabletServerServiceProxy::PublishAsync(

    const ::yb::tserver::PublishRequestPB &req, ::yb::tserver::PublishResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kPublish)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::IsTabletServerReady(

    const ::yb::tserver::IsTabletServerReadyRequestPB &req, ::yb::tserver::IsTabletServerReadyResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kIsTabletServerReady)), req, resp, controller);

}

void TabletServerServiceProxy::IsTabletServerReadyAsync(

    const ::yb::tserver::IsTabletServerReadyRequestPB &req, ::yb::tserver::IsTabletServerReadyResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kIsTabletServerReady)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::TakeTransaction(

    const ::yb::tserver::TakeTransactionRequestPB &req, ::yb::tserver::TakeTransactionResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kTakeTransaction)), req, resp, controller);

}

void TabletServerServiceProxy::TakeTransactionAsync(

    const ::yb::tserver::TakeTransactionRequestPB &req, ::yb::tserver::TakeTransactionResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kTakeTransaction)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::GetSplitKey(

    const ::yb::tserver::GetSplitKeyRequestPB &req, ::yb::tserver::GetSplitKeyResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetSplitKey)), req, resp, controller);

}

void TabletServerServiceProxy::GetSplitKeyAsync(

    const ::yb::tserver::GetSplitKeyRequestPB &req, ::yb::tserver::GetSplitKeyResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetSplitKey)), req, resp, controller, std::move(callback));

}

::yb::Status TabletServerServiceProxy::GetSharedData(

    const ::yb::tserver::GetSharedDataRequestPB &req, ::yb::tserver::GetSharedDataResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetSharedData)), req, resp, controller);

}

void TabletServerServiceProxy::GetSharedDataAsync(

    const ::yb::tserver::GetSharedDataRequestPB &req, ::yb::tserver::GetSharedDataResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<21>(static_cast<size_t>(TabletServerServiceRpcMethodIndexes::kGetSharedData)), req, resp, controller, std::move(callback));

}

} // namespace tserver

} // namespace yb