/Users/deen/code/yugabyte-db/build/debugcov-clang-dynamic-arm64-ninja/src/yb/server/server_base.proxy.cc

Source (jump to first uncovered line)
// THIS FILE IS AUTOGENERATED FROM yb/server/server_base.proto

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

#include "yb/server/server_base.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_server_GenericService_SetFlag,
  "Bytes sent by yb.server.GenericService.SetFlag() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.server.GenericService.SetFlag() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_server_GenericService_SetFlag,
  "Bytes received in response to yb.server.GenericService.SetFlag() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.server.GenericService.SetFlag() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_server_GenericService_GetFlag,
  "Bytes sent by yb.server.GenericService.GetFlag() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.server.GenericService.GetFlag() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_server_GenericService_GetFlag,
  "Bytes received in response to yb.server.GenericService.GetFlag() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.server.GenericService.GetFlag() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_server_GenericService_RefreshFlags,
  "Bytes sent by yb.server.GenericService.RefreshFlags() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.server.GenericService.RefreshFlags() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_server_GenericService_RefreshFlags,
  "Bytes received in response to yb.server.GenericService.RefreshFlags() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.server.GenericService.RefreshFlags() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_server_GenericService_FlushCoverage,
  "Bytes sent by yb.server.GenericService.FlushCoverage() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.server.GenericService.FlushCoverage() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_server_GenericService_FlushCoverage,
  "Bytes received in response to yb.server.GenericService.FlushCoverage() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.server.GenericService.FlushCoverage() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_server_GenericService_ServerClock,
  "Bytes sent by yb.server.GenericService.ServerClock() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.server.GenericService.ServerClock() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_server_GenericService_ServerClock,
  "Bytes received in response to yb.server.GenericService.ServerClock() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.server.GenericService.ServerClock() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_server_GenericService_GetStatus,
  "Bytes sent by yb.server.GenericService.GetStatus() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.server.GenericService.GetStatus() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_server_GenericService_GetStatus,
  "Bytes received in response to yb.server.GenericService.GetStatus() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.server.GenericService.GetStatus() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_request_bytes_yb_server_GenericService_Ping,
  "Bytes sent by yb.server.GenericService.Ping() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes sent by yb.server.GenericService.Ping() RPC requests");

METRIC_DEFINE_counter(
  server, proxy_response_bytes_yb_server_GenericService_Ping,
  "Bytes received in response to yb.server.GenericService.Ping() RPC requests",
  yb::MetricUnit::kBytes,
  "Bytes received in response to yb.server.GenericService.Ping() RPC requests");

namespace yb {
namespace server {


namespace {

const std::string kFullGenericServiceName = "yb.server.GenericService";

::yb::rpc::ProxyMetricsPtr CreateGenericServiceMetrics(const scoped_refptr<MetricEntity>& entity) {
  auto result = std::make_shared<::yb::rpc::ProxyMetricsImpl<7>>();
  result->value[to_underlying(GenericServiceRpcMethodIndexes::kSetFlag)] = {
      METRIC_proxy_request_bytes_yb_server_GenericService_SetFlag.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_server_GenericService_SetFlag.Instantiate(entity)
  };

  result->value[to_underlying(GenericServiceRpcMethodIndexes::kGetFlag)] = {
      METRIC_proxy_request_bytes_yb_server_GenericService_GetFlag.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_server_GenericService_GetFlag.Instantiate(entity)
  };

  result->value[to_underlying(GenericServiceRpcMethodIndexes::kRefreshFlags)] = {
      METRIC_proxy_request_bytes_yb_server_GenericService_RefreshFlags.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_server_GenericService_RefreshFlags.Instantiate(entity)
  };

  result->value[to_underlying(GenericServiceRpcMethodIndexes::kFlushCoverage)] = {
      METRIC_proxy_request_bytes_yb_server_GenericService_FlushCoverage.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_server_GenericService_FlushCoverage.Instantiate(entity)
  };

  result->value[to_underlying(GenericServiceRpcMethodIndexes::kServerClock)] = {
      METRIC_proxy_request_bytes_yb_server_GenericService_ServerClock.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_server_GenericService_ServerClock.Instantiate(entity)
  };

  result->value[to_underlying(GenericServiceRpcMethodIndexes::kGetStatus)] = {
      METRIC_proxy_request_bytes_yb_server_GenericService_GetStatus.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_server_GenericService_GetStatus.Instantiate(entity)
  };

  result->value[to_underlying(GenericServiceRpcMethodIndexes::kPing)] = {
      METRIC_proxy_request_bytes_yb_server_GenericService_Ping.Instantiate(entity),
      METRIC_proxy_response_bytes_yb_server_GenericService_Ping.Instantiate(entity)
  };

  return result;
}


} // namespace

GenericServiceProxy::GenericServiceProxy(
    ::yb::rpc::ProxyCache* cache, const ::yb::HostPort& remote,
    const ::yb::rpc::Protocol* protocol,
    const ::yb::MonoDelta& resolve_cache_timeout)
    : ProxyBase(kFullGenericServiceName, &CreateGenericServiceMetrics,
                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status GenericServiceProxy::SetFlag(
    const ::yb::server::SetFlagRequestPB &req, ::yb::server::SetFlagResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "SetFlag");
  return proxy().SyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kSetFlag)), req, resp, controller);
}

