1#![allow(unknown_lints)]
6#![allow(clippy::all)]
7#![allow(box_pointers)]
8#![allow(dead_code)]
9#![allow(missing_docs)]
10#![allow(non_camel_case_types)]
11#![allow(non_snake_case)]
12#![allow(non_upper_case_globals)]
13#![allow(trivial_casts)]
14#![allow(unsafe_code)]
15#![allow(unused_imports)]
16#![allow(unused_results)]
17
18const METHOD_BENCHMARK_SERVICE_UNARY_CALL: ::grpcio::Method<
19 super::messages::SimpleRequest,
20 super::messages::SimpleResponse,
21> = ::grpcio::Method {
22 ty: ::grpcio::MethodType::Unary,
23 name: "/grpc.testing.BenchmarkService/UnaryCall",
24 req_mar: ::grpcio::Marshaller {
25 ser: ::grpcio::pb_ser,
26 de: ::grpcio::pb_de,
27 },
28 resp_mar: ::grpcio::Marshaller {
29 ser: ::grpcio::pb_ser,
30 de: ::grpcio::pb_de,
31 },
32};
33
34const METHOD_BENCHMARK_SERVICE_STREAMING_CALL: ::grpcio::Method<
35 super::messages::SimpleRequest,
36 super::messages::SimpleResponse,
37> = ::grpcio::Method {
38 ty: ::grpcio::MethodType::Duplex,
39 name: "/grpc.testing.BenchmarkService/StreamingCall",
40 req_mar: ::grpcio::Marshaller {
41 ser: ::grpcio::pb_ser,
42 de: ::grpcio::pb_de,
43 },
44 resp_mar: ::grpcio::Marshaller {
45 ser: ::grpcio::pb_ser,
46 de: ::grpcio::pb_de,
47 },
48};
49
50const METHOD_BENCHMARK_SERVICE_STREAMING_FROM_CLIENT: ::grpcio::Method<
51 super::messages::SimpleRequest,
52 super::messages::SimpleResponse,
53> = ::grpcio::Method {
54 ty: ::grpcio::MethodType::ClientStreaming,
55 name: "/grpc.testing.BenchmarkService/StreamingFromClient",
56 req_mar: ::grpcio::Marshaller {
57 ser: ::grpcio::pb_ser,
58 de: ::grpcio::pb_de,
59 },
60 resp_mar: ::grpcio::Marshaller {
61 ser: ::grpcio::pb_ser,
62 de: ::grpcio::pb_de,
63 },
64};
65
66const METHOD_BENCHMARK_SERVICE_STREAMING_FROM_SERVER: ::grpcio::Method<
67 super::messages::SimpleRequest,
68 super::messages::SimpleResponse,
69> = ::grpcio::Method {
70 ty: ::grpcio::MethodType::ServerStreaming,
71 name: "/grpc.testing.BenchmarkService/StreamingFromServer",
72 req_mar: ::grpcio::Marshaller {
73 ser: ::grpcio::pb_ser,
74 de: ::grpcio::pb_de,
75 },
76 resp_mar: ::grpcio::Marshaller {
77 ser: ::grpcio::pb_ser,
78 de: ::grpcio::pb_de,
79 },
80};
81
82const METHOD_BENCHMARK_SERVICE_STREAMING_BOTH_WAYS: ::grpcio::Method<
83 super::messages::SimpleRequest,
84 super::messages::SimpleResponse,
85> = ::grpcio::Method {
86 ty: ::grpcio::MethodType::Duplex,
87 name: "/grpc.testing.BenchmarkService/StreamingBothWays",
88 req_mar: ::grpcio::Marshaller {
89 ser: ::grpcio::pb_ser,
90 de: ::grpcio::pb_de,
91 },
92 resp_mar: ::grpcio::Marshaller {
93 ser: ::grpcio::pb_ser,
94 de: ::grpcio::pb_de,
95 },
96};
97
98#[derive(Clone)]
99pub struct BenchmarkServiceClient {
100 pub client: ::grpcio::Client,
101}
102
103impl BenchmarkServiceClient {
104 pub fn new(channel: ::grpcio::Channel) -> Self {
105 BenchmarkServiceClient {
106 client: ::grpcio::Client::new(channel),
107 }
108 }
109
110 pub fn unary_call_opt(
111 &self,
112 req: &super::messages::SimpleRequest,
113 opt: ::grpcio::CallOption,
114 ) -> ::grpcio::Result<super::messages::SimpleResponse> {
115 self.client
116 .unary_call(&METHOD_BENCHMARK_SERVICE_UNARY_CALL, req, opt)
117 }
118
119 pub fn unary_call(
120 &self,
121 req: &super::messages::SimpleRequest,
122 ) -> ::grpcio::Result<super::messages::SimpleResponse> {
123 self.unary_call_opt(req, ::grpcio::CallOption::default())
124 }
125
126 pub fn unary_call_async_opt(
127 &self,
128 req: &super::messages::SimpleRequest,
129 opt: ::grpcio::CallOption,
130 ) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver<super::messages::SimpleResponse>> {
131 self.client
132 .unary_call_async(&METHOD_BENCHMARK_SERVICE_UNARY_CALL, req, opt)
133 }
134
135 pub fn unary_call_async(
136 &self,
137 req: &super::messages::SimpleRequest,
138 ) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver<super::messages::SimpleResponse>> {
139 self.unary_call_async_opt(req, ::grpcio::CallOption::default())
140 }
141
142 pub fn streaming_call_opt(
143 &self,
144 opt: ::grpcio::CallOption,
145 ) -> ::grpcio::Result<(
146 ::grpcio::ClientDuplexSender<super::messages::SimpleRequest>,
147 ::grpcio::ClientDuplexReceiver<super::messages::SimpleResponse>,
148 )> {
149 self.client
150 .duplex_streaming(&METHOD_BENCHMARK_SERVICE_STREAMING_CALL, opt)
151 }
152
153 pub fn streaming_call(
154 &self,
155 ) -> ::grpcio::Result<(
156 ::grpcio::ClientDuplexSender<super::messages::SimpleRequest>,
157 ::grpcio::ClientDuplexReceiver<super::messages::SimpleResponse>,
158 )> {
159 self.streaming_call_opt(::grpcio::CallOption::default())
160 }
161
162 pub fn streaming_from_client_opt(
163 &self,
164 opt: ::grpcio::CallOption,
165 ) -> ::grpcio::Result<(
166 ::grpcio::ClientCStreamSender<super::messages::SimpleRequest>,
167 ::grpcio::ClientCStreamReceiver<super::messages::SimpleResponse>,
168 )> {
169 self.client
170 .client_streaming(&METHOD_BENCHMARK_SERVICE_STREAMING_FROM_CLIENT, opt)
171 }
172
173 pub fn streaming_from_client(
174 &self,
175 ) -> ::grpcio::Result<(
176 ::grpcio::ClientCStreamSender<super::messages::SimpleRequest>,
177 ::grpcio::ClientCStreamReceiver<super::messages::SimpleResponse>,
178 )> {
179 self.streaming_from_client_opt(::grpcio::CallOption::default())
180 }
181
182 pub fn streaming_from_server_opt(
183 &self,
184 req: &super::messages::SimpleRequest,
185 opt: ::grpcio::CallOption,
186 ) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver<super::messages::SimpleResponse>> {
187 self.client
188 .server_streaming(&METHOD_BENCHMARK_SERVICE_STREAMING_FROM_SERVER, req, opt)
189 }
190
191 pub fn streaming_from_server(
192 &self,
193 req: &super::messages::SimpleRequest,
194 ) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver<super::messages::SimpleResponse>> {
195 self.streaming_from_server_opt(req, ::grpcio::CallOption::default())
196 }
197
198 pub fn streaming_both_ways_opt(
199 &self,
200 opt: ::grpcio::CallOption,
201 ) -> ::grpcio::Result<(
202 ::grpcio::ClientDuplexSender<super::messages::SimpleRequest>,
203 ::grpcio::ClientDuplexReceiver<super::messages::SimpleResponse>,
204 )> {
205 self.client
206 .duplex_streaming(&METHOD_BENCHMARK_SERVICE_STREAMING_BOTH_WAYS, opt)
207 }
208
209 pub fn streaming_both_ways(
210 &self,
211 ) -> ::grpcio::Result<(
212 ::grpcio::ClientDuplexSender<super::messages::SimpleRequest>,
213 ::grpcio::ClientDuplexReceiver<super::messages::SimpleResponse>,
214 )> {
215 self.streaming_both_ways_opt(::grpcio::CallOption::default())
216 }
217 pub fn spawn<F>(&self, f: F)
218 where
219 F: ::std::future::Future<Output = ()> + Send + 'static,
220 {
221 self.client.spawn(f)
222 }
223}
224
225pub trait BenchmarkService {
226 fn unary_call(
227 &mut self,
228 ctx: ::grpcio::RpcContext,
229 _req: super::messages::SimpleRequest,
230 sink: ::grpcio::UnarySink<super::messages::SimpleResponse>,
231 ) {
232 grpcio::unimplemented_call!(ctx, sink)
233 }
234 fn streaming_call(
235 &mut self,
236 ctx: ::grpcio::RpcContext,
237 _stream: ::grpcio::RequestStream<super::messages::SimpleRequest>,
238 sink: ::grpcio::DuplexSink<super::messages::SimpleResponse>,
239 ) {
240 grpcio::unimplemented_call!(ctx, sink)
241 }
242 fn streaming_from_client(
243 &mut self,
244 ctx: ::grpcio::RpcContext,
245 _stream: ::grpcio::RequestStream<super::messages::SimpleRequest>,
246 sink: ::grpcio::ClientStreamingSink<super::messages::SimpleResponse>,
247 ) {
248 grpcio::unimplemented_call!(ctx, sink)
249 }
250 fn streaming_from_server(
251 &mut self,
252 ctx: ::grpcio::RpcContext,
253 _req: super::messages::SimpleRequest,
254 sink: ::grpcio::ServerStreamingSink<super::messages::SimpleResponse>,
255 ) {
256 grpcio::unimplemented_call!(ctx, sink)
257 }
258 fn streaming_both_ways(
259 &mut self,
260 ctx: ::grpcio::RpcContext,
261 _stream: ::grpcio::RequestStream<super::messages::SimpleRequest>,
262 sink: ::grpcio::DuplexSink<super::messages::SimpleResponse>,
263 ) {
264 grpcio::unimplemented_call!(ctx, sink)
265 }
266}
267
268pub fn create_benchmark_service<S: BenchmarkService + Send + Clone + 'static>(
269 s: S,
270) -> ::grpcio::Service {
271 let mut builder = ::grpcio::ServiceBuilder::new();
272 let mut instance = s.clone();
273 builder = builder.add_unary_handler(
274 &METHOD_BENCHMARK_SERVICE_UNARY_CALL,
275 move |ctx, req, resp| instance.unary_call(ctx, req, resp),
276 );
277 let mut instance = s.clone();
278 builder = builder.add_duplex_streaming_handler(
279 &METHOD_BENCHMARK_SERVICE_STREAMING_CALL,
280 move |ctx, req, resp| instance.streaming_call(ctx, req, resp),
281 );
282 let mut instance = s.clone();
283 builder = builder.add_client_streaming_handler(
284 &METHOD_BENCHMARK_SERVICE_STREAMING_FROM_CLIENT,
285 move |ctx, req, resp| instance.streaming_from_client(ctx, req, resp),
286 );
287 let mut instance = s.clone();
288 builder = builder.add_server_streaming_handler(
289 &METHOD_BENCHMARK_SERVICE_STREAMING_FROM_SERVER,
290 move |ctx, req, resp| instance.streaming_from_server(ctx, req, resp),
291 );
292 let mut instance = s;
293 builder = builder.add_duplex_streaming_handler(
294 &METHOD_BENCHMARK_SERVICE_STREAMING_BOTH_WAYS,
295 move |ctx, req, resp| instance.streaming_both_ways(ctx, req, resp),
296 );
297 builder.build()
298}
299
300const METHOD_WORKER_SERVICE_RUN_SERVER: ::grpcio::Method<
301 super::control::ServerArgs,
302 super::control::ServerStatus,
303> = ::grpcio::Method {
304 ty: ::grpcio::MethodType::Duplex,
305 name: "/grpc.testing.WorkerService/RunServer",
306 req_mar: ::grpcio::Marshaller {
307 ser: ::grpcio::pb_ser,
308 de: ::grpcio::pb_de,
309 },
310 resp_mar: ::grpcio::Marshaller {
311 ser: ::grpcio::pb_ser,
312 de: ::grpcio::pb_de,
313 },
314};
315
316const METHOD_WORKER_SERVICE_RUN_CLIENT: ::grpcio::Method<
317 super::control::ClientArgs,
318 super::control::ClientStatus,
319> = ::grpcio::Method {
320 ty: ::grpcio::MethodType::Duplex,
321 name: "/grpc.testing.WorkerService/RunClient",
322 req_mar: ::grpcio::Marshaller {
323 ser: ::grpcio::pb_ser,
324 de: ::grpcio::pb_de,
325 },
326 resp_mar: ::grpcio::Marshaller {
327 ser: ::grpcio::pb_ser,
328 de: ::grpcio::pb_de,
329 },
330};
331
332const METHOD_WORKER_SERVICE_CORE_COUNT: ::grpcio::Method<
333 super::control::CoreRequest,
334 super::control::CoreResponse,
335> = ::grpcio::Method {
336 ty: ::grpcio::MethodType::Unary,
337 name: "/grpc.testing.WorkerService/CoreCount",
338 req_mar: ::grpcio::Marshaller {
339 ser: ::grpcio::pb_ser,
340 de: ::grpcio::pb_de,
341 },
342 resp_mar: ::grpcio::Marshaller {
343 ser: ::grpcio::pb_ser,
344 de: ::grpcio::pb_de,
345 },
346};
347
348const METHOD_WORKER_SERVICE_QUIT_WORKER: ::grpcio::Method<
349 super::control::Void,
350 super::control::Void,
351> = ::grpcio::Method {
352 ty: ::grpcio::MethodType::Unary,
353 name: "/grpc.testing.WorkerService/QuitWorker",
354 req_mar: ::grpcio::Marshaller {
355 ser: ::grpcio::pb_ser,
356 de: ::grpcio::pb_de,
357 },
358 resp_mar: ::grpcio::Marshaller {
359 ser: ::grpcio::pb_ser,
360 de: ::grpcio::pb_de,
361 },
362};
363
364#[derive(Clone)]
365pub struct WorkerServiceClient {
366 pub client: ::grpcio::Client,
367}
368
369impl WorkerServiceClient {
370 pub fn new(channel: ::grpcio::Channel) -> Self {
371 WorkerServiceClient {
372 client: ::grpcio::Client::new(channel),
373 }
374 }
375
376 pub fn run_server_opt(
377 &self,
378 opt: ::grpcio::CallOption,
379 ) -> ::grpcio::Result<(
380 ::grpcio::ClientDuplexSender<super::control::ServerArgs>,
381 ::grpcio::ClientDuplexReceiver<super::control::ServerStatus>,
382 )> {
383 self.client
384 .duplex_streaming(&METHOD_WORKER_SERVICE_RUN_SERVER, opt)
385 }
386
387 pub fn run_server(
388 &self,
389 ) -> ::grpcio::Result<(
390 ::grpcio::ClientDuplexSender<super::control::ServerArgs>,
391 ::grpcio::ClientDuplexReceiver<super::control::ServerStatus>,
392 )> {
393 self.run_server_opt(::grpcio::CallOption::default())
394 }
395
396 pub fn run_client_opt(
397 &self,
398 opt: ::grpcio::CallOption,
399 ) -> ::grpcio::Result<(
400 ::grpcio::ClientDuplexSender<super::control::ClientArgs>,
401 ::grpcio::ClientDuplexReceiver<super::control::ClientStatus>,
402 )> {
403 self.client
404 .duplex_streaming(&METHOD_WORKER_SERVICE_RUN_CLIENT, opt)
405 }
406
407 pub fn run_client(
408 &self,
409 ) -> ::grpcio::Result<(
410 ::grpcio::ClientDuplexSender<super::control::ClientArgs>,
411 ::grpcio::ClientDuplexReceiver<super::control::ClientStatus>,
412 )> {
413 self.run_client_opt(::grpcio::CallOption::default())
414 }
415
416 pub fn core_count_opt(
417 &self,
418 req: &super::control::CoreRequest,
419 opt: ::grpcio::CallOption,
420 ) -> ::grpcio::Result<super::control::CoreResponse> {
421 self.client
422 .unary_call(&METHOD_WORKER_SERVICE_CORE_COUNT, req, opt)
423 }
424
425 pub fn core_count(
426 &self,
427 req: &super::control::CoreRequest,
428 ) -> ::grpcio::Result<super::control::CoreResponse> {
429 self.core_count_opt(req, ::grpcio::CallOption::default())
430 }
431
432 pub fn core_count_async_opt(
433 &self,
434 req: &super::control::CoreRequest,
435 opt: ::grpcio::CallOption,
436 ) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver<super::control::CoreResponse>> {
437 self.client
438 .unary_call_async(&METHOD_WORKER_SERVICE_CORE_COUNT, req, opt)
439 }
440
441 pub fn core_count_async(
442 &self,
443 req: &super::control::CoreRequest,
444 ) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver<super::control::CoreResponse>> {
445 self.core_count_async_opt(req, ::grpcio::CallOption::default())
446 }
447
448 pub fn quit_worker_opt(
449 &self,
450 req: &super::control::Void,
451 opt: ::grpcio::CallOption,
452 ) -> ::grpcio::Result<super::control::Void> {
453 self.client
454 .unary_call(&METHOD_WORKER_SERVICE_QUIT_WORKER, req, opt)
455 }
456
457 pub fn quit_worker(
458 &self,
459 req: &super::control::Void,
460 ) -> ::grpcio::Result<super::control::Void> {
461 self.quit_worker_opt(req, ::grpcio::CallOption::default())
462 }
463
464 pub fn quit_worker_async_opt(
465 &self,
466 req: &super::control::Void,
467 opt: ::grpcio::CallOption,
468 ) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver<super::control::Void>> {
469 self.client
470 .unary_call_async(&METHOD_WORKER_SERVICE_QUIT_WORKER, req, opt)
471 }
472
473 pub fn quit_worker_async(
474 &self,
475 req: &super::control::Void,
476 ) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver<super::control::Void>> {
477 self.quit_worker_async_opt(req, ::grpcio::CallOption::default())
478 }
479 pub fn spawn<F>(&self, f: F)
480 where
481 F: ::std::future::Future<Output = ()> + Send + 'static,
482 {
483 self.client.spawn(f)
484 }
485}
486
487pub trait WorkerService {
488 fn run_server(
489 &mut self,
490 ctx: ::grpcio::RpcContext,
491 _stream: ::grpcio::RequestStream<super::control::ServerArgs>,
492 sink: ::grpcio::DuplexSink<super::control::ServerStatus>,
493 ) {
494 grpcio::unimplemented_call!(ctx, sink)
495 }
496 fn run_client(
497 &mut self,
498 ctx: ::grpcio::RpcContext,
499 _stream: ::grpcio::RequestStream<super::control::ClientArgs>,
500 sink: ::grpcio::DuplexSink<super::control::ClientStatus>,
501 ) {
502 grpcio::unimplemented_call!(ctx, sink)
503 }
504 fn core_count(
505 &mut self,
506 ctx: ::grpcio::RpcContext,
507 _req: super::control::CoreRequest,
508 sink: ::grpcio::UnarySink<super::control::CoreResponse>,
509 ) {
510 grpcio::unimplemented_call!(ctx, sink)
511 }
512 fn quit_worker(
513 &mut self,
514 ctx: ::grpcio::RpcContext,
515 _req: super::control::Void,
516 sink: ::grpcio::UnarySink<super::control::Void>,
517 ) {
518 grpcio::unimplemented_call!(ctx, sink)
519 }
520}
521
522pub fn create_worker_service<S: WorkerService + Send + Clone + 'static>(s: S) -> ::grpcio::Service {
523 let mut builder = ::grpcio::ServiceBuilder::new();
524 let mut instance = s.clone();
525 builder = builder
526 .add_duplex_streaming_handler(&METHOD_WORKER_SERVICE_RUN_SERVER, move |ctx, req, resp| {
527 instance.run_server(ctx, req, resp)
528 });
529 let mut instance = s.clone();
530 builder = builder
531 .add_duplex_streaming_handler(&METHOD_WORKER_SERVICE_RUN_CLIENT, move |ctx, req, resp| {
532 instance.run_client(ctx, req, resp)
533 });
534 let mut instance = s.clone();
535 builder = builder
536 .add_unary_handler(&METHOD_WORKER_SERVICE_CORE_COUNT, move |ctx, req, resp| {
537 instance.core_count(ctx, req, resp)
538 });
539 let mut instance = s;
540 builder = builder
541 .add_unary_handler(&METHOD_WORKER_SERVICE_QUIT_WORKER, move |ctx, req, resp| {
542 instance.quit_worker(ctx, req, resp)
543 });
544 builder.build()
545}
546
547const METHOD_REPORT_QPS_SCENARIO_SERVICE_REPORT_SCENARIO: ::grpcio::Method<
548 super::control::ScenarioResult,
549 super::control::Void,
550> = ::grpcio::Method {
551 ty: ::grpcio::MethodType::Unary,
552 name: "/grpc.testing.ReportQpsScenarioService/ReportScenario",
553 req_mar: ::grpcio::Marshaller {
554 ser: ::grpcio::pb_ser,
555 de: ::grpcio::pb_de,
556 },
557 resp_mar: ::grpcio::Marshaller {
558 ser: ::grpcio::pb_ser,
559 de: ::grpcio::pb_de,
560 },
561};
562
563#[derive(Clone)]
564pub struct ReportQpsScenarioServiceClient {
565 pub client: ::grpcio::Client,
566}
567
568impl ReportQpsScenarioServiceClient {
569 pub fn new(channel: ::grpcio::Channel) -> Self {
570 ReportQpsScenarioServiceClient {
571 client: ::grpcio::Client::new(channel),
572 }
573 }
574
575 pub fn report_scenario_opt(
576 &self,
577 req: &super::control::ScenarioResult,
578 opt: ::grpcio::CallOption,
579 ) -> ::grpcio::Result<super::control::Void> {
580 self.client.unary_call(
581 &METHOD_REPORT_QPS_SCENARIO_SERVICE_REPORT_SCENARIO,
582 req,
583 opt,
584 )
585 }
586
587 pub fn report_scenario(
588 &self,
589 req: &super::control::ScenarioResult,
590 ) -> ::grpcio::Result<super::control::Void> {
591 self.report_scenario_opt(req, ::grpcio::CallOption::default())
592 }
593
594 pub fn report_scenario_async_opt(
595 &self,
596 req: &super::control::ScenarioResult,
597 opt: ::grpcio::CallOption,
598 ) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver<super::control::Void>> {
599 self.client.unary_call_async(
600 &METHOD_REPORT_QPS_SCENARIO_SERVICE_REPORT_SCENARIO,
601 req,
602 opt,
603 )
604 }
605
606 pub fn report_scenario_async(
607 &self,
608 req: &super::control::ScenarioResult,
609 ) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver<super::control::Void>> {
610 self.report_scenario_async_opt(req, ::grpcio::CallOption::default())
611 }
612 pub fn spawn<F>(&self, f: F)
613 where
614 F: ::std::future::Future<Output = ()> + Send + 'static,
615 {
616 self.client.spawn(f)
617 }
618}
619
620pub trait ReportQpsScenarioService {
621 fn report_scenario(
622 &mut self,
623 ctx: ::grpcio::RpcContext,
624 _req: super::control::ScenarioResult,
625 sink: ::grpcio::UnarySink<super::control::Void>,
626 ) {
627 grpcio::unimplemented_call!(ctx, sink)
628 }
629}
630
631pub fn create_report_qps_scenario_service<S: ReportQpsScenarioService + Send + Clone + 'static>(
632 s: S,
633) -> ::grpcio::Service {
634 let mut builder = ::grpcio::ServiceBuilder::new();
635 let mut instance = s;
636 builder = builder.add_unary_handler(
637 &METHOD_REPORT_QPS_SCENARIO_SERVICE_REPORT_SCENARIO,
638 move |ctx, req, resp| instance.report_scenario(ctx, req, resp),
639 );
640 builder.build()
641}