YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

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

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

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

  "Bytes sent by yb.master.MasterBackup.CreateSnapshot() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterBackup.CreateSnapshot() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterBackup_CreateSnapshot,

  "Bytes received in response to yb.master.MasterBackup.CreateSnapshot() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterBackup.CreateSnapshot() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterBackup_ListSnapshots,

  "Bytes sent by yb.master.MasterBackup.ListSnapshots() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterBackup.ListSnapshots() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterBackup_ListSnapshots,

  "Bytes received in response to yb.master.MasterBackup.ListSnapshots() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterBackup.ListSnapshots() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterBackup_ListSnapshotRestorations,

  "Bytes sent by yb.master.MasterBackup.ListSnapshotRestorations() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterBackup.ListSnapshotRestorations() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterBackup_ListSnapshotRestorations,

  "Bytes received in response to yb.master.MasterBackup.ListSnapshotRestorations() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterBackup.ListSnapshotRestorations() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterBackup_RestoreSnapshot,

  "Bytes sent by yb.master.MasterBackup.RestoreSnapshot() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterBackup.RestoreSnapshot() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterBackup_RestoreSnapshot,

  "Bytes received in response to yb.master.MasterBackup.RestoreSnapshot() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterBackup.RestoreSnapshot() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterBackup_DeleteSnapshot,

  "Bytes sent by yb.master.MasterBackup.DeleteSnapshot() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterBackup.DeleteSnapshot() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterBackup_DeleteSnapshot,

  "Bytes received in response to yb.master.MasterBackup.DeleteSnapshot() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterBackup.DeleteSnapshot() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterBackup_ImportSnapshotMeta,

  "Bytes sent by yb.master.MasterBackup.ImportSnapshotMeta() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterBackup.ImportSnapshotMeta() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterBackup_ImportSnapshotMeta,

  "Bytes received in response to yb.master.MasterBackup.ImportSnapshotMeta() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterBackup.ImportSnapshotMeta() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterBackup_CreateSnapshotSchedule,

  "Bytes sent by yb.master.MasterBackup.CreateSnapshotSchedule() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterBackup.CreateSnapshotSchedule() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterBackup_CreateSnapshotSchedule,

  "Bytes received in response to yb.master.MasterBackup.CreateSnapshotSchedule() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterBackup.CreateSnapshotSchedule() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterBackup_ListSnapshotSchedules,

  "Bytes sent by yb.master.MasterBackup.ListSnapshotSchedules() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterBackup.ListSnapshotSchedules() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterBackup_ListSnapshotSchedules,

  "Bytes received in response to yb.master.MasterBackup.ListSnapshotSchedules() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterBackup.ListSnapshotSchedules() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_master_MasterBackup_DeleteSnapshotSchedule,

  "Bytes sent by yb.master.MasterBackup.DeleteSnapshotSchedule() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.master.MasterBackup.DeleteSnapshotSchedule() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_master_MasterBackup_DeleteSnapshotSchedule,

  "Bytes received in response to yb.master.MasterBackup.DeleteSnapshotSchedule() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.master.MasterBackup.DeleteSnapshotSchedule() RPC requests");

namespace yb {

namespace master {

namespace {

const std::string kFullMasterBackupName = "yb.master.MasterBackup";

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

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

  result->value[to_underlying(MasterBackupRpcMethodIndexes::kCreateSnapshot)] = {

      METRIC_proxy_request_bytes_yb_master_MasterBackup_CreateSnapshot.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterBackup_CreateSnapshot.Instantiate(entity)

  };

  result->value[to_underlying(MasterBackupRpcMethodIndexes::kListSnapshots)] = {

      METRIC_proxy_request_bytes_yb_master_MasterBackup_ListSnapshots.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterBackup_ListSnapshots.Instantiate(entity)

  };

  result->value[to_underlying(MasterBackupRpcMethodIndexes::kListSnapshotRestorations)] = {

      METRIC_proxy_request_bytes_yb_master_MasterBackup_ListSnapshotRestorations.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterBackup_ListSnapshotRestorations.Instantiate(entity)

  };