void GenericServiceProxy::SetFlagAsync(
    const ::yb::server::SetFlagRequestPB &req, ::yb::server::SetFlagResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "SetFlag");
  proxy().AsyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kSetFlag)), req, resp, controller, std::move(callback));
}

::yb::Status GenericServiceProxy::GetFlag(
    const ::yb::server::GetFlagRequestPB &req, ::yb::server::GetFlagResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "GetFlag");
  return proxy().SyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kGetFlag)), req, resp, controller);
}

void GenericServiceProxy::GetFlagAsync(
    const ::yb::server::GetFlagRequestPB &req, ::yb::server::GetFlagResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "GetFlag");
  proxy().AsyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kGetFlag)), req, resp, controller, std::move(callback));
}

::yb::Status GenericServiceProxy::RefreshFlags(
    const ::yb::server::RefreshFlagsRequestPB &req, ::yb::server::RefreshFlagsResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "RefreshFlags");
  return proxy().SyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kRefreshFlags)), req, resp, controller);
}

void GenericServiceProxy::RefreshFlagsAsync(
    const ::yb::server::RefreshFlagsRequestPB &req, ::yb::server::RefreshFlagsResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "RefreshFlags");
  proxy().AsyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kRefreshFlags)), req, resp, controller, std::move(callback));
}

::yb::Status GenericServiceProxy::FlushCoverage(
    const ::yb::server::FlushCoverageRequestPB &req, ::yb::server::FlushCoverageResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "FlushCoverage");
  return proxy().SyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kFlushCoverage)), req, resp, controller);
}

void GenericServiceProxy::FlushCoverageAsync(
    const ::yb::server::FlushCoverageRequestPB &req, ::yb::server::FlushCoverageResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "FlushCoverage");
  proxy().AsyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kFlushCoverage)), req, resp, controller, std::move(callback));
}

::yb::Status GenericServiceProxy::ServerClock(
    const ::yb::server::ServerClockRequestPB &req, ::yb::server::ServerClockResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "ServerClock");
  return proxy().SyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kServerClock)), req, resp, controller);
}

void GenericServiceProxy::ServerClockAsync(
    const ::yb::server::ServerClockRequestPB &req, ::yb::server::ServerClockResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "ServerClock");
  proxy().AsyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kServerClock)), req, resp, controller, std::move(callback));
}

::yb::Status GenericServiceProxy::GetStatus(
    const ::yb::server::GetStatusRequestPB &req, ::yb::server::GetStatusResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "GetStatus");
  return proxy().SyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kGetStatus)), req, resp, controller);
}

