YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

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

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

#include "yb/master/master_replication.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_MasterReplication_ValidateReplicationInfo,

  "Bytes sent by yb.master.MasterReplication.ValidateReplicationInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.ValidateReplicationInfo() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_ValidateReplicationInfo,

  "Bytes received in response to yb.master.MasterReplication.ValidateReplicationInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.ValidateReplicationInfo() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_CreateCDCStream,

  "Bytes sent by yb.master.MasterReplication.CreateCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.CreateCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_CreateCDCStream,

  "Bytes received in response to yb.master.MasterReplication.CreateCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.CreateCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_DeleteCDCStream,

  "Bytes sent by yb.master.MasterReplication.DeleteCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.DeleteCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_DeleteCDCStream,

  "Bytes received in response to yb.master.MasterReplication.DeleteCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.DeleteCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_ListCDCStreams,

  "Bytes sent by yb.master.MasterReplication.ListCDCStreams() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.ListCDCStreams() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_ListCDCStreams,

  "Bytes received in response to yb.master.MasterReplication.ListCDCStreams() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.ListCDCStreams() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_GetCDCStream,

  "Bytes sent by yb.master.MasterReplication.GetCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.GetCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_GetCDCStream,

  "Bytes received in response to yb.master.MasterReplication.GetCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.GetCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_GetCDCDBStreamInfo,

  "Bytes sent by yb.master.MasterReplication.GetCDCDBStreamInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.GetCDCDBStreamInfo() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_GetCDCDBStreamInfo,

  "Bytes received in response to yb.master.MasterReplication.GetCDCDBStreamInfo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.GetCDCDBStreamInfo() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_UpdateCDCStream,

  "Bytes sent by yb.master.MasterReplication.UpdateCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.UpdateCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_UpdateCDCStream,

  "Bytes received in response to yb.master.MasterReplication.UpdateCDCStream() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.UpdateCDCStream() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_SetupUniverseReplication,

  "Bytes sent by yb.master.MasterReplication.SetupUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.SetupUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_SetupUniverseReplication,

  "Bytes received in response to yb.master.MasterReplication.SetupUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.SetupUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_DeleteUniverseReplication,

  "Bytes sent by yb.master.MasterReplication.DeleteUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.DeleteUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_DeleteUniverseReplication,

  "Bytes received in response to yb.master.MasterReplication.DeleteUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.DeleteUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_AlterUniverseReplication,

  "Bytes sent by yb.master.MasterReplication.AlterUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.AlterUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_AlterUniverseReplication,

  "Bytes received in response to yb.master.MasterReplication.AlterUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.AlterUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_SetUniverseReplicationEnabled,

  "Bytes sent by yb.master.MasterReplication.SetUniverseReplicationEnabled() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.SetUniverseReplicationEnabled() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_SetUniverseReplicationEnabled,

  "Bytes received in response to yb.master.MasterReplication.SetUniverseReplicationEnabled() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.SetUniverseReplicationEnabled() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_GetUniverseReplication,

  "Bytes sent by yb.master.MasterReplication.GetUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.GetUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_GetUniverseReplication,

  "Bytes received in response to yb.master.MasterReplication.GetUniverseReplication() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.GetUniverseReplication() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_IsSetupUniverseReplicationDone,

  "Bytes sent by yb.master.MasterReplication.IsSetupUniverseReplicationDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.IsSetupUniverseReplicationDone() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_IsSetupUniverseReplicationDone,

  "Bytes received in response to yb.master.MasterReplication.IsSetupUniverseReplicationDone() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.IsSetupUniverseReplicationDone() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterReplication_UpdateConsumerOnProducerSplit,

  "Bytes sent by yb.master.MasterReplication.UpdateConsumerOnProducerSplit() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterReplication.UpdateConsumerOnProducerSplit() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterReplication_UpdateConsumerOnProducerSplit,

  "Bytes received in response to yb.master.MasterReplication.UpdateConsumerOnProducerSplit() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterReplication.UpdateConsumerOnProducerSplit() RPC requests");

