YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

// THIS FILE IS AUTOGENERATED FROM yb/server/server_base.proto

#include "yb/server/server_base.pb.h"

#include "yb/server/server_base.service.h"

#include <glog/logging.h>

#include "yb/rpc/inbound_call.h"

#include "yb/rpc/local_call.h"

#include "yb/rpc/remote_method.h"

#include "yb/rpc/rpc_context.h"

#include "yb/rpc/rpc_service.h"

#include "yb/rpc/service_if.h"

#include "yb/util/metrics.h"

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_server_GenericService_SetFlag,

  "Bytes received by yb.server.GenericService.SetFlag() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.server.GenericService.SetFlag() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_server_GenericService_SetFlag,

  "Bytes sent in response to yb.server.GenericService.SetFlag() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.server.GenericService.SetFlag() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_server_GenericService_SetFlag,

  "Microseconds spent handling yb.server.GenericService.SetFlag() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.server.GenericService.SetFlag() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_server_GenericService_GetFlag,

  "Bytes received by yb.server.GenericService.GetFlag() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.server.GenericService.GetFlag() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_server_GenericService_GetFlag,

  "Bytes sent in response to yb.server.GenericService.GetFlag() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.server.GenericService.GetFlag() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_server_GenericService_GetFlag,

  "Microseconds spent handling yb.server.GenericService.GetFlag() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.server.GenericService.GetFlag() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_server_GenericService_RefreshFlags,

  "Bytes received by yb.server.GenericService.RefreshFlags() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.server.GenericService.RefreshFlags() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_server_GenericService_RefreshFlags,

  "Bytes sent in response to yb.server.GenericService.RefreshFlags() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.server.GenericService.RefreshFlags() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_server_GenericService_RefreshFlags,

  "Microseconds spent handling yb.server.GenericService.RefreshFlags() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.server.GenericService.RefreshFlags() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_server_GenericService_FlushCoverage,

  "Bytes received by yb.server.GenericService.FlushCoverage() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.server.GenericService.FlushCoverage() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_server_GenericService_FlushCoverage,

  "Bytes sent in response to yb.server.GenericService.FlushCoverage() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.server.GenericService.FlushCoverage() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_server_GenericService_FlushCoverage,

  "Microseconds spent handling yb.server.GenericService.FlushCoverage() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.server.GenericService.FlushCoverage() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_server_GenericService_ServerClock,

  "Bytes received by yb.server.GenericService.ServerClock() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.server.GenericService.ServerClock() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_server_GenericService_ServerClock,

  "Bytes sent in response to yb.server.GenericService.ServerClock() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.server.GenericService.ServerClock() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_server_GenericService_ServerClock,

  "Microseconds spent handling yb.server.GenericService.ServerClock() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.server.GenericService.ServerClock() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_server_GenericService_GetStatus,

  "Bytes received by yb.server.GenericService.GetStatus() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.server.GenericService.GetStatus() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_server_GenericService_GetStatus,

  "Bytes sent in response to yb.server.GenericService.GetStatus() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.server.GenericService.GetStatus() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_server_GenericService_GetStatus,

  "Microseconds spent handling yb.server.GenericService.GetStatus() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.server.GenericService.GetStatus() RPC requests",

  60000000LU, 2);

METRIC_DEFINE_counter(

  server, service_request_bytes_yb_server_GenericService_Ping,

  "Bytes received by yb.server.GenericService.Ping() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received by yb.server.GenericService.Ping() RPC requests");

METRIC_DEFINE_counter(

  server, service_response_bytes_yb_server_GenericService_Ping,

  "Bytes sent in response to yb.server.GenericService.Ping() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent in response to yb.server.GenericService.Ping() RPC requests");

METRIC_DEFINE_histogram_with_percentiles(

  server, handler_latency_yb_server_GenericService_Ping,

  "Microseconds spent handling yb.server.GenericService.Ping() RPC requests",

  yb::MetricUnit::kMicroseconds,

  "Microseconds spent handling yb.server.GenericService.Ping() RPC requests",

  60000000LU, 2);

namespace yb {

namespace server {

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

  InitMethods(entity);

}

GenericServiceIf::~GenericServiceIf() {

}

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

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

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

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

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

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

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

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

}

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

  auto index = call->method_index();

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

}

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

  return "yb.server.GenericService";

}