  result->value[to_underlying(MasterBackupRpcMethodIndexes::kRestoreSnapshot)] = {

      METRIC_proxy_request_bytes_yb_master_MasterBackup_RestoreSnapshot.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterBackup_RestoreSnapshot.Instantiate(entity)

  };

  result->value[to_underlying(MasterBackupRpcMethodIndexes::kDeleteSnapshot)] = {

      METRIC_proxy_request_bytes_yb_master_MasterBackup_DeleteSnapshot.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterBackup_DeleteSnapshot.Instantiate(entity)

  };

  result->value[to_underlying(MasterBackupRpcMethodIndexes::kImportSnapshotMeta)] = {

      METRIC_proxy_request_bytes_yb_master_MasterBackup_ImportSnapshotMeta.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterBackup_ImportSnapshotMeta.Instantiate(entity)

  };

  result->value[to_underlying(MasterBackupRpcMethodIndexes::kCreateSnapshotSchedule)] = {

      METRIC_proxy_request_bytes_yb_master_MasterBackup_CreateSnapshotSchedule.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterBackup_CreateSnapshotSchedule.Instantiate(entity)

  };

  result->value[to_underlying(MasterBackupRpcMethodIndexes::kListSnapshotSchedules)] = {

      METRIC_proxy_request_bytes_yb_master_MasterBackup_ListSnapshotSchedules.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterBackup_ListSnapshotSchedules.Instantiate(entity)

  };

  result->value[to_underlying(MasterBackupRpcMethodIndexes::kDeleteSnapshotSchedule)] = {

      METRIC_proxy_request_bytes_yb_master_MasterBackup_DeleteSnapshotSchedule.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_master_MasterBackup_DeleteSnapshotSchedule.Instantiate(entity)

  };

  return result;

}

} // namespace

MasterBackupProxy::MasterBackupProxy(

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

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

    const ::yb::MonoDelta& resolve_cache_timeout)

    : ProxyBase(kFullMasterBackupName, &CreateMasterBackupMetrics,

                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status MasterBackupProxy::CreateSnapshot(

    const ::yb::master::CreateSnapshotRequestPB &req, ::yb::master::CreateSnapshotResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "CreateSnapshot");

  return proxy().SyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kCreateSnapshot)), req, resp, controller);

}

void MasterBackupProxy::CreateSnapshotAsync(

    const ::yb::master::CreateSnapshotRequestPB &req, ::yb::master::CreateSnapshotResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "CreateSnapshot");

  proxy().AsyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kCreateSnapshot)), req, resp, controller, std::move(callback));

}

::yb::Status MasterBackupProxy::ListSnapshots(

    const ::yb::master::ListSnapshotsRequestPB &req, ::yb::master::ListSnapshotsResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "ListSnapshots");

  return proxy().SyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kListSnapshots)), req, resp, controller);

}

void MasterBackupProxy::ListSnapshotsAsync(

    const ::yb::master::ListSnapshotsRequestPB &req, ::yb::master::ListSnapshotsResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "ListSnapshots");

  proxy().AsyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kListSnapshots)), req, resp, controller, std::move(callback));

}

::yb::Status MasterBackupProxy::ListSnapshotRestorations(

    const ::yb::master::ListSnapshotRestorationsRequestPB &req, ::yb::master::ListSnapshotRestorationsResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "ListSnapshotRestorations");

  return proxy().SyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kListSnapshotRestorations)), req, resp, controller);

}

void MasterBackupProxy::ListSnapshotRestorationsAsync(

    const ::yb::master::ListSnapshotRestorationsRequestPB &req, ::yb::master::ListSnapshotRestorationsResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "ListSnapshotRestorations");

  proxy().AsyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kListSnapshotRestorations)), req, resp, controller, std::move(callback));

}

::yb::Status MasterBackupProxy::RestoreSnapshot(

    const ::yb::master::RestoreSnapshotRequestPB &req, ::yb::master::RestoreSnapshotResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "RestoreSnapshot");

  return proxy().SyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kRestoreSnapshot)), req, resp, controller);

}