namespace yb {

namespace master {

namespace {

const std::string kFullMasterReplicationName = "yb.master.MasterReplication";

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

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

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kValidateReplicationInfo)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_ValidateReplicationInfo.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_ValidateReplicationInfo.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kCreateCDCStream)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_CreateCDCStream.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_CreateCDCStream.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kDeleteCDCStream)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_DeleteCDCStream.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_DeleteCDCStream.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kListCDCStreams)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_ListCDCStreams.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_ListCDCStreams.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kGetCDCStream)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_GetCDCStream.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_GetCDCStream.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kGetCDCDBStreamInfo)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_GetCDCDBStreamInfo.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_GetCDCDBStreamInfo.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kUpdateCDCStream)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_UpdateCDCStream.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_UpdateCDCStream.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kSetupUniverseReplication)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_SetupUniverseReplication.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_SetupUniverseReplication.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kDeleteUniverseReplication)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_DeleteUniverseReplication.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_DeleteUniverseReplication.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kAlterUniverseReplication)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_AlterUniverseReplication.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_AlterUniverseReplication.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kSetUniverseReplicationEnabled)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_SetUniverseReplicationEnabled.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_SetUniverseReplicationEnabled.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kGetUniverseReplication)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_GetUniverseReplication.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_GetUniverseReplication.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kIsSetupUniverseReplicationDone)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_IsSetupUniverseReplicationDone.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_IsSetupUniverseReplicationDone.Instantiate(entity)

  };

  result->value[to_underlying(MasterReplicationRpcMethodIndexes::kUpdateConsumerOnProducerSplit)] = {

      METRIC_proxy_request_bytes_yb_master_MasterReplication_UpdateConsumerOnProducerSplit.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterReplication_UpdateConsumerOnProducerSplit.Instantiate(entity)

  };

  return result;

}

} // namespace

MasterReplicationProxy::MasterReplicationProxy(

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

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

    const ::yb::MonoDelta& resolve_cache_timeout)

    : ProxyBase(kFullMasterReplicationName, &CreateMasterReplicationMetrics,

                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status MasterReplicationProxy::ValidateReplicationInfo(

    const ::yb::master::ValidateReplicationInfoRequestPB &req, ::yb::master::ValidateReplicationInfoResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kValidateReplicationInfo)), req, resp, controller);

}

void MasterReplicationProxy::ValidateReplicationInfoAsync(

    const ::yb::master::ValidateReplicationInfoRequestPB &req, ::yb::master::ValidateReplicationInfoResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kValidateReplicationInfo)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::CreateCDCStream(

    const ::yb::master::CreateCDCStreamRequestPB &req, ::yb::master::CreateCDCStreamResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kCreateCDCStream)), req, resp, controller);

}

void MasterReplicationProxy::CreateCDCStreamAsync(

    const ::yb::master::CreateCDCStreamRequestPB &req, ::yb::master::CreateCDCStreamResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kCreateCDCStream)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::DeleteCDCStream(

    const ::yb::master::DeleteCDCStreamRequestPB &req, ::yb::master::DeleteCDCStreamResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kDeleteCDCStream)), req, resp, controller);

}

void MasterReplicationProxy::DeleteCDCStreamAsync(

    const ::yb::master::DeleteCDCStreamRequestPB &req, ::yb::master::DeleteCDCStreamResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kDeleteCDCStream)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::ListCDCStreams(

    const ::yb::master::ListCDCStreamsRequestPB &req, ::yb::master::ListCDCStreamsResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kListCDCStreams)), req, resp, controller);

}

void MasterReplicationProxy::ListCDCStreamsAsync(

    const ::yb::master::ListCDCStreamsRequestPB &req, ::yb::master::ListCDCStreamsResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kListCDCStreams)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::GetCDCStream(

    const ::yb::master::GetCDCStreamRequestPB &req, ::yb::master::GetCDCStreamResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kGetCDCStream)), req, resp, controller);

}

void MasterReplicationProxy::GetCDCStreamAsync(

    const ::yb::master::GetCDCStreamRequestPB &req, ::yb::master::GetCDCStreamResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kGetCDCStream)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::GetCDCDBStreamInfo(

    const ::yb::master::GetCDCDBStreamInfoRequestPB &req, ::yb::master::GetCDCDBStreamInfoResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kGetCDCDBStreamInfo)), req, resp, controller);

}

