YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

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

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

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

#include "yb/rpc/proxy.h"

#include "yb/rpc/outbound_call.h"

#include "yb/util/metrics.h"

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

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_FlushTables,

  "Bytes sent by yb.master.MasterAdmin.FlushTables() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.FlushTables() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_FlushTables,

  "Bytes received in response to yb.master.MasterAdmin.FlushTables() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.FlushTables() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_IsFlushTablesDone,

  "Bytes sent by yb.master.MasterAdmin.IsFlushTablesDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.IsFlushTablesDone() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_IsFlushTablesDone,

  "Bytes received in response to yb.master.MasterAdmin.IsFlushTablesDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.IsFlushTablesDone() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_FlushSysCatalog,

  "Bytes sent by yb.master.MasterAdmin.FlushSysCatalog() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.FlushSysCatalog() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_FlushSysCatalog,

  "Bytes received in response to yb.master.MasterAdmin.FlushSysCatalog() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.FlushSysCatalog() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_CompactSysCatalog,

  "Bytes sent by yb.master.MasterAdmin.CompactSysCatalog() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.CompactSysCatalog() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_CompactSysCatalog,

  "Bytes received in response to yb.master.MasterAdmin.CompactSysCatalog() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.CompactSysCatalog() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_IsInitDbDone,

  "Bytes sent by yb.master.MasterAdmin.IsInitDbDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.IsInitDbDone() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_IsInitDbDone,

  "Bytes received in response to yb.master.MasterAdmin.IsInitDbDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.IsInitDbDone() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_SplitTablet,

  "Bytes sent by yb.master.MasterAdmin.SplitTablet() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.SplitTablet() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_SplitTablet,

  "Bytes received in response to yb.master.MasterAdmin.SplitTablet() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.SplitTablet() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_CreateTransactionStatusTable,

  "Bytes sent by yb.master.MasterAdmin.CreateTransactionStatusTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.CreateTransactionStatusTable() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_CreateTransactionStatusTable,

  "Bytes received in response to yb.master.MasterAdmin.CreateTransactionStatusTable() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.CreateTransactionStatusTable() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_DeleteNotServingTablet,

  "Bytes sent by yb.master.MasterAdmin.DeleteNotServingTablet() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.DeleteNotServingTablet() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_DeleteNotServingTablet,

  "Bytes received in response to yb.master.MasterAdmin.DeleteNotServingTablet() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.DeleteNotServingTablet() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_DisableTabletSplitting,

  "Bytes sent by yb.master.MasterAdmin.DisableTabletSplitting() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.DisableTabletSplitting() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_DisableTabletSplitting,

  "Bytes received in response to yb.master.MasterAdmin.DisableTabletSplitting() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.DisableTabletSplitting() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_IsTabletSplittingComplete,

  "Bytes sent by yb.master.MasterAdmin.IsTabletSplittingComplete() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.IsTabletSplittingComplete() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_IsTabletSplittingComplete,

  "Bytes received in response to yb.master.MasterAdmin.IsTabletSplittingComplete() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.IsTabletSplittingComplete() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterAdmin_DdlLog,

  "Bytes sent by yb.master.MasterAdmin.DdlLog() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterAdmin.DdlLog() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterAdmin_DdlLog,

  "Bytes received in response to yb.master.MasterAdmin.DdlLog() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterAdmin.DdlLog() RPC requests");

namespace yb {

namespace master {

namespace {

const std::string kFullMasterAdminName = "yb.master.MasterAdmin";

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

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

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kFlushTables)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_FlushTables.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_FlushTables.Instantiate(entity)

  };

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kIsFlushTablesDone)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_IsFlushTablesDone.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_IsFlushTablesDone.Instantiate(entity)

  };

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kFlushSysCatalog)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_FlushSysCatalog.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_FlushSysCatalog.Instantiate(entity)

  };

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kCompactSysCatalog)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_CompactSysCatalog.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_CompactSysCatalog.Instantiate(entity)

  };

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kIsInitDbDone)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_IsInitDbDone.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_IsInitDbDone.Instantiate(entity)

  };

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kSplitTablet)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_SplitTablet.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_SplitTablet.Instantiate(entity)

  };

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kCreateTransactionStatusTable)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_CreateTransactionStatusTable.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_CreateTransactionStatusTable.Instantiate(entity)

  };

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kDeleteNotServingTablet)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_DeleteNotServingTablet.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_DeleteNotServingTablet.Instantiate(entity)

  };

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kDisableTabletSplitting)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_DisableTabletSplitting.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_DisableTabletSplitting.Instantiate(entity)

  };

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kIsTabletSplittingComplete)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_IsTabletSplittingComplete.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_IsTabletSplittingComplete.Instantiate(entity)

  };

  result->value[to_underlying(MasterAdminRpcMethodIndexes::kDdlLog)] = {

      METRIC_proxy_request_bytes_yb_master_MasterAdmin_DdlLog.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterAdmin_DdlLog.Instantiate(entity)

  };

  return result;

}

} // namespace

MasterAdminProxy::MasterAdminProxy(

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

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

    const ::yb::MonoDelta& resolve_cache_timeout)

    : ProxyBase(kFullMasterAdminName, &CreateMasterAdminMetrics,

                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status MasterAdminProxy::FlushTables(

    const ::yb::master::FlushTablesRequestPB &req, ::yb::master::FlushTablesResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kFlushTables)), req, resp, controller);

}