void MasterBackupProxy::RestoreSnapshotAsync(

    const ::yb::master::RestoreSnapshotRequestPB &req, ::yb::master::RestoreSnapshotResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "RestoreSnapshot");

  proxy().AsyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kRestoreSnapshot)), req, resp, controller, std::move(callback));

}

::yb::Status MasterBackupProxy::DeleteSnapshot(

    const ::yb::master::DeleteSnapshotRequestPB &req, ::yb::master::DeleteSnapshotResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "DeleteSnapshot");

  return proxy().SyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kDeleteSnapshot)), req, resp, controller);

}

void MasterBackupProxy::DeleteSnapshotAsync(

    const ::yb::master::DeleteSnapshotRequestPB &req, ::yb::master::DeleteSnapshotResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "DeleteSnapshot");

  proxy().AsyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kDeleteSnapshot)), req, resp, controller, std::move(callback));

}

::yb::Status MasterBackupProxy::ImportSnapshotMeta(

    const ::yb::master::ImportSnapshotMetaRequestPB &req, ::yb::master::ImportSnapshotMetaResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "ImportSnapshotMeta");

  return proxy().SyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kImportSnapshotMeta)), req, resp, controller);

}

void MasterBackupProxy::ImportSnapshotMetaAsync(

    const ::yb::master::ImportSnapshotMetaRequestPB &req, ::yb::master::ImportSnapshotMetaResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "ImportSnapshotMeta");

  proxy().AsyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kImportSnapshotMeta)), req, resp, controller, std::move(callback));

}

::yb::Status MasterBackupProxy::CreateSnapshotSchedule(

    const ::yb::master::CreateSnapshotScheduleRequestPB &req, ::yb::master::CreateSnapshotScheduleResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "CreateSnapshotSchedule");

  return proxy().SyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kCreateSnapshotSchedule)), req, resp, controller);

}

void MasterBackupProxy::CreateSnapshotScheduleAsync(

    const ::yb::master::CreateSnapshotScheduleRequestPB &req, ::yb::master::CreateSnapshotScheduleResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "CreateSnapshotSchedule");

  proxy().AsyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kCreateSnapshotSchedule)), req, resp, controller, std::move(callback));

}

::yb::Status MasterBackupProxy::ListSnapshotSchedules(

    const ::yb::master::ListSnapshotSchedulesRequestPB &req, ::yb::master::ListSnapshotSchedulesResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "ListSnapshotSchedules");

  return proxy().SyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kListSnapshotSchedules)), req, resp, controller);

}

void MasterBackupProxy::ListSnapshotSchedulesAsync(

    const ::yb::master::ListSnapshotSchedulesRequestPB &req, ::yb::master::ListSnapshotSchedulesResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "ListSnapshotSchedules");

  proxy().AsyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kListSnapshotSchedules)), req, resp, controller, std::move(callback));

}

::yb::Status MasterBackupProxy::DeleteSnapshotSchedule(

    const ::yb::master::DeleteSnapshotScheduleRequestPB &req, ::yb::master::DeleteSnapshotScheduleResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "DeleteSnapshotSchedule");

  return proxy().SyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kDeleteSnapshotSchedule)), req, resp, controller);

}

void MasterBackupProxy::DeleteSnapshotScheduleAsync(

    const ::yb::master::DeleteSnapshotScheduleRequestPB &req, ::yb::master::DeleteSnapshotScheduleResponsePB *resp, ::yb::rpc::RpcController *controller,

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

  static ::yb::rpc::RemoteMethod method("yb.master.MasterBackup", "DeleteSnapshotSchedule");

  proxy().AsyncRequest(

      &method, metrics<9>(static_cast<size_t>(MasterBackupRpcMethodIndexes::kDeleteSnapshotSchedule)), req, resp, controller, std::move(callback));

}

} // namespace master

} // namespace yb