void MasterReplicationProxy::GetCDCDBStreamInfoAsync(

    const ::yb::master::GetCDCDBStreamInfoRequestPB &req, ::yb::master::GetCDCDBStreamInfoResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kGetCDCDBStreamInfo)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::UpdateCDCStream(

    const ::yb::master::UpdateCDCStreamRequestPB &req, ::yb::master::UpdateCDCStreamResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kUpdateCDCStream)), req, resp, controller);

}

void MasterReplicationProxy::UpdateCDCStreamAsync(

    const ::yb::master::UpdateCDCStreamRequestPB &req, ::yb::master::UpdateCDCStreamResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kUpdateCDCStream)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::SetupUniverseReplication(

    const ::yb::master::SetupUniverseReplicationRequestPB &req, ::yb::master::SetupUniverseReplicationResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kSetupUniverseReplication)), req, resp, controller);

}

void MasterReplicationProxy::SetupUniverseReplicationAsync(

    const ::yb::master::SetupUniverseReplicationRequestPB &req, ::yb::master::SetupUniverseReplicationResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kSetupUniverseReplication)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::DeleteUniverseReplication(

    const ::yb::master::DeleteUniverseReplicationRequestPB &req, ::yb::master::DeleteUniverseReplicationResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kDeleteUniverseReplication)), req, resp, controller);

}

void MasterReplicationProxy::DeleteUniverseReplicationAsync(

    const ::yb::master::DeleteUniverseReplicationRequestPB &req, ::yb::master::DeleteUniverseReplicationResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kDeleteUniverseReplication)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::AlterUniverseReplication(

    const ::yb::master::AlterUniverseReplicationRequestPB &req, ::yb::master::AlterUniverseReplicationResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kAlterUniverseReplication)), req, resp, controller);

}

void MasterReplicationProxy::AlterUniverseReplicationAsync(

    const ::yb::master::AlterUniverseReplicationRequestPB &req, ::yb::master::AlterUniverseReplicationResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kAlterUniverseReplication)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::SetUniverseReplicationEnabled(

    const ::yb::master::SetUniverseReplicationEnabledRequestPB &req, ::yb::master::SetUniverseReplicationEnabledResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kSetUniverseReplicationEnabled)), req, resp, controller);

}

void MasterReplicationProxy::SetUniverseReplicationEnabledAsync(

    const ::yb::master::SetUniverseReplicationEnabledRequestPB &req, ::yb::master::SetUniverseReplicationEnabledResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kSetUniverseReplicationEnabled)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::GetUniverseReplication(

    const ::yb::master::GetUniverseReplicationRequestPB &req, ::yb::master::GetUniverseReplicationResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kGetUniverseReplication)), req, resp, controller);

}

void MasterReplicationProxy::GetUniverseReplicationAsync(

    const ::yb::master::GetUniverseReplicationRequestPB &req, ::yb::master::GetUniverseReplicationResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kGetUniverseReplication)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::IsSetupUniverseReplicationDone(

    const ::yb::master::IsSetupUniverseReplicationDoneRequestPB &req, ::yb::master::IsSetupUniverseReplicationDoneResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kIsSetupUniverseReplicationDone)), req, resp, controller);

}

void MasterReplicationProxy::IsSetupUniverseReplicationDoneAsync(

    const ::yb::master::IsSetupUniverseReplicationDoneRequestPB &req, ::yb::master::IsSetupUniverseReplicationDoneResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kIsSetupUniverseReplicationDone)), req, resp, controller, std::move(callback));

}

::yb::Status MasterReplicationProxy::UpdateConsumerOnProducerSplit(

    const ::yb::master::UpdateConsumerOnProducerSplitRequestPB &req, ::yb::master::UpdateConsumerOnProducerSplitResponsePB *resp, ::yb::rpc::RpcController *controller) const {

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

  return proxy().SyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kUpdateConsumerOnProducerSplit)), req, resp, controller);

}

void MasterReplicationProxy::UpdateConsumerOnProducerSplitAsync(

    const ::yb::master::UpdateConsumerOnProducerSplitRequestPB &req, ::yb::master::UpdateConsumerOnProducerSplitResponsePB *resp, ::yb::rpc::RpcController *controller,

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

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

  proxy().AsyncRequest(

      &method, metrics<14>(static_cast<size_t>(MasterReplicationRpcMethodIndexes::kUpdateConsumerOnProducerSplit)), req, resp, controller, std::move(callback));

}

} // namespace master

} // namespace yb