void MasterAdminProxy::FlushTablesAsync(

    const ::yb::master::FlushTablesRequestPB &req, ::yb::master::FlushTablesResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kFlushTables)), req, resp, controller, std::move(callback));

}

::yb::Status MasterAdminProxy::IsFlushTablesDone(

    const ::yb::master::IsFlushTablesDoneRequestPB &req, ::yb::master::IsFlushTablesDoneResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kIsFlushTablesDone)), req, resp, controller);

}

void MasterAdminProxy::IsFlushTablesDoneAsync(

    const ::yb::master::IsFlushTablesDoneRequestPB &req, ::yb::master::IsFlushTablesDoneResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kIsFlushTablesDone)), req, resp, controller, std::move(callback));

}

::yb::Status MasterAdminProxy::FlushSysCatalog(

    const ::yb::master::FlushSysCatalogRequestPB &req, ::yb::master::FlushSysCatalogResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kFlushSysCatalog)), req, resp, controller);

}

void MasterAdminProxy::FlushSysCatalogAsync(

    const ::yb::master::FlushSysCatalogRequestPB &req, ::yb::master::FlushSysCatalogResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kFlushSysCatalog)), req, resp, controller, std::move(callback));

}

::yb::Status MasterAdminProxy::CompactSysCatalog(

    const ::yb::master::CompactSysCatalogRequestPB &req, ::yb::master::CompactSysCatalogResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kCompactSysCatalog)), req, resp, controller);

}

void MasterAdminProxy::CompactSysCatalogAsync(

    const ::yb::master::CompactSysCatalogRequestPB &req, ::yb::master::CompactSysCatalogResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kCompactSysCatalog)), req, resp, controller, std::move(callback));

}

::yb::Status MasterAdminProxy::IsInitDbDone(

    const ::yb::master::IsInitDbDoneRequestPB &req, ::yb::master::IsInitDbDoneResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kIsInitDbDone)), req, resp, controller);

}

void MasterAdminProxy::IsInitDbDoneAsync(

    const ::yb::master::IsInitDbDoneRequestPB &req, ::yb::master::IsInitDbDoneResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kIsInitDbDone)), req, resp, controller, std::move(callback));

}

::yb::Status MasterAdminProxy::SplitTablet(

    const ::yb::master::SplitTabletRequestPB &req, ::yb::master::SplitTabletResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kSplitTablet)), req, resp, controller);

}

void MasterAdminProxy::SplitTabletAsync(

    const ::yb::master::SplitTabletRequestPB &req, ::yb::master::SplitTabletResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kSplitTablet)), req, resp, controller, std::move(callback));

}

::yb::Status MasterAdminProxy::CreateTransactionStatusTable(

    const ::yb::master::CreateTransactionStatusTableRequestPB &req, ::yb::master::CreateTransactionStatusTableResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kCreateTransactionStatusTable)), req, resp, controller);

}

void MasterAdminProxy::CreateTransactionStatusTableAsync(

    const ::yb::master::CreateTransactionStatusTableRequestPB &req, ::yb::master::CreateTransactionStatusTableResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kCreateTransactionStatusTable)), req, resp, controller, std::move(callback));

}

::yb::Status MasterAdminProxy::DeleteNotServingTablet(

    const ::yb::master::DeleteNotServingTabletRequestPB &req, ::yb::master::DeleteNotServingTabletResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kDeleteNotServingTablet)), req, resp, controller);

}

void MasterAdminProxy::DeleteNotServingTabletAsync(

    const ::yb::master::DeleteNotServingTabletRequestPB &req, ::yb::master::DeleteNotServingTabletResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kDeleteNotServingTablet)), req, resp, controller, std::move(callback));

}

::yb::Status MasterAdminProxy::DisableTabletSplitting(

    const ::yb::master::DisableTabletSplittingRequestPB &req, ::yb::master::DisableTabletSplittingResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kDisableTabletSplitting)), req, resp, controller);

}

void MasterAdminProxy::DisableTabletSplittingAsync(

    const ::yb::master::DisableTabletSplittingRequestPB &req, ::yb::master::DisableTabletSplittingResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kDisableTabletSplitting)), req, resp, controller, std::move(callback));

}

::yb::Status MasterAdminProxy::IsTabletSplittingComplete(

    const ::yb::master::IsTabletSplittingCompleteRequestPB &req, ::yb::master::IsTabletSplittingCompleteResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kIsTabletSplittingComplete)), req, resp, controller);

}

void MasterAdminProxy::IsTabletSplittingCompleteAsync(

    const ::yb::master::IsTabletSplittingCompleteRequestPB &req, ::yb::master::IsTabletSplittingCompleteResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kIsTabletSplittingComplete)), req, resp, controller, std::move(callback));

}

::yb::Status MasterAdminProxy::DdlLog(

    const ::yb::master::DdlLogRequestPB &req, ::yb::master::DdlLogResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kDdlLog)), req, resp, controller);

}

void MasterAdminProxy::DdlLogAsync(

    const ::yb::master::DdlLogRequestPB &req, ::yb::master::DdlLogResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(MasterAdminRpcMethodIndexes::kDdlLog)), req, resp, controller, std::move(callback));

}

} // namespace master

} // namespace yb