void GenericServiceProxy::GetStatusAsync(
    const ::yb::server::GetStatusRequestPB &req, ::yb::server::GetStatusResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "GetStatus");
  proxy().AsyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kGetStatus)), req, resp, controller, std::move(callback));
}

::yb::Status GenericServiceProxy::Ping(
    const ::yb::server::PingRequestPB &req, ::yb::server::PingResponsePB *resp, ::yb::rpc::RpcController *controller) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "Ping");
  return proxy().SyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kPing)), req, resp, controller);
}

void GenericServiceProxy::PingAsync(
    const ::yb::server::PingRequestPB &req, ::yb::server::PingResponsePB *resp, ::yb::rpc::RpcController *controller,
    ::yb::rpc::ResponseCallback callback) const {
  static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "Ping");
  proxy().AsyncRequest(
      &method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kPing)), req, resp, controller, std::move(callback));
}

} // namespace server
} // namespace yb

YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

Coverage Report

Created: 2022-03-09 17:30

Line	Count	Source (jump to first uncovered line)
1		// THIS FILE IS AUTOGENERATED FROM yb/server/server_base.proto
2
3		#include "yb/server/server_base.proxy.h"
4
5		#include "yb/server/server_base.service.h"
6
7		#include "yb/rpc/proxy.h"
8		#include "yb/rpc/outbound_call.h"
9		#include "yb/util/metrics.h"
10		#include "yb/util/net/sockaddr.h"
11
12		METRIC_DEFINE_counter(
13		server, proxy_request_bytes_yb_server_GenericService_SetFlag,
14		"Bytes sent by yb.server.GenericService.SetFlag() RPC requests",
15		yb::MetricUnit::kBytes,
16		"Bytes sent by yb.server.GenericService.SetFlag() RPC requests");
17
18		METRIC_DEFINE_counter(
19		server, proxy_response_bytes_yb_server_GenericService_SetFlag,
20		"Bytes received in response to yb.server.GenericService.SetFlag() RPC requests",
21		yb::MetricUnit::kBytes,
22		"Bytes received in response to yb.server.GenericService.SetFlag() RPC requests");
23
24		METRIC_DEFINE_counter(
25		server, proxy_request_bytes_yb_server_GenericService_GetFlag,
26		"Bytes sent by yb.server.GenericService.GetFlag() RPC requests",
27		yb::MetricUnit::kBytes,
28		"Bytes sent by yb.server.GenericService.GetFlag() RPC requests");
29
30		METRIC_DEFINE_counter(
31		server, proxy_response_bytes_yb_server_GenericService_GetFlag,
32		"Bytes received in response to yb.server.GenericService.GetFlag() RPC requests",
33		yb::MetricUnit::kBytes,
34		"Bytes received in response to yb.server.GenericService.GetFlag() RPC requests");
35
36		METRIC_DEFINE_counter(
37		server, proxy_request_bytes_yb_server_GenericService_RefreshFlags,
38		"Bytes sent by yb.server.GenericService.RefreshFlags() RPC requests",
39		yb::MetricUnit::kBytes,
40		"Bytes sent by yb.server.GenericService.RefreshFlags() RPC requests");
41
42		METRIC_DEFINE_counter(
43		server, proxy_response_bytes_yb_server_GenericService_RefreshFlags,
44		"Bytes received in response to yb.server.GenericService.RefreshFlags() RPC requests",
45		yb::MetricUnit::kBytes,
46		"Bytes received in response to yb.server.GenericService.RefreshFlags() RPC requests");
47
48		METRIC_DEFINE_counter(
49		server, proxy_request_bytes_yb_server_GenericService_FlushCoverage,
50		"Bytes sent by yb.server.GenericService.FlushCoverage() RPC requests",
51		yb::MetricUnit::kBytes,
52		"Bytes sent by yb.server.GenericService.FlushCoverage() RPC requests");
53
54		METRIC_DEFINE_counter(
55		server, proxy_response_bytes_yb_server_GenericService_FlushCoverage,
56		"Bytes received in response to yb.server.GenericService.FlushCoverage() RPC requests",
57		yb::MetricUnit::kBytes,
58		"Bytes received in response to yb.server.GenericService.FlushCoverage() RPC requests");
59
60		METRIC_DEFINE_counter(
61		server, proxy_request_bytes_yb_server_GenericService_ServerClock,
62		"Bytes sent by yb.server.GenericService.ServerClock() RPC requests",
63		yb::MetricUnit::kBytes,
64		"Bytes sent by yb.server.GenericService.ServerClock() RPC requests");
65
66		METRIC_DEFINE_counter(
67		server, proxy_response_bytes_yb_server_GenericService_ServerClock,
68		"Bytes received in response to yb.server.GenericService.ServerClock() RPC requests",
69		yb::MetricUnit::kBytes,
70		"Bytes received in response to yb.server.GenericService.ServerClock() RPC requests");
71
72		METRIC_DEFINE_counter(
73		server, proxy_request_bytes_yb_server_GenericService_GetStatus,
74		"Bytes sent by yb.server.GenericService.GetStatus() RPC requests",
75		yb::MetricUnit::kBytes,
76		"Bytes sent by yb.server.GenericService.GetStatus() RPC requests");
77
78		METRIC_DEFINE_counter(
79		server, proxy_response_bytes_yb_server_GenericService_GetStatus,
80		"Bytes received in response to yb.server.GenericService.GetStatus() RPC requests",
81		yb::MetricUnit::kBytes,
82		"Bytes received in response to yb.server.GenericService.GetStatus() RPC requests");
83
84		METRIC_DEFINE_counter(
85		server, proxy_request_bytes_yb_server_GenericService_Ping,
86		"Bytes sent by yb.server.GenericService.Ping() RPC requests",
87		yb::MetricUnit::kBytes,
88		"Bytes sent by yb.server.GenericService.Ping() RPC requests");
89
90		METRIC_DEFINE_counter(
91		server, proxy_response_bytes_yb_server_GenericService_Ping,
92		"Bytes received in response to yb.server.GenericService.Ping() RPC requests",
93		yb::MetricUnit::kBytes,
94		"Bytes received in response to yb.server.GenericService.Ping() RPC requests");
95
96		namespace yb {
97		namespace server {
98
99
100		namespace {
101
102		const std::string kFullGenericServiceName = "yb.server.GenericService";
103
104	5.50k	::yb::rpc::ProxyMetricsPtr CreateGenericServiceMetrics(const scoped_refptr<MetricEntity>& entity) {
105	5.50k	auto result = std::make_shared<::yb::rpc::ProxyMetricsImpl<7>>();
106	5.50k	result->value[to_underlying(GenericServiceRpcMethodIndexes::kSetFlag)] = {
107	5.50k	METRIC_proxy_request_bytes_yb_server_GenericService_SetFlag.Instantiate(entity),
108	5.50k	METRIC_proxy_response_bytes_yb_server_GenericService_SetFlag.Instantiate(entity)
109	5.50k	};
110
111	5.50k	result->value[to_underlying(GenericServiceRpcMethodIndexes::kGetFlag)] = {
112	5.50k	METRIC_proxy_request_bytes_yb_server_GenericService_GetFlag.Instantiate(entity),
113	5.50k	METRIC_proxy_response_bytes_yb_server_GenericService_GetFlag.Instantiate(entity)
114	5.50k	};
115
116	5.50k	result->value[to_underlying(GenericServiceRpcMethodIndexes::kRefreshFlags)] = {
117	5.50k	METRIC_proxy_request_bytes_yb_server_GenericService_RefreshFlags.Instantiate(entity),
118	5.50k	METRIC_proxy_response_bytes_yb_server_GenericService_RefreshFlags.Instantiate(entity)
119	5.50k	};
120
121	5.50k	result->value[to_underlying(GenericServiceRpcMethodIndexes::kFlushCoverage)] = {
122	5.50k	METRIC_proxy_request_bytes_yb_server_GenericService_FlushCoverage.Instantiate(entity),
123	5.50k	METRIC_proxy_response_bytes_yb_server_GenericService_FlushCoverage.Instantiate(entity)
124	5.50k	};
125
126	5.50k	result->value[to_underlying(GenericServiceRpcMethodIndexes::kServerClock)] = {
127	5.50k	METRIC_proxy_request_bytes_yb_server_GenericService_ServerClock.Instantiate(entity),
128	5.50k	METRIC_proxy_response_bytes_yb_server_GenericService_ServerClock.Instantiate(entity)
129	5.50k	};
130
131	5.50k	result->value[to_underlying(GenericServiceRpcMethodIndexes::kGetStatus)] = {
132	5.50k	METRIC_proxy_request_bytes_yb_server_GenericService_GetStatus.Instantiate(entity),
133	5.50k	METRIC_proxy_response_bytes_yb_server_GenericService_GetStatus.Instantiate(entity)
134	5.50k	};
135
136	5.50k	result->value[to_underlying(GenericServiceRpcMethodIndexes::kPing)] = {
137	5.50k	METRIC_proxy_request_bytes_yb_server_GenericService_Ping.Instantiate(entity),
138	5.50k	METRIC_proxy_response_bytes_yb_server_GenericService_Ping.Instantiate(entity)
139	5.50k	};
140
141	5.50k	return result;
142	5.50k	}
143
144
145		} // namespace
146
147		GenericServiceProxy::GenericServiceProxy(
148		::yb::rpc::ProxyCache* cache, const ::yb::HostPort& remote,
149		const ::yb::rpc::Protocol* protocol,
150		const ::yb::MonoDelta& resolve_cache_timeout)
151		: ProxyBase(kFullGenericServiceName, &CreateGenericServiceMetrics,
152	11.2k	cache, remote, protocol, resolve_cache_timeout) {}
153
154		::yb::Status GenericServiceProxy::SetFlag(
155	103	const ::yb::server::SetFlagRequestPB &req, ::yb::server::SetFlagResponsePB resp, ::yb::rpc::RpcController controller) const {
156	103	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "SetFlag");
157	103	return proxy().SyncRequest(
158	103	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kSetFlag)), req, resp, controller);
159	103	}
160
161		void GenericServiceProxy::SetFlagAsync(
162		const ::yb::server::SetFlagRequestPB &req, ::yb::server::SetFlagResponsePB resp, ::yb::rpc::RpcController controller,
163	0	::yb::rpc::ResponseCallback callback) const {
164	0	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "SetFlag");
165	0	proxy().AsyncRequest(
166	0	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kSetFlag)), req, resp, controller, std::move(callback));
167	0	}
168
169		::yb::Status GenericServiceProxy::GetFlag(
170	25	const ::yb::server::GetFlagRequestPB &req, ::yb::server::GetFlagResponsePB resp, ::yb::rpc::RpcController controller) const {
171	25	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "GetFlag");
172	25	return proxy().SyncRequest(
173	25	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kGetFlag)), req, resp, controller);
174	25	}
175
176		void GenericServiceProxy::GetFlagAsync(
177		const ::yb::server::GetFlagRequestPB &req, ::yb::server::GetFlagResponsePB resp, ::yb::rpc::RpcController controller,
178	0	::yb::rpc::ResponseCallback callback) const {
179	0	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "GetFlag");
180	0	proxy().AsyncRequest(
181	0	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kGetFlag)), req, resp, controller, std::move(callback));
182	0	}
183
184		::yb::Status GenericServiceProxy::RefreshFlags(
185	0	const ::yb::server::RefreshFlagsRequestPB &req, ::yb::server::RefreshFlagsResponsePB resp, ::yb::rpc::RpcController controller) const {
186	0	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "RefreshFlags");
187	0	return proxy().SyncRequest(
188	0	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kRefreshFlags)), req, resp, controller);
189	0	}
190
191		void GenericServiceProxy::RefreshFlagsAsync(
192		const ::yb::server::RefreshFlagsRequestPB &req, ::yb::server::RefreshFlagsResponsePB resp, ::yb::rpc::RpcController controller,
193	0	::yb::rpc::ResponseCallback callback) const {
194	0	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "RefreshFlags");
195	0	proxy().AsyncRequest(
196	0	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kRefreshFlags)), req, resp, controller, std::move(callback));
197	0	}
198
199		::yb::Status GenericServiceProxy::FlushCoverage(
200	0	const ::yb::server::FlushCoverageRequestPB &req, ::yb::server::FlushCoverageResponsePB resp, ::yb::rpc::RpcController controller) const {
201	0	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "FlushCoverage");
202	0	return proxy().SyncRequest(
203	0	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kFlushCoverage)), req, resp, controller);
204	0	}
205
206		void GenericServiceProxy::FlushCoverageAsync(
207		const ::yb::server::FlushCoverageRequestPB &req, ::yb::server::FlushCoverageResponsePB resp, ::yb::rpc::RpcController controller,
208	0	::yb::rpc::ResponseCallback callback) const {
209	0	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "FlushCoverage");
210	0	proxy().AsyncRequest(
211	0	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kFlushCoverage)), req, resp, controller, std::move(callback));
212	0	}
213
214		::yb::Status GenericServiceProxy::ServerClock(
215	1	const ::yb::server::ServerClockRequestPB &req, ::yb::server::ServerClockResponsePB resp, ::yb::rpc::RpcController controller) const {
216	1	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "ServerClock");
217	1	return proxy().SyncRequest(
218	1	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kServerClock)), req, resp, controller);
219	1	}
220
221		void GenericServiceProxy::ServerClockAsync(
222		const ::yb::server::ServerClockRequestPB &req, ::yb::server::ServerClockResponsePB resp, ::yb::rpc::RpcController controller,
223	0	::yb::rpc::ResponseCallback callback) const {
224	0	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "ServerClock");
225	0	proxy().AsyncRequest(
226	0	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kServerClock)), req, resp, controller, std::move(callback));
227	0	}
228
229		::yb::Status GenericServiceProxy::GetStatus(
230	1	const ::yb::server::GetStatusRequestPB &req, ::yb::server::GetStatusResponsePB resp, ::yb::rpc::RpcController controller) const {
231	1	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "GetStatus");
232	1	return proxy().SyncRequest(
233	1	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kGetStatus)), req, resp, controller);
234	1	}
235
236		void GenericServiceProxy::GetStatusAsync(
237		const ::yb::server::GetStatusRequestPB &req, ::yb::server::GetStatusResponsePB resp, ::yb::rpc::RpcController controller,
238	0	::yb::rpc::ResponseCallback callback) const {
239	0	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "GetStatus");
240	0	proxy().AsyncRequest(
241	0	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kGetStatus)), req, resp, controller, std::move(callback));
242	0	}
243
244		::yb::Status GenericServiceProxy::Ping(
245	11.8k	const ::yb::server::PingRequestPB &req, ::yb::server::PingResponsePB resp, ::yb::rpc::RpcController controller) const {
246	11.8k	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "Ping");
247	11.8k	return proxy().SyncRequest(
248	11.8k	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kPing)), req, resp, controller);
249	11.8k	}
250
251		void GenericServiceProxy::PingAsync(
252		const ::yb::server::PingRequestPB &req, ::yb::server::PingResponsePB resp, ::yb::rpc::RpcController controller,
253	0	::yb::rpc::ResponseCallback callback) const {
254	0	static ::yb::rpc::RemoteMethod method("yb.server.GenericService", "Ping");
255	0	proxy().AsyncRequest(
256	0	&method, metrics<7>(static_cast<size_t>(GenericServiceRpcMethodIndexes::kPing)), req, resp, controller, std::move(callback));
257	0	}
258
259		} // namespace server
260		} // namespace yb