std::string GenericServiceIf::static_service_name() {

  return "yb.server.GenericService";

}

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

  methods_[static_cast<size_t>(GenericServiceRpcMethodIndexes::kSetFlag)] = {

    .method = ::yb::rpc::RemoteMethod("yb.server.GenericService", "SetFlag"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::server::SetFlagRequestPB, ::yb::server::SetFlagResponsePB>>(

          std::move(call), [this](const ::yb::server::SetFlagRequestPB* req, ::yb::server::SetFlagResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_server_GenericService_SetFlag.Instantiate(entity),

        METRIC_service_response_bytes_yb_server_GenericService_SetFlag.Instantiate(entity),

        METRIC_handler_latency_yb_server_GenericService_SetFlag.Instantiate(entity))

  };

  methods_[static_cast<size_t>(GenericServiceRpcMethodIndexes::kGetFlag)] = {

    .method = ::yb::rpc::RemoteMethod("yb.server.GenericService", "GetFlag"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::server::GetFlagRequestPB, ::yb::server::GetFlagResponsePB>>(

          std::move(call), [this](const ::yb::server::GetFlagRequestPB* req, ::yb::server::GetFlagResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_server_GenericService_GetFlag.Instantiate(entity),

        METRIC_service_response_bytes_yb_server_GenericService_GetFlag.Instantiate(entity),

        METRIC_handler_latency_yb_server_GenericService_GetFlag.Instantiate(entity))

  };

  methods_[static_cast<size_t>(GenericServiceRpcMethodIndexes::kRefreshFlags)] = {

    .method = ::yb::rpc::RemoteMethod("yb.server.GenericService", "RefreshFlags"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::server::RefreshFlagsRequestPB, ::yb::server::RefreshFlagsResponsePB>>(

          std::move(call), [this](const ::yb::server::RefreshFlagsRequestPB* req, ::yb::server::RefreshFlagsResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_server_GenericService_RefreshFlags.Instantiate(entity),

        METRIC_service_response_bytes_yb_server_GenericService_RefreshFlags.Instantiate(entity),

        METRIC_handler_latency_yb_server_GenericService_RefreshFlags.Instantiate(entity))

  };

  methods_[static_cast<size_t>(GenericServiceRpcMethodIndexes::kFlushCoverage)] = {

    .method = ::yb::rpc::RemoteMethod("yb.server.GenericService", "FlushCoverage"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::server::FlushCoverageRequestPB, ::yb::server::FlushCoverageResponsePB>>(

          std::move(call), [this](const ::yb::server::FlushCoverageRequestPB* req, ::yb::server::FlushCoverageResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_server_GenericService_FlushCoverage.Instantiate(entity),

        METRIC_service_response_bytes_yb_server_GenericService_FlushCoverage.Instantiate(entity),

        METRIC_handler_latency_yb_server_GenericService_FlushCoverage.Instantiate(entity))

  };

  methods_[static_cast<size_t>(GenericServiceRpcMethodIndexes::kServerClock)] = {

    .method = ::yb::rpc::RemoteMethod("yb.server.GenericService", "ServerClock"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::server::ServerClockRequestPB, ::yb::server::ServerClockResponsePB>>(

          std::move(call), [this](const ::yb::server::ServerClockRequestPB* req, ::yb::server::ServerClockResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_server_GenericService_ServerClock.Instantiate(entity),

        METRIC_service_response_bytes_yb_server_GenericService_ServerClock.Instantiate(entity),

        METRIC_handler_latency_yb_server_GenericService_ServerClock.Instantiate(entity))

  };

  methods_[static_cast<size_t>(GenericServiceRpcMethodIndexes::kGetStatus)] = {

    .method = ::yb::rpc::RemoteMethod("yb.server.GenericService", "GetStatus"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::server::GetStatusRequestPB, ::yb::server::GetStatusResponsePB>>(

          std::move(call), [this](const ::yb::server::GetStatusRequestPB* req, ::yb::server::GetStatusResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_server_GenericService_GetStatus.Instantiate(entity),

        METRIC_service_response_bytes_yb_server_GenericService_GetStatus.Instantiate(entity),

        METRIC_handler_latency_yb_server_GenericService_GetStatus.Instantiate(entity))

  };

  methods_[static_cast<size_t>(GenericServiceRpcMethodIndexes::kPing)] = {

    .method = ::yb::rpc::RemoteMethod("yb.server.GenericService", "Ping"),

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

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

      ::yb::rpc::HandleCall<::yb::rpc::RpcCallPBParamsImpl<::yb::server::PingRequestPB, ::yb::server::PingResponsePB>>(

          std::move(call), [this](const ::yb::server::PingRequestPB* req, ::yb::server::PingResponsePB* resp, ::yb::rpc::RpcContext rpc_context) {

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

      });

    },

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

        METRIC_service_request_bytes_yb_server_GenericService_Ping.Instantiate(entity),

        METRIC_service_response_bytes_yb_server_GenericService_Ping.Instantiate(entity),

        METRIC_handler_latency_yb_server_GenericService_Ping.Instantiate(entity))

  };

}

} // namespace server

} // namespace yb