Skip to content
rachel/specter
File

Blob: spec/protocol/chord.twirp.go

go3641 lines
1// Code generated by protoc-gen-twirp v8.1.3, DO NOT EDIT.
2// source: spec/proto/chord.proto
3 
4package protocol
5 
6import context "context"
7import fmt "fmt"
8import http "net/http"
9import io "io"
10import json "encoding/json"
11import strconv "strconv"
12import strings "strings"
13 
14import protojson "google.golang.org/protobuf/encoding/protojson"
15import proto "google.golang.org/protobuf/proto"
16import twirp "github.com/twitchtv/twirp"
17import ctxsetters "github.com/twitchtv/twirp/ctxsetters"
18 
19import bytes "bytes"
20import errors "errors"
21import path "path"
22import url "net/url"
23 
24// Version compatibility assertion.
25// If the constant is not defined in the package, that likely means
26// the package needs to be updated to work with this generated code.
27// See https://twitchtv.github.io/twirp/docs/version_matrix.html
28const _ = twirp.TwirpPackageMinVersion_8_1_0
29 
30// ======================
31// VNodeService Interface
32// ======================
33 
34type VNodeService interface {
35	Identity(context.Context, *IdentityRequest) (*IdentityResponse, error)
36 
37	Ping(context.Context, *PingRequest) (*PingResponse, error)
38 
39	Notify(context.Context, *NotifyRequest) (*NotifyResponse, error)
40 
41	FindSuccessor(context.Context, *FindSuccessorRequest) (*FindSuccessorResponse, error)
42 
43	GetSuccessors(context.Context, *GetSuccessorsRequest) (*GetSuccessorsResponse, error)
44 
45	GetPredecessor(context.Context, *GetPredecessorRequest) (*GetPredecessorResponse, error)
46 
47	RequestToJoin(context.Context, *RequestToJoinRequest) (*RequestToJoinResponse, error)
48 
49	FinishJoin(context.Context, *MembershipConclusionRequest) (*MembershipConclusionResponse, error)
50 
51	RequestToLeave(context.Context, *RequestToLeaveRequest) (*RequestToLeaveResponse, error)
52 
53	FinishLeave(context.Context, *MembershipConclusionRequest) (*MembershipConclusionResponse, error)
54}
55 
56// ============================
57// VNodeService Protobuf Client
58// ============================
59 
60type vNodeServiceProtobufClient struct {
61	client      HTTPClient
62	urls        [10]string
63	interceptor twirp.Interceptor
64	opts        twirp.ClientOptions
65}
66 
67// NewVNodeServiceProtobufClient creates a Protobuf client that implements the VNodeService interface.
68// It communicates using Protobuf and can be configured with a custom HTTPClient.
69func NewVNodeServiceProtobufClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) VNodeService {
70	if c, ok := client.(*http.Client); ok {
71		client = withoutRedirects(c)
72	}
73 
74	clientOpts := twirp.ClientOptions{}
75	for _, o := range opts {
76		o(&clientOpts)
77	}
78 
79	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
80	literalURLs := false
81	_ = clientOpts.ReadOpt("literalURLs", &literalURLs)
82	var pathPrefix string
83	if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
84		pathPrefix = "/twirp" // default prefix
85	}
86 
87	// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
88	serviceURL := sanitizeBaseURL(baseURL)
89	serviceURL += baseServicePath(pathPrefix, "protocol", "VNodeService")
90	urls := [10]string{
91		serviceURL + "Identity",
92		serviceURL + "Ping",
93		serviceURL + "Notify",
94		serviceURL + "FindSuccessor",
95		serviceURL + "GetSuccessors",
96		serviceURL + "GetPredecessor",
97		serviceURL + "RequestToJoin",
98		serviceURL + "FinishJoin",
99		serviceURL + "RequestToLeave",
100		serviceURL + "FinishLeave",
101	}
102 
103	return &vNodeServiceProtobufClient{
104		client:      client,
105		urls:        urls,
106		interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...),
107		opts:        clientOpts,
108	}
109}
110 
111func (c *vNodeServiceProtobufClient) Identity(ctx context.Context, in *IdentityRequest) (*IdentityResponse, error) {
112	ctx = ctxsetters.WithPackageName(ctx, "protocol")
113	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
114	ctx = ctxsetters.WithMethodName(ctx, "Identity")
115	caller := c.callIdentity
116	if c.interceptor != nil {
117		caller = func(ctx context.Context, req *IdentityRequest) (*IdentityResponse, error) {
118			resp, err := c.interceptor(
119				func(ctx context.Context, req interface{}) (interface{}, error) {
120					typedReq, ok := req.(*IdentityRequest)
121					if !ok {
122						return nil, twirp.InternalError("failed type assertion req.(*IdentityRequest) when calling interceptor")
123					}
124					return c.callIdentity(ctx, typedReq)
125				},
126			)(ctx, req)
127			if resp != nil {
128				typedResp, ok := resp.(*IdentityResponse)
129				if !ok {
130					return nil, twirp.InternalError("failed type assertion resp.(*IdentityResponse) when calling interceptor")
131				}
132				return typedResp, err
133			}
134			return nil, err
135		}
136	}
137	return caller(ctx, in)
138}
139 
140func (c *vNodeServiceProtobufClient) callIdentity(ctx context.Context, in *IdentityRequest) (*IdentityResponse, error) {
141	out := new(IdentityResponse)
142	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
143	if err != nil {
144		twerr, ok := err.(twirp.Error)
145		if !ok {
146			twerr = twirp.InternalErrorWith(err)
147		}
148		callClientError(ctx, c.opts.Hooks, twerr)
149		return nil, err
150	}
151 
152	callClientResponseReceived(ctx, c.opts.Hooks)
153 
154	return out, nil
155}
156 
157func (c *vNodeServiceProtobufClient) Ping(ctx context.Context, in *PingRequest) (*PingResponse, error) {
158	ctx = ctxsetters.WithPackageName(ctx, "protocol")
159	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
160	ctx = ctxsetters.WithMethodName(ctx, "Ping")
161	caller := c.callPing
162	if c.interceptor != nil {
163		caller = func(ctx context.Context, req *PingRequest) (*PingResponse, error) {
164			resp, err := c.interceptor(
165				func(ctx context.Context, req interface{}) (interface{}, error) {
166					typedReq, ok := req.(*PingRequest)
167					if !ok {
168						return nil, twirp.InternalError("failed type assertion req.(*PingRequest) when calling interceptor")
169					}
170					return c.callPing(ctx, typedReq)
171				},
172			)(ctx, req)
173			if resp != nil {
174				typedResp, ok := resp.(*PingResponse)
175				if !ok {
176					return nil, twirp.InternalError("failed type assertion resp.(*PingResponse) when calling interceptor")
177				}
178				return typedResp, err
179			}
180			return nil, err
181		}
182	}
183	return caller(ctx, in)
184}
185 
186func (c *vNodeServiceProtobufClient) callPing(ctx context.Context, in *PingRequest) (*PingResponse, error) {
187	out := new(PingResponse)
188	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[1], in, out)
189	if err != nil {
190		twerr, ok := err.(twirp.Error)
191		if !ok {
192			twerr = twirp.InternalErrorWith(err)
193		}
194		callClientError(ctx, c.opts.Hooks, twerr)
195		return nil, err
196	}
197 
198	callClientResponseReceived(ctx, c.opts.Hooks)
199 
200	return out, nil
201}
202 
203func (c *vNodeServiceProtobufClient) Notify(ctx context.Context, in *NotifyRequest) (*NotifyResponse, error) {
204	ctx = ctxsetters.WithPackageName(ctx, "protocol")
205	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
206	ctx = ctxsetters.WithMethodName(ctx, "Notify")
207	caller := c.callNotify
208	if c.interceptor != nil {
209		caller = func(ctx context.Context, req *NotifyRequest) (*NotifyResponse, error) {
210			resp, err := c.interceptor(
211				func(ctx context.Context, req interface{}) (interface{}, error) {
212					typedReq, ok := req.(*NotifyRequest)
213					if !ok {
214						return nil, twirp.InternalError("failed type assertion req.(*NotifyRequest) when calling interceptor")
215					}
216					return c.callNotify(ctx, typedReq)
217				},
218			)(ctx, req)
219			if resp != nil {
220				typedResp, ok := resp.(*NotifyResponse)
221				if !ok {
222					return nil, twirp.InternalError("failed type assertion resp.(*NotifyResponse) when calling interceptor")
223				}
224				return typedResp, err
225			}
226			return nil, err
227		}
228	}
229	return caller(ctx, in)
230}
231 
232func (c *vNodeServiceProtobufClient) callNotify(ctx context.Context, in *NotifyRequest) (*NotifyResponse, error) {
233	out := new(NotifyResponse)
234	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[2], in, out)
235	if err != nil {
236		twerr, ok := err.(twirp.Error)
237		if !ok {
238			twerr = twirp.InternalErrorWith(err)
239		}
240		callClientError(ctx, c.opts.Hooks, twerr)
241		return nil, err
242	}
243 
244	callClientResponseReceived(ctx, c.opts.Hooks)
245 
246	return out, nil
247}
248 
249func (c *vNodeServiceProtobufClient) FindSuccessor(ctx context.Context, in *FindSuccessorRequest) (*FindSuccessorResponse, error) {
250	ctx = ctxsetters.WithPackageName(ctx, "protocol")
251	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
252	ctx = ctxsetters.WithMethodName(ctx, "FindSuccessor")
253	caller := c.callFindSuccessor
254	if c.interceptor != nil {
255		caller = func(ctx context.Context, req *FindSuccessorRequest) (*FindSuccessorResponse, error) {
256			resp, err := c.interceptor(
257				func(ctx context.Context, req interface{}) (interface{}, error) {
258					typedReq, ok := req.(*FindSuccessorRequest)
259					if !ok {
260						return nil, twirp.InternalError("failed type assertion req.(*FindSuccessorRequest) when calling interceptor")
261					}
262					return c.callFindSuccessor(ctx, typedReq)
263				},
264			)(ctx, req)
265			if resp != nil {
266				typedResp, ok := resp.(*FindSuccessorResponse)
267				if !ok {
268					return nil, twirp.InternalError("failed type assertion resp.(*FindSuccessorResponse) when calling interceptor")
269				}
270				return typedResp, err
271			}
272			return nil, err
273		}
274	}
275	return caller(ctx, in)
276}
277 
278func (c *vNodeServiceProtobufClient) callFindSuccessor(ctx context.Context, in *FindSuccessorRequest) (*FindSuccessorResponse, error) {
279	out := new(FindSuccessorResponse)
280	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[3], in, out)
281	if err != nil {
282		twerr, ok := err.(twirp.Error)
283		if !ok {
284			twerr = twirp.InternalErrorWith(err)
285		}
286		callClientError(ctx, c.opts.Hooks, twerr)
287		return nil, err
288	}
289 
290	callClientResponseReceived(ctx, c.opts.Hooks)
291 
292	return out, nil
293}
294 
295func (c *vNodeServiceProtobufClient) GetSuccessors(ctx context.Context, in *GetSuccessorsRequest) (*GetSuccessorsResponse, error) {
296	ctx = ctxsetters.WithPackageName(ctx, "protocol")
297	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
298	ctx = ctxsetters.WithMethodName(ctx, "GetSuccessors")
299	caller := c.callGetSuccessors
300	if c.interceptor != nil {
301		caller = func(ctx context.Context, req *GetSuccessorsRequest) (*GetSuccessorsResponse, error) {
302			resp, err := c.interceptor(
303				func(ctx context.Context, req interface{}) (interface{}, error) {
304					typedReq, ok := req.(*GetSuccessorsRequest)
305					if !ok {
306						return nil, twirp.InternalError("failed type assertion req.(*GetSuccessorsRequest) when calling interceptor")
307					}
308					return c.callGetSuccessors(ctx, typedReq)
309				},
310			)(ctx, req)
311			if resp != nil {
312				typedResp, ok := resp.(*GetSuccessorsResponse)
313				if !ok {
314					return nil, twirp.InternalError("failed type assertion resp.(*GetSuccessorsResponse) when calling interceptor")
315				}
316				return typedResp, err
317			}
318			return nil, err
319		}
320	}
321	return caller(ctx, in)
322}
323 
324func (c *vNodeServiceProtobufClient) callGetSuccessors(ctx context.Context, in *GetSuccessorsRequest) (*GetSuccessorsResponse, error) {
325	out := new(GetSuccessorsResponse)
326	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[4], in, out)
327	if err != nil {
328		twerr, ok := err.(twirp.Error)
329		if !ok {
330			twerr = twirp.InternalErrorWith(err)
331		}
332		callClientError(ctx, c.opts.Hooks, twerr)
333		return nil, err
334	}
335 
336	callClientResponseReceived(ctx, c.opts.Hooks)
337 
338	return out, nil
339}
340 
341func (c *vNodeServiceProtobufClient) GetPredecessor(ctx context.Context, in *GetPredecessorRequest) (*GetPredecessorResponse, error) {
342	ctx = ctxsetters.WithPackageName(ctx, "protocol")
343	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
344	ctx = ctxsetters.WithMethodName(ctx, "GetPredecessor")
345	caller := c.callGetPredecessor
346	if c.interceptor != nil {
347		caller = func(ctx context.Context, req *GetPredecessorRequest) (*GetPredecessorResponse, error) {
348			resp, err := c.interceptor(
349				func(ctx context.Context, req interface{}) (interface{}, error) {
350					typedReq, ok := req.(*GetPredecessorRequest)
351					if !ok {
352						return nil, twirp.InternalError("failed type assertion req.(*GetPredecessorRequest) when calling interceptor")
353					}
354					return c.callGetPredecessor(ctx, typedReq)
355				},
356			)(ctx, req)
357			if resp != nil {
358				typedResp, ok := resp.(*GetPredecessorResponse)
359				if !ok {
360					return nil, twirp.InternalError("failed type assertion resp.(*GetPredecessorResponse) when calling interceptor")
361				}
362				return typedResp, err
363			}
364			return nil, err
365		}
366	}
367	return caller(ctx, in)
368}
369 
370func (c *vNodeServiceProtobufClient) callGetPredecessor(ctx context.Context, in *GetPredecessorRequest) (*GetPredecessorResponse, error) {
371	out := new(GetPredecessorResponse)
372	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[5], in, out)
373	if err != nil {
374		twerr, ok := err.(twirp.Error)
375		if !ok {
376			twerr = twirp.InternalErrorWith(err)
377		}
378		callClientError(ctx, c.opts.Hooks, twerr)
379		return nil, err
380	}
381 
382	callClientResponseReceived(ctx, c.opts.Hooks)
383 
384	return out, nil
385}
386 
387func (c *vNodeServiceProtobufClient) RequestToJoin(ctx context.Context, in *RequestToJoinRequest) (*RequestToJoinResponse, error) {
388	ctx = ctxsetters.WithPackageName(ctx, "protocol")
389	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
390	ctx = ctxsetters.WithMethodName(ctx, "RequestToJoin")
391	caller := c.callRequestToJoin
392	if c.interceptor != nil {
393		caller = func(ctx context.Context, req *RequestToJoinRequest) (*RequestToJoinResponse, error) {
394			resp, err := c.interceptor(
395				func(ctx context.Context, req interface{}) (interface{}, error) {
396					typedReq, ok := req.(*RequestToJoinRequest)
397					if !ok {
398						return nil, twirp.InternalError("failed type assertion req.(*RequestToJoinRequest) when calling interceptor")
399					}
400					return c.callRequestToJoin(ctx, typedReq)
401				},
402			)(ctx, req)
403			if resp != nil {
404				typedResp, ok := resp.(*RequestToJoinResponse)
405				if !ok {
406					return nil, twirp.InternalError("failed type assertion resp.(*RequestToJoinResponse) when calling interceptor")
407				}
408				return typedResp, err
409			}
410			return nil, err
411		}
412	}
413	return caller(ctx, in)
414}
415 
416func (c *vNodeServiceProtobufClient) callRequestToJoin(ctx context.Context, in *RequestToJoinRequest) (*RequestToJoinResponse, error) {
417	out := new(RequestToJoinResponse)
418	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[6], in, out)
419	if err != nil {
420		twerr, ok := err.(twirp.Error)
421		if !ok {
422			twerr = twirp.InternalErrorWith(err)
423		}
424		callClientError(ctx, c.opts.Hooks, twerr)
425		return nil, err
426	}
427 
428	callClientResponseReceived(ctx, c.opts.Hooks)
429 
430	return out, nil
431}
432 
433func (c *vNodeServiceProtobufClient) FinishJoin(ctx context.Context, in *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
434	ctx = ctxsetters.WithPackageName(ctx, "protocol")
435	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
436	ctx = ctxsetters.WithMethodName(ctx, "FinishJoin")
437	caller := c.callFinishJoin
438	if c.interceptor != nil {
439		caller = func(ctx context.Context, req *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
440			resp, err := c.interceptor(
441				func(ctx context.Context, req interface{}) (interface{}, error) {
442					typedReq, ok := req.(*MembershipConclusionRequest)
443					if !ok {
444						return nil, twirp.InternalError("failed type assertion req.(*MembershipConclusionRequest) when calling interceptor")
445					}
446					return c.callFinishJoin(ctx, typedReq)
447				},
448			)(ctx, req)
449			if resp != nil {
450				typedResp, ok := resp.(*MembershipConclusionResponse)
451				if !ok {
452					return nil, twirp.InternalError("failed type assertion resp.(*MembershipConclusionResponse) when calling interceptor")
453				}
454				return typedResp, err
455			}
456			return nil, err
457		}
458	}
459	return caller(ctx, in)
460}
461 
462func (c *vNodeServiceProtobufClient) callFinishJoin(ctx context.Context, in *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
463	out := new(MembershipConclusionResponse)
464	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
465	if err != nil {
466		twerr, ok := err.(twirp.Error)
467		if !ok {
468			twerr = twirp.InternalErrorWith(err)
469		}
470		callClientError(ctx, c.opts.Hooks, twerr)
471		return nil, err
472	}
473 
474	callClientResponseReceived(ctx, c.opts.Hooks)
475 
476	return out, nil
477}
478 
479func (c *vNodeServiceProtobufClient) RequestToLeave(ctx context.Context, in *RequestToLeaveRequest) (*RequestToLeaveResponse, error) {
480	ctx = ctxsetters.WithPackageName(ctx, "protocol")
481	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
482	ctx = ctxsetters.WithMethodName(ctx, "RequestToLeave")
483	caller := c.callRequestToLeave
484	if c.interceptor != nil {
485		caller = func(ctx context.Context, req *RequestToLeaveRequest) (*RequestToLeaveResponse, error) {
486			resp, err := c.interceptor(
487				func(ctx context.Context, req interface{}) (interface{}, error) {
488					typedReq, ok := req.(*RequestToLeaveRequest)
489					if !ok {
490						return nil, twirp.InternalError("failed type assertion req.(*RequestToLeaveRequest) when calling interceptor")
491					}
492					return c.callRequestToLeave(ctx, typedReq)
493				},
494			)(ctx, req)
495			if resp != nil {
496				typedResp, ok := resp.(*RequestToLeaveResponse)
497				if !ok {
498					return nil, twirp.InternalError("failed type assertion resp.(*RequestToLeaveResponse) when calling interceptor")
499				}
500				return typedResp, err
501			}
502			return nil, err
503		}
504	}
505	return caller(ctx, in)
506}
507 
508func (c *vNodeServiceProtobufClient) callRequestToLeave(ctx context.Context, in *RequestToLeaveRequest) (*RequestToLeaveResponse, error) {
509	out := new(RequestToLeaveResponse)
510	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
511	if err != nil {
512		twerr, ok := err.(twirp.Error)
513		if !ok {
514			twerr = twirp.InternalErrorWith(err)
515		}
516		callClientError(ctx, c.opts.Hooks, twerr)
517		return nil, err
518	}
519 
520	callClientResponseReceived(ctx, c.opts.Hooks)
521 
522	return out, nil
523}
524 
525func (c *vNodeServiceProtobufClient) FinishLeave(ctx context.Context, in *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
526	ctx = ctxsetters.WithPackageName(ctx, "protocol")
527	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
528	ctx = ctxsetters.WithMethodName(ctx, "FinishLeave")
529	caller := c.callFinishLeave
530	if c.interceptor != nil {
531		caller = func(ctx context.Context, req *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
532			resp, err := c.interceptor(
533				func(ctx context.Context, req interface{}) (interface{}, error) {
534					typedReq, ok := req.(*MembershipConclusionRequest)
535					if !ok {
536						return nil, twirp.InternalError("failed type assertion req.(*MembershipConclusionRequest) when calling interceptor")
537					}
538					return c.callFinishLeave(ctx, typedReq)
539				},
540			)(ctx, req)
541			if resp != nil {
542				typedResp, ok := resp.(*MembershipConclusionResponse)
543				if !ok {
544					return nil, twirp.InternalError("failed type assertion resp.(*MembershipConclusionResponse) when calling interceptor")
545				}
546				return typedResp, err
547			}
548			return nil, err
549		}
550	}
551	return caller(ctx, in)
552}
553 
554func (c *vNodeServiceProtobufClient) callFinishLeave(ctx context.Context, in *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
555	out := new(MembershipConclusionResponse)
556	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[9], in, out)
557	if err != nil {
558		twerr, ok := err.(twirp.Error)
559		if !ok {
560			twerr = twirp.InternalErrorWith(err)
561		}
562		callClientError(ctx, c.opts.Hooks, twerr)
563		return nil, err
564	}
565 
566	callClientResponseReceived(ctx, c.opts.Hooks)
567 
568	return out, nil
569}
570 
571// ========================
572// VNodeService JSON Client
573// ========================
574 
575type vNodeServiceJSONClient struct {
576	client      HTTPClient
577	urls        [10]string
578	interceptor twirp.Interceptor
579	opts        twirp.ClientOptions
580}
581 
582// NewVNodeServiceJSONClient creates a JSON client that implements the VNodeService interface.
583// It communicates using JSON and can be configured with a custom HTTPClient.
584func NewVNodeServiceJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) VNodeService {
585	if c, ok := client.(*http.Client); ok {
586		client = withoutRedirects(c)
587	}
588 
589	clientOpts := twirp.ClientOptions{}
590	for _, o := range opts {
591		o(&clientOpts)
592	}
593 
594	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
595	literalURLs := false
596	_ = clientOpts.ReadOpt("literalURLs", &literalURLs)
597	var pathPrefix string
598	if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
599		pathPrefix = "/twirp" // default prefix
600	}
601 
602	// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
603	serviceURL := sanitizeBaseURL(baseURL)
604	serviceURL += baseServicePath(pathPrefix, "protocol", "VNodeService")
605	urls := [10]string{
606		serviceURL + "Identity",
607		serviceURL + "Ping",
608		serviceURL + "Notify",
609		serviceURL + "FindSuccessor",
610		serviceURL + "GetSuccessors",
611		serviceURL + "GetPredecessor",
612		serviceURL + "RequestToJoin",
613		serviceURL + "FinishJoin",
614		serviceURL + "RequestToLeave",
615		serviceURL + "FinishLeave",
616	}
617 
618	return &vNodeServiceJSONClient{
619		client:      client,
620		urls:        urls,
621		interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...),
622		opts:        clientOpts,
623	}
624}
625 
626func (c *vNodeServiceJSONClient) Identity(ctx context.Context, in *IdentityRequest) (*IdentityResponse, error) {
627	ctx = ctxsetters.WithPackageName(ctx, "protocol")
628	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
629	ctx = ctxsetters.WithMethodName(ctx, "Identity")
630	caller := c.callIdentity
631	if c.interceptor != nil {
632		caller = func(ctx context.Context, req *IdentityRequest) (*IdentityResponse, error) {
633			resp, err := c.interceptor(
634				func(ctx context.Context, req interface{}) (interface{}, error) {
635					typedReq, ok := req.(*IdentityRequest)
636					if !ok {
637						return nil, twirp.InternalError("failed type assertion req.(*IdentityRequest) when calling interceptor")
638					}
639					return c.callIdentity(ctx, typedReq)
640				},
641			)(ctx, req)
642			if resp != nil {
643				typedResp, ok := resp.(*IdentityResponse)
644				if !ok {
645					return nil, twirp.InternalError("failed type assertion resp.(*IdentityResponse) when calling interceptor")
646				}
647				return typedResp, err
648			}
649			return nil, err
650		}
651	}
652	return caller(ctx, in)
653}
654 
655func (c *vNodeServiceJSONClient) callIdentity(ctx context.Context, in *IdentityRequest) (*IdentityResponse, error) {
656	out := new(IdentityResponse)
657	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
658	if err != nil {
659		twerr, ok := err.(twirp.Error)
660		if !ok {
661			twerr = twirp.InternalErrorWith(err)
662		}
663		callClientError(ctx, c.opts.Hooks, twerr)
664		return nil, err
665	}
666 
667	callClientResponseReceived(ctx, c.opts.Hooks)
668 
669	return out, nil
670}
671 
672func (c *vNodeServiceJSONClient) Ping(ctx context.Context, in *PingRequest) (*PingResponse, error) {
673	ctx = ctxsetters.WithPackageName(ctx, "protocol")
674	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
675	ctx = ctxsetters.WithMethodName(ctx, "Ping")
676	caller := c.callPing
677	if c.interceptor != nil {
678		caller = func(ctx context.Context, req *PingRequest) (*PingResponse, error) {
679			resp, err := c.interceptor(
680				func(ctx context.Context, req interface{}) (interface{}, error) {
681					typedReq, ok := req.(*PingRequest)
682					if !ok {
683						return nil, twirp.InternalError("failed type assertion req.(*PingRequest) when calling interceptor")
684					}
685					return c.callPing(ctx, typedReq)
686				},
687			)(ctx, req)
688			if resp != nil {
689				typedResp, ok := resp.(*PingResponse)
690				if !ok {
691					return nil, twirp.InternalError("failed type assertion resp.(*PingResponse) when calling interceptor")
692				}
693				return typedResp, err
694			}
695			return nil, err
696		}
697	}
698	return caller(ctx, in)
699}
700 
701func (c *vNodeServiceJSONClient) callPing(ctx context.Context, in *PingRequest) (*PingResponse, error) {
702	out := new(PingResponse)
703	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[1], in, out)
704	if err != nil {
705		twerr, ok := err.(twirp.Error)
706		if !ok {
707			twerr = twirp.InternalErrorWith(err)
708		}
709		callClientError(ctx, c.opts.Hooks, twerr)
710		return nil, err
711	}
712 
713	callClientResponseReceived(ctx, c.opts.Hooks)
714 
715	return out, nil
716}
717 
718func (c *vNodeServiceJSONClient) Notify(ctx context.Context, in *NotifyRequest) (*NotifyResponse, error) {
719	ctx = ctxsetters.WithPackageName(ctx, "protocol")
720	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
721	ctx = ctxsetters.WithMethodName(ctx, "Notify")
722	caller := c.callNotify
723	if c.interceptor != nil {
724		caller = func(ctx context.Context, req *NotifyRequest) (*NotifyResponse, error) {
725			resp, err := c.interceptor(
726				func(ctx context.Context, req interface{}) (interface{}, error) {
727					typedReq, ok := req.(*NotifyRequest)
728					if !ok {
729						return nil, twirp.InternalError("failed type assertion req.(*NotifyRequest) when calling interceptor")
730					}
731					return c.callNotify(ctx, typedReq)
732				},
733			)(ctx, req)
734			if resp != nil {
735				typedResp, ok := resp.(*NotifyResponse)
736				if !ok {
737					return nil, twirp.InternalError("failed type assertion resp.(*NotifyResponse) when calling interceptor")
738				}
739				return typedResp, err
740			}
741			return nil, err
742		}
743	}
744	return caller(ctx, in)
745}
746 
747func (c *vNodeServiceJSONClient) callNotify(ctx context.Context, in *NotifyRequest) (*NotifyResponse, error) {
748	out := new(NotifyResponse)
749	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[2], in, out)
750	if err != nil {
751		twerr, ok := err.(twirp.Error)
752		if !ok {
753			twerr = twirp.InternalErrorWith(err)
754		}
755		callClientError(ctx, c.opts.Hooks, twerr)
756		return nil, err
757	}
758 
759	callClientResponseReceived(ctx, c.opts.Hooks)
760 
761	return out, nil
762}
763 
764func (c *vNodeServiceJSONClient) FindSuccessor(ctx context.Context, in *FindSuccessorRequest) (*FindSuccessorResponse, error) {
765	ctx = ctxsetters.WithPackageName(ctx, "protocol")
766	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
767	ctx = ctxsetters.WithMethodName(ctx, "FindSuccessor")
768	caller := c.callFindSuccessor
769	if c.interceptor != nil {
770		caller = func(ctx context.Context, req *FindSuccessorRequest) (*FindSuccessorResponse, error) {
771			resp, err := c.interceptor(
772				func(ctx context.Context, req interface{}) (interface{}, error) {
773					typedReq, ok := req.(*FindSuccessorRequest)
774					if !ok {
775						return nil, twirp.InternalError("failed type assertion req.(*FindSuccessorRequest) when calling interceptor")
776					}
777					return c.callFindSuccessor(ctx, typedReq)
778				},
779			)(ctx, req)
780			if resp != nil {
781				typedResp, ok := resp.(*FindSuccessorResponse)
782				if !ok {
783					return nil, twirp.InternalError("failed type assertion resp.(*FindSuccessorResponse) when calling interceptor")
784				}
785				return typedResp, err
786			}
787			return nil, err
788		}
789	}
790	return caller(ctx, in)
791}
792 
793func (c *vNodeServiceJSONClient) callFindSuccessor(ctx context.Context, in *FindSuccessorRequest) (*FindSuccessorResponse, error) {
794	out := new(FindSuccessorResponse)
795	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[3], in, out)
796	if err != nil {
797		twerr, ok := err.(twirp.Error)
798		if !ok {
799			twerr = twirp.InternalErrorWith(err)
800		}
801		callClientError(ctx, c.opts.Hooks, twerr)
802		return nil, err
803	}
804 
805	callClientResponseReceived(ctx, c.opts.Hooks)
806 
807	return out, nil
808}
809 
810func (c *vNodeServiceJSONClient) GetSuccessors(ctx context.Context, in *GetSuccessorsRequest) (*GetSuccessorsResponse, error) {
811	ctx = ctxsetters.WithPackageName(ctx, "protocol")
812	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
813	ctx = ctxsetters.WithMethodName(ctx, "GetSuccessors")
814	caller := c.callGetSuccessors
815	if c.interceptor != nil {
816		caller = func(ctx context.Context, req *GetSuccessorsRequest) (*GetSuccessorsResponse, error) {
817			resp, err := c.interceptor(
818				func(ctx context.Context, req interface{}) (interface{}, error) {
819					typedReq, ok := req.(*GetSuccessorsRequest)
820					if !ok {
821						return nil, twirp.InternalError("failed type assertion req.(*GetSuccessorsRequest) when calling interceptor")
822					}
823					return c.callGetSuccessors(ctx, typedReq)
824				},
825			)(ctx, req)
826			if resp != nil {
827				typedResp, ok := resp.(*GetSuccessorsResponse)
828				if !ok {
829					return nil, twirp.InternalError("failed type assertion resp.(*GetSuccessorsResponse) when calling interceptor")
830				}
831				return typedResp, err
832			}
833			return nil, err
834		}
835	}
836	return caller(ctx, in)
837}
838 
839func (c *vNodeServiceJSONClient) callGetSuccessors(ctx context.Context, in *GetSuccessorsRequest) (*GetSuccessorsResponse, error) {
840	out := new(GetSuccessorsResponse)
841	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[4], in, out)
842	if err != nil {
843		twerr, ok := err.(twirp.Error)
844		if !ok {
845			twerr = twirp.InternalErrorWith(err)
846		}
847		callClientError(ctx, c.opts.Hooks, twerr)
848		return nil, err
849	}
850 
851	callClientResponseReceived(ctx, c.opts.Hooks)
852 
853	return out, nil
854}
855 
856func (c *vNodeServiceJSONClient) GetPredecessor(ctx context.Context, in *GetPredecessorRequest) (*GetPredecessorResponse, error) {
857	ctx = ctxsetters.WithPackageName(ctx, "protocol")
858	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
859	ctx = ctxsetters.WithMethodName(ctx, "GetPredecessor")
860	caller := c.callGetPredecessor
861	if c.interceptor != nil {
862		caller = func(ctx context.Context, req *GetPredecessorRequest) (*GetPredecessorResponse, error) {
863			resp, err := c.interceptor(
864				func(ctx context.Context, req interface{}) (interface{}, error) {
865					typedReq, ok := req.(*GetPredecessorRequest)
866					if !ok {
867						return nil, twirp.InternalError("failed type assertion req.(*GetPredecessorRequest) when calling interceptor")
868					}
869					return c.callGetPredecessor(ctx, typedReq)
870				},
871			)(ctx, req)
872			if resp != nil {
873				typedResp, ok := resp.(*GetPredecessorResponse)
874				if !ok {
875					return nil, twirp.InternalError("failed type assertion resp.(*GetPredecessorResponse) when calling interceptor")
876				}
877				return typedResp, err
878			}
879			return nil, err
880		}
881	}
882	return caller(ctx, in)
883}
884 
885func (c *vNodeServiceJSONClient) callGetPredecessor(ctx context.Context, in *GetPredecessorRequest) (*GetPredecessorResponse, error) {
886	out := new(GetPredecessorResponse)
887	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[5], in, out)
888	if err != nil {
889		twerr, ok := err.(twirp.Error)
890		if !ok {
891			twerr = twirp.InternalErrorWith(err)
892		}
893		callClientError(ctx, c.opts.Hooks, twerr)
894		return nil, err
895	}
896 
897	callClientResponseReceived(ctx, c.opts.Hooks)
898 
899	return out, nil
900}
901 
902func (c *vNodeServiceJSONClient) RequestToJoin(ctx context.Context, in *RequestToJoinRequest) (*RequestToJoinResponse, error) {
903	ctx = ctxsetters.WithPackageName(ctx, "protocol")
904	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
905	ctx = ctxsetters.WithMethodName(ctx, "RequestToJoin")
906	caller := c.callRequestToJoin
907	if c.interceptor != nil {
908		caller = func(ctx context.Context, req *RequestToJoinRequest) (*RequestToJoinResponse, error) {
909			resp, err := c.interceptor(
910				func(ctx context.Context, req interface{}) (interface{}, error) {
911					typedReq, ok := req.(*RequestToJoinRequest)
912					if !ok {
913						return nil, twirp.InternalError("failed type assertion req.(*RequestToJoinRequest) when calling interceptor")
914					}
915					return c.callRequestToJoin(ctx, typedReq)
916				},
917			)(ctx, req)
918			if resp != nil {
919				typedResp, ok := resp.(*RequestToJoinResponse)
920				if !ok {
921					return nil, twirp.InternalError("failed type assertion resp.(*RequestToJoinResponse) when calling interceptor")
922				}
923				return typedResp, err
924			}
925			return nil, err
926		}
927	}
928	return caller(ctx, in)
929}
930 
931func (c *vNodeServiceJSONClient) callRequestToJoin(ctx context.Context, in *RequestToJoinRequest) (*RequestToJoinResponse, error) {
932	out := new(RequestToJoinResponse)
933	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[6], in, out)
934	if err != nil {
935		twerr, ok := err.(twirp.Error)
936		if !ok {
937			twerr = twirp.InternalErrorWith(err)
938		}
939		callClientError(ctx, c.opts.Hooks, twerr)
940		return nil, err
941	}
942 
943	callClientResponseReceived(ctx, c.opts.Hooks)
944 
945	return out, nil
946}
947 
948func (c *vNodeServiceJSONClient) FinishJoin(ctx context.Context, in *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
949	ctx = ctxsetters.WithPackageName(ctx, "protocol")
950	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
951	ctx = ctxsetters.WithMethodName(ctx, "FinishJoin")
952	caller := c.callFinishJoin
953	if c.interceptor != nil {
954		caller = func(ctx context.Context, req *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
955			resp, err := c.interceptor(
956				func(ctx context.Context, req interface{}) (interface{}, error) {
957					typedReq, ok := req.(*MembershipConclusionRequest)
958					if !ok {
959						return nil, twirp.InternalError("failed type assertion req.(*MembershipConclusionRequest) when calling interceptor")
960					}
961					return c.callFinishJoin(ctx, typedReq)
962				},
963			)(ctx, req)
964			if resp != nil {
965				typedResp, ok := resp.(*MembershipConclusionResponse)
966				if !ok {
967					return nil, twirp.InternalError("failed type assertion resp.(*MembershipConclusionResponse) when calling interceptor")
968				}
969				return typedResp, err
970			}
971			return nil, err
972		}
973	}
974	return caller(ctx, in)
975}
976 
977func (c *vNodeServiceJSONClient) callFinishJoin(ctx context.Context, in *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
978	out := new(MembershipConclusionResponse)
979	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
980	if err != nil {
981		twerr, ok := err.(twirp.Error)
982		if !ok {
983			twerr = twirp.InternalErrorWith(err)
984		}
985		callClientError(ctx, c.opts.Hooks, twerr)
986		return nil, err
987	}
988 
989	callClientResponseReceived(ctx, c.opts.Hooks)
990 
991	return out, nil
992}
993 
994func (c *vNodeServiceJSONClient) RequestToLeave(ctx context.Context, in *RequestToLeaveRequest) (*RequestToLeaveResponse, error) {
995	ctx = ctxsetters.WithPackageName(ctx, "protocol")
996	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
997	ctx = ctxsetters.WithMethodName(ctx, "RequestToLeave")
998	caller := c.callRequestToLeave
999	if c.interceptor != nil {
1000		caller = func(ctx context.Context, req *RequestToLeaveRequest) (*RequestToLeaveResponse, error) {
1001			resp, err := c.interceptor(
1002				func(ctx context.Context, req interface{}) (interface{}, error) {
1003					typedReq, ok := req.(*RequestToLeaveRequest)
1004					if !ok {
1005						return nil, twirp.InternalError("failed type assertion req.(*RequestToLeaveRequest) when calling interceptor")
1006					}
1007					return c.callRequestToLeave(ctx, typedReq)
1008				},
1009			)(ctx, req)
1010			if resp != nil {
1011				typedResp, ok := resp.(*RequestToLeaveResponse)
1012				if !ok {
1013					return nil, twirp.InternalError("failed type assertion resp.(*RequestToLeaveResponse) when calling interceptor")
1014				}
1015				return typedResp, err
1016			}
1017			return nil, err
1018		}
1019	}
1020	return caller(ctx, in)
1021}
1022 
1023func (c *vNodeServiceJSONClient) callRequestToLeave(ctx context.Context, in *RequestToLeaveRequest) (*RequestToLeaveResponse, error) {
1024	out := new(RequestToLeaveResponse)
1025	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
1026	if err != nil {
1027		twerr, ok := err.(twirp.Error)
1028		if !ok {
1029			twerr = twirp.InternalErrorWith(err)
1030		}
1031		callClientError(ctx, c.opts.Hooks, twerr)
1032		return nil, err
1033	}
1034 
1035	callClientResponseReceived(ctx, c.opts.Hooks)
1036 
1037	return out, nil
1038}
1039 
1040func (c *vNodeServiceJSONClient) FinishLeave(ctx context.Context, in *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
1041	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1042	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
1043	ctx = ctxsetters.WithMethodName(ctx, "FinishLeave")
1044	caller := c.callFinishLeave
1045	if c.interceptor != nil {
1046		caller = func(ctx context.Context, req *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
1047			resp, err := c.interceptor(
1048				func(ctx context.Context, req interface{}) (interface{}, error) {
1049					typedReq, ok := req.(*MembershipConclusionRequest)
1050					if !ok {
1051						return nil, twirp.InternalError("failed type assertion req.(*MembershipConclusionRequest) when calling interceptor")
1052					}
1053					return c.callFinishLeave(ctx, typedReq)
1054				},
1055			)(ctx, req)
1056			if resp != nil {
1057				typedResp, ok := resp.(*MembershipConclusionResponse)
1058				if !ok {
1059					return nil, twirp.InternalError("failed type assertion resp.(*MembershipConclusionResponse) when calling interceptor")
1060				}
1061				return typedResp, err
1062			}
1063			return nil, err
1064		}
1065	}
1066	return caller(ctx, in)
1067}
1068 
1069func (c *vNodeServiceJSONClient) callFinishLeave(ctx context.Context, in *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
1070	out := new(MembershipConclusionResponse)
1071	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[9], in, out)
1072	if err != nil {
1073		twerr, ok := err.(twirp.Error)
1074		if !ok {
1075			twerr = twirp.InternalErrorWith(err)
1076		}
1077		callClientError(ctx, c.opts.Hooks, twerr)
1078		return nil, err
1079	}
1080 
1081	callClientResponseReceived(ctx, c.opts.Hooks)
1082 
1083	return out, nil
1084}
1085 
1086// ===========================
1087// VNodeService Server Handler
1088// ===========================
1089 
1090type vNodeServiceServer struct {
1091	VNodeService
1092	interceptor      twirp.Interceptor
1093	hooks            *twirp.ServerHooks
1094	pathPrefix       string // prefix for routing
1095	jsonSkipDefaults bool   // do not include unpopulated fields (default values) in the response
1096	jsonCamelCase    bool   // JSON fields are serialized as lowerCamelCase rather than keeping the original proto names
1097}
1098 
1099// NewVNodeServiceServer builds a TwirpServer that can be used as an http.Handler to handle
1100// HTTP requests that are routed to the right method in the provided svc implementation.
1101// The opts are twirp.ServerOption modifiers, for example twirp.WithServerHooks(hooks).
1102func NewVNodeServiceServer(svc VNodeService, opts ...interface{}) TwirpServer {
1103	serverOpts := newServerOpts(opts)
1104 
1105	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
1106	jsonSkipDefaults := false
1107	_ = serverOpts.ReadOpt("jsonSkipDefaults", &jsonSkipDefaults)
1108	jsonCamelCase := false
1109	_ = serverOpts.ReadOpt("jsonCamelCase", &jsonCamelCase)
1110	var pathPrefix string
1111	if ok := serverOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
1112		pathPrefix = "/twirp" // default prefix
1113	}
1114 
1115	return &vNodeServiceServer{
1116		VNodeService:     svc,
1117		hooks:            serverOpts.Hooks,
1118		interceptor:      twirp.ChainInterceptors(serverOpts.Interceptors...),
1119		pathPrefix:       pathPrefix,
1120		jsonSkipDefaults: jsonSkipDefaults,
1121		jsonCamelCase:    jsonCamelCase,
1122	}
1123}
1124 
1125// writeError writes an HTTP response with a valid Twirp error format, and triggers hooks.
1126// If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err)
1127func (s *vNodeServiceServer) writeError(ctx context.Context, resp http.ResponseWriter, err error) {
1128	writeError(ctx, resp, err, s.hooks)
1129}
1130 
1131// handleRequestBodyError is used to handle error when the twirp server cannot read request
1132func (s *vNodeServiceServer) handleRequestBodyError(ctx context.Context, resp http.ResponseWriter, msg string, err error) {
1133	if context.Canceled == ctx.Err() {
1134		s.writeError(ctx, resp, twirp.NewError(twirp.Canceled, "failed to read request: context canceled"))
1135		return
1136	}
1137	if context.DeadlineExceeded == ctx.Err() {
1138		s.writeError(ctx, resp, twirp.NewError(twirp.DeadlineExceeded, "failed to read request: deadline exceeded"))
1139		return
1140	}
1141	s.writeError(ctx, resp, twirp.WrapError(malformedRequestError(msg), err))
1142}
1143 
1144// VNodeServicePathPrefix is a convenience constant that may identify URL paths.
1145// Should be used with caution, it only matches routes generated by Twirp Go clients,
1146// with the default "/twirp" prefix and default CamelCase service and method names.
1147// More info: https://twitchtv.github.io/twirp/docs/routing.html
1148const VNodeServicePathPrefix = "/twirp/protocol.VNodeService/"
1149 
1150func (s *vNodeServiceServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
1151	ctx := req.Context()
1152	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1153	ctx = ctxsetters.WithServiceName(ctx, "VNodeService")
1154	ctx = ctxsetters.WithResponseWriter(ctx, resp)
1155 
1156	var err error
1157	ctx, err = callRequestReceived(ctx, s.hooks)
1158	if err != nil {
1159		s.writeError(ctx, resp, err)
1160		return
1161	}
1162 
1163	if req.Method != "POST" {
1164		msg := fmt.Sprintf("unsupported method %q (only POST is allowed)", req.Method)
1165		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
1166		return
1167	}
1168 
1169	// Verify path format: [<prefix>]/<package>.<Service>/<Method>
1170	prefix, pkgService, method := parseTwirpPath(req.URL.Path)
1171	if pkgService != "protocol.VNodeService" {
1172		msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
1173		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
1174		return
1175	}
1176	if prefix != s.pathPrefix {
1177		msg := fmt.Sprintf("invalid path prefix %q, expected %q, on path %q", prefix, s.pathPrefix, req.URL.Path)
1178		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
1179		return
1180	}
1181 
1182	switch method {
1183	case "Identity":
1184		s.serveIdentity(ctx, resp, req)
1185		return
1186	case "Ping":
1187		s.servePing(ctx, resp, req)
1188		return
1189	case "Notify":
1190		s.serveNotify(ctx, resp, req)
1191		return
1192	case "FindSuccessor":
1193		s.serveFindSuccessor(ctx, resp, req)
1194		return
1195	case "GetSuccessors":
1196		s.serveGetSuccessors(ctx, resp, req)
1197		return
1198	case "GetPredecessor":
1199		s.serveGetPredecessor(ctx, resp, req)
1200		return
1201	case "RequestToJoin":
1202		s.serveRequestToJoin(ctx, resp, req)
1203		return
1204	case "FinishJoin":
1205		s.serveFinishJoin(ctx, resp, req)
1206		return
1207	case "RequestToLeave":
1208		s.serveRequestToLeave(ctx, resp, req)
1209		return
1210	case "FinishLeave":
1211		s.serveFinishLeave(ctx, resp, req)
1212		return
1213	default:
1214		msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
1215		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
1216		return
1217	}
1218}
1219 
1220func (s *vNodeServiceServer) serveIdentity(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1221	header := req.Header.Get("Content-Type")
1222	i := strings.Index(header, ";")
1223	if i == -1 {
1224		i = len(header)
1225	}
1226	switch strings.TrimSpace(strings.ToLower(header[:i])) {
1227	case "application/json":
1228		s.serveIdentityJSON(ctx, resp, req)
1229	case "application/protobuf":
1230		s.serveIdentityProtobuf(ctx, resp, req)
1231	default:
1232		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
1233		twerr := badRouteError(msg, req.Method, req.URL.Path)
1234		s.writeError(ctx, resp, twerr)
1235	}
1236}
1237 
1238func (s *vNodeServiceServer) serveIdentityJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1239	var err error
1240	ctx = ctxsetters.WithMethodName(ctx, "Identity")
1241	ctx, err = callRequestRouted(ctx, s.hooks)
1242	if err != nil {
1243		s.writeError(ctx, resp, err)
1244		return
1245	}
1246 
1247	d := json.NewDecoder(req.Body)
1248	rawReqBody := json.RawMessage{}
1249	if err := d.Decode(&rawReqBody); err != nil {
1250		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1251		return
1252	}
1253	reqContent := new(IdentityRequest)
1254	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
1255	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
1256		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1257		return
1258	}
1259 
1260	handler := s.VNodeService.Identity
1261	if s.interceptor != nil {
1262		handler = func(ctx context.Context, req *IdentityRequest) (*IdentityResponse, error) {
1263			resp, err := s.interceptor(
1264				func(ctx context.Context, req interface{}) (interface{}, error) {
1265					typedReq, ok := req.(*IdentityRequest)
1266					if !ok {
1267						return nil, twirp.InternalError("failed type assertion req.(*IdentityRequest) when calling interceptor")
1268					}
1269					return s.VNodeService.Identity(ctx, typedReq)
1270				},
1271			)(ctx, req)
1272			if resp != nil {
1273				typedResp, ok := resp.(*IdentityResponse)
1274				if !ok {
1275					return nil, twirp.InternalError("failed type assertion resp.(*IdentityResponse) when calling interceptor")
1276				}
1277				return typedResp, err
1278			}
1279			return nil, err
1280		}
1281	}
1282 
1283	// Call service method
1284	var respContent *IdentityResponse
1285	func() {
1286		defer ensurePanicResponses(ctx, resp, s.hooks)
1287		respContent, err = handler(ctx, reqContent)
1288	}()
1289 
1290	if err != nil {
1291		s.writeError(ctx, resp, err)
1292		return
1293	}
1294	if respContent == nil {
1295		s.writeError(ctx, resp, twirp.InternalError("received a nil *IdentityResponse and nil error while calling Identity. nil responses are not supported"))
1296		return
1297	}
1298 
1299	ctx = callResponsePrepared(ctx, s.hooks)
1300 
1301	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
1302	respBytes, err := marshaler.Marshal(respContent)
1303	if err != nil {
1304		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
1305		return
1306	}
1307 
1308	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1309	resp.Header().Set("Content-Type", "application/json")
1310	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1311	resp.WriteHeader(http.StatusOK)
1312 
1313	if n, err := resp.Write(respBytes); err != nil {
1314		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1315		twerr := twirp.NewError(twirp.Unknown, msg)
1316		ctx = callError(ctx, s.hooks, twerr)
1317	}
1318	callResponseSent(ctx, s.hooks)
1319}
1320 
1321func (s *vNodeServiceServer) serveIdentityProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1322	var err error
1323	ctx = ctxsetters.WithMethodName(ctx, "Identity")
1324	ctx, err = callRequestRouted(ctx, s.hooks)
1325	if err != nil {
1326		s.writeError(ctx, resp, err)
1327		return
1328	}
1329 
1330	buf, err := io.ReadAll(req.Body)
1331	if err != nil {
1332		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
1333		return
1334	}
1335	reqContent := new(IdentityRequest)
1336	if err = reqContent.UnmarshalVT(buf); err != nil {
1337		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
1338		return
1339	}
1340 
1341	handler := s.VNodeService.Identity
1342	if s.interceptor != nil {
1343		handler = func(ctx context.Context, req *IdentityRequest) (*IdentityResponse, error) {
1344			resp, err := s.interceptor(
1345				func(ctx context.Context, req interface{}) (interface{}, error) {
1346					typedReq, ok := req.(*IdentityRequest)
1347					if !ok {
1348						return nil, twirp.InternalError("failed type assertion req.(*IdentityRequest) when calling interceptor")
1349					}
1350					return s.VNodeService.Identity(ctx, typedReq)
1351				},
1352			)(ctx, req)
1353			if resp != nil {
1354				typedResp, ok := resp.(*IdentityResponse)
1355				if !ok {
1356					return nil, twirp.InternalError("failed type assertion resp.(*IdentityResponse) when calling interceptor")
1357				}
1358				return typedResp, err
1359			}
1360			return nil, err
1361		}
1362	}
1363 
1364	// Call service method
1365	var respContent *IdentityResponse
1366	func() {
1367		defer ensurePanicResponses(ctx, resp, s.hooks)
1368		respContent, err = handler(ctx, reqContent)
1369	}()
1370 
1371	if err != nil {
1372		s.writeError(ctx, resp, err)
1373		return
1374	}
1375	if respContent == nil {
1376		s.writeError(ctx, resp, twirp.InternalError("received a nil *IdentityResponse and nil error while calling Identity. nil responses are not supported"))
1377		return
1378	}
1379 
1380	ctx = callResponsePrepared(ctx, s.hooks)
1381 
1382	respBytes, err := respContent.MarshalVT()
1383	if err != nil {
1384		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
1385		return
1386	}
1387 
1388	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1389	resp.Header().Set("Content-Type", "application/protobuf")
1390	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1391	resp.WriteHeader(http.StatusOK)
1392	if n, err := resp.Write(respBytes); err != nil {
1393		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1394		twerr := twirp.NewError(twirp.Unknown, msg)
1395		ctx = callError(ctx, s.hooks, twerr)
1396	}
1397	callResponseSent(ctx, s.hooks)
1398}
1399 
1400func (s *vNodeServiceServer) servePing(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1401	header := req.Header.Get("Content-Type")
1402	i := strings.Index(header, ";")
1403	if i == -1 {
1404		i = len(header)
1405	}
1406	switch strings.TrimSpace(strings.ToLower(header[:i])) {
1407	case "application/json":
1408		s.servePingJSON(ctx, resp, req)
1409	case "application/protobuf":
1410		s.servePingProtobuf(ctx, resp, req)
1411	default:
1412		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
1413		twerr := badRouteError(msg, req.Method, req.URL.Path)
1414		s.writeError(ctx, resp, twerr)
1415	}
1416}
1417 
1418func (s *vNodeServiceServer) servePingJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1419	var err error
1420	ctx = ctxsetters.WithMethodName(ctx, "Ping")
1421	ctx, err = callRequestRouted(ctx, s.hooks)
1422	if err != nil {
1423		s.writeError(ctx, resp, err)
1424		return
1425	}
1426 
1427	d := json.NewDecoder(req.Body)
1428	rawReqBody := json.RawMessage{}
1429	if err := d.Decode(&rawReqBody); err != nil {
1430		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1431		return
1432	}
1433	reqContent := new(PingRequest)
1434	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
1435	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
1436		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1437		return
1438	}
1439 
1440	handler := s.VNodeService.Ping
1441	if s.interceptor != nil {
1442		handler = func(ctx context.Context, req *PingRequest) (*PingResponse, error) {
1443			resp, err := s.interceptor(
1444				func(ctx context.Context, req interface{}) (interface{}, error) {
1445					typedReq, ok := req.(*PingRequest)
1446					if !ok {
1447						return nil, twirp.InternalError("failed type assertion req.(*PingRequest) when calling interceptor")
1448					}
1449					return s.VNodeService.Ping(ctx, typedReq)
1450				},
1451			)(ctx, req)
1452			if resp != nil {
1453				typedResp, ok := resp.(*PingResponse)
1454				if !ok {
1455					return nil, twirp.InternalError("failed type assertion resp.(*PingResponse) when calling interceptor")
1456				}
1457				return typedResp, err
1458			}
1459			return nil, err
1460		}
1461	}
1462 
1463	// Call service method
1464	var respContent *PingResponse
1465	func() {
1466		defer ensurePanicResponses(ctx, resp, s.hooks)
1467		respContent, err = handler(ctx, reqContent)
1468	}()
1469 
1470	if err != nil {
1471		s.writeError(ctx, resp, err)
1472		return
1473	}
1474	if respContent == nil {
1475		s.writeError(ctx, resp, twirp.InternalError("received a nil *PingResponse and nil error while calling Ping. nil responses are not supported"))
1476		return
1477	}
1478 
1479	ctx = callResponsePrepared(ctx, s.hooks)
1480 
1481	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
1482	respBytes, err := marshaler.Marshal(respContent)
1483	if err != nil {
1484		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
1485		return
1486	}
1487 
1488	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1489	resp.Header().Set("Content-Type", "application/json")
1490	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1491	resp.WriteHeader(http.StatusOK)
1492 
1493	if n, err := resp.Write(respBytes); err != nil {
1494		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1495		twerr := twirp.NewError(twirp.Unknown, msg)
1496		ctx = callError(ctx, s.hooks, twerr)
1497	}
1498	callResponseSent(ctx, s.hooks)
1499}
1500 
1501func (s *vNodeServiceServer) servePingProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1502	var err error
1503	ctx = ctxsetters.WithMethodName(ctx, "Ping")
1504	ctx, err = callRequestRouted(ctx, s.hooks)
1505	if err != nil {
1506		s.writeError(ctx, resp, err)
1507		return
1508	}
1509 
1510	buf, err := io.ReadAll(req.Body)
1511	if err != nil {
1512		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
1513		return
1514	}
1515	reqContent := new(PingRequest)
1516	if err = reqContent.UnmarshalVT(buf); err != nil {
1517		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
1518		return
1519	}
1520 
1521	handler := s.VNodeService.Ping
1522	if s.interceptor != nil {
1523		handler = func(ctx context.Context, req *PingRequest) (*PingResponse, error) {
1524			resp, err := s.interceptor(
1525				func(ctx context.Context, req interface{}) (interface{}, error) {
1526					typedReq, ok := req.(*PingRequest)
1527					if !ok {
1528						return nil, twirp.InternalError("failed type assertion req.(*PingRequest) when calling interceptor")
1529					}
1530					return s.VNodeService.Ping(ctx, typedReq)
1531				},
1532			)(ctx, req)
1533			if resp != nil {
1534				typedResp, ok := resp.(*PingResponse)
1535				if !ok {
1536					return nil, twirp.InternalError("failed type assertion resp.(*PingResponse) when calling interceptor")
1537				}
1538				return typedResp, err
1539			}
1540			return nil, err
1541		}
1542	}
1543 
1544	// Call service method
1545	var respContent *PingResponse
1546	func() {
1547		defer ensurePanicResponses(ctx, resp, s.hooks)
1548		respContent, err = handler(ctx, reqContent)
1549	}()
1550 
1551	if err != nil {
1552		s.writeError(ctx, resp, err)
1553		return
1554	}
1555	if respContent == nil {
1556		s.writeError(ctx, resp, twirp.InternalError("received a nil *PingResponse and nil error while calling Ping. nil responses are not supported"))
1557		return
1558	}
1559 
1560	ctx = callResponsePrepared(ctx, s.hooks)
1561 
1562	respBytes, err := respContent.MarshalVT()
1563	if err != nil {
1564		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
1565		return
1566	}
1567 
1568	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1569	resp.Header().Set("Content-Type", "application/protobuf")
1570	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1571	resp.WriteHeader(http.StatusOK)
1572	if n, err := resp.Write(respBytes); err != nil {
1573		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1574		twerr := twirp.NewError(twirp.Unknown, msg)
1575		ctx = callError(ctx, s.hooks, twerr)
1576	}
1577	callResponseSent(ctx, s.hooks)
1578}
1579 
1580func (s *vNodeServiceServer) serveNotify(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1581	header := req.Header.Get("Content-Type")
1582	i := strings.Index(header, ";")
1583	if i == -1 {
1584		i = len(header)
1585	}
1586	switch strings.TrimSpace(strings.ToLower(header[:i])) {
1587	case "application/json":
1588		s.serveNotifyJSON(ctx, resp, req)
1589	case "application/protobuf":
1590		s.serveNotifyProtobuf(ctx, resp, req)
1591	default:
1592		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
1593		twerr := badRouteError(msg, req.Method, req.URL.Path)
1594		s.writeError(ctx, resp, twerr)
1595	}
1596}
1597 
1598func (s *vNodeServiceServer) serveNotifyJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1599	var err error
1600	ctx = ctxsetters.WithMethodName(ctx, "Notify")
1601	ctx, err = callRequestRouted(ctx, s.hooks)
1602	if err != nil {
1603		s.writeError(ctx, resp, err)
1604		return
1605	}
1606 
1607	d := json.NewDecoder(req.Body)
1608	rawReqBody := json.RawMessage{}
1609	if err := d.Decode(&rawReqBody); err != nil {
1610		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1611		return
1612	}
1613	reqContent := new(NotifyRequest)
1614	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
1615	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
1616		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1617		return
1618	}
1619 
1620	handler := s.VNodeService.Notify
1621	if s.interceptor != nil {
1622		handler = func(ctx context.Context, req *NotifyRequest) (*NotifyResponse, error) {
1623			resp, err := s.interceptor(
1624				func(ctx context.Context, req interface{}) (interface{}, error) {
1625					typedReq, ok := req.(*NotifyRequest)
1626					if !ok {
1627						return nil, twirp.InternalError("failed type assertion req.(*NotifyRequest) when calling interceptor")
1628					}
1629					return s.VNodeService.Notify(ctx, typedReq)
1630				},
1631			)(ctx, req)
1632			if resp != nil {
1633				typedResp, ok := resp.(*NotifyResponse)
1634				if !ok {
1635					return nil, twirp.InternalError("failed type assertion resp.(*NotifyResponse) when calling interceptor")
1636				}
1637				return typedResp, err
1638			}
1639			return nil, err
1640		}
1641	}
1642 
1643	// Call service method
1644	var respContent *NotifyResponse
1645	func() {
1646		defer ensurePanicResponses(ctx, resp, s.hooks)
1647		respContent, err = handler(ctx, reqContent)
1648	}()
1649 
1650	if err != nil {
1651		s.writeError(ctx, resp, err)
1652		return
1653	}
1654	if respContent == nil {
1655		s.writeError(ctx, resp, twirp.InternalError("received a nil *NotifyResponse and nil error while calling Notify. nil responses are not supported"))
1656		return
1657	}
1658 
1659	ctx = callResponsePrepared(ctx, s.hooks)
1660 
1661	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
1662	respBytes, err := marshaler.Marshal(respContent)
1663	if err != nil {
1664		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
1665		return
1666	}
1667 
1668	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1669	resp.Header().Set("Content-Type", "application/json")
1670	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1671	resp.WriteHeader(http.StatusOK)
1672 
1673	if n, err := resp.Write(respBytes); err != nil {
1674		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1675		twerr := twirp.NewError(twirp.Unknown, msg)
1676		ctx = callError(ctx, s.hooks, twerr)
1677	}
1678	callResponseSent(ctx, s.hooks)
1679}
1680 
1681func (s *vNodeServiceServer) serveNotifyProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1682	var err error
1683	ctx = ctxsetters.WithMethodName(ctx, "Notify")
1684	ctx, err = callRequestRouted(ctx, s.hooks)
1685	if err != nil {
1686		s.writeError(ctx, resp, err)
1687		return
1688	}
1689 
1690	buf, err := io.ReadAll(req.Body)
1691	if err != nil {
1692		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
1693		return
1694	}
1695	reqContent := new(NotifyRequest)
1696	if err = reqContent.UnmarshalVT(buf); err != nil {
1697		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
1698		return
1699	}
1700 
1701	handler := s.VNodeService.Notify
1702	if s.interceptor != nil {
1703		handler = func(ctx context.Context, req *NotifyRequest) (*NotifyResponse, error) {
1704			resp, err := s.interceptor(
1705				func(ctx context.Context, req interface{}) (interface{}, error) {
1706					typedReq, ok := req.(*NotifyRequest)
1707					if !ok {
1708						return nil, twirp.InternalError("failed type assertion req.(*NotifyRequest) when calling interceptor")
1709					}
1710					return s.VNodeService.Notify(ctx, typedReq)
1711				},
1712			)(ctx, req)
1713			if resp != nil {
1714				typedResp, ok := resp.(*NotifyResponse)
1715				if !ok {
1716					return nil, twirp.InternalError("failed type assertion resp.(*NotifyResponse) when calling interceptor")
1717				}
1718				return typedResp, err
1719			}
1720			return nil, err
1721		}
1722	}
1723 
1724	// Call service method
1725	var respContent *NotifyResponse
1726	func() {
1727		defer ensurePanicResponses(ctx, resp, s.hooks)
1728		respContent, err = handler(ctx, reqContent)
1729	}()
1730 
1731	if err != nil {
1732		s.writeError(ctx, resp, err)
1733		return
1734	}
1735	if respContent == nil {
1736		s.writeError(ctx, resp, twirp.InternalError("received a nil *NotifyResponse and nil error while calling Notify. nil responses are not supported"))
1737		return
1738	}
1739 
1740	ctx = callResponsePrepared(ctx, s.hooks)
1741 
1742	respBytes, err := respContent.MarshalVT()
1743	if err != nil {
1744		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
1745		return
1746	}
1747 
1748	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1749	resp.Header().Set("Content-Type", "application/protobuf")
1750	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1751	resp.WriteHeader(http.StatusOK)
1752	if n, err := resp.Write(respBytes); err != nil {
1753		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1754		twerr := twirp.NewError(twirp.Unknown, msg)
1755		ctx = callError(ctx, s.hooks, twerr)
1756	}
1757	callResponseSent(ctx, s.hooks)
1758}
1759 
1760func (s *vNodeServiceServer) serveFindSuccessor(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1761	header := req.Header.Get("Content-Type")
1762	i := strings.Index(header, ";")
1763	if i == -1 {
1764		i = len(header)
1765	}
1766	switch strings.TrimSpace(strings.ToLower(header[:i])) {
1767	case "application/json":
1768		s.serveFindSuccessorJSON(ctx, resp, req)
1769	case "application/protobuf":
1770		s.serveFindSuccessorProtobuf(ctx, resp, req)
1771	default:
1772		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
1773		twerr := badRouteError(msg, req.Method, req.URL.Path)
1774		s.writeError(ctx, resp, twerr)
1775	}
1776}
1777 
1778func (s *vNodeServiceServer) serveFindSuccessorJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1779	var err error
1780	ctx = ctxsetters.WithMethodName(ctx, "FindSuccessor")
1781	ctx, err = callRequestRouted(ctx, s.hooks)
1782	if err != nil {
1783		s.writeError(ctx, resp, err)
1784		return
1785	}
1786 
1787	d := json.NewDecoder(req.Body)
1788	rawReqBody := json.RawMessage{}
1789	if err := d.Decode(&rawReqBody); err != nil {
1790		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1791		return
1792	}
1793	reqContent := new(FindSuccessorRequest)
1794	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
1795	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
1796		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1797		return
1798	}
1799 
1800	handler := s.VNodeService.FindSuccessor
1801	if s.interceptor != nil {
1802		handler = func(ctx context.Context, req *FindSuccessorRequest) (*FindSuccessorResponse, error) {
1803			resp, err := s.interceptor(
1804				func(ctx context.Context, req interface{}) (interface{}, error) {
1805					typedReq, ok := req.(*FindSuccessorRequest)
1806					if !ok {
1807						return nil, twirp.InternalError("failed type assertion req.(*FindSuccessorRequest) when calling interceptor")
1808					}
1809					return s.VNodeService.FindSuccessor(ctx, typedReq)
1810				},
1811			)(ctx, req)
1812			if resp != nil {
1813				typedResp, ok := resp.(*FindSuccessorResponse)
1814				if !ok {
1815					return nil, twirp.InternalError("failed type assertion resp.(*FindSuccessorResponse) when calling interceptor")
1816				}
1817				return typedResp, err
1818			}
1819			return nil, err
1820		}
1821	}
1822 
1823	// Call service method
1824	var respContent *FindSuccessorResponse
1825	func() {
1826		defer ensurePanicResponses(ctx, resp, s.hooks)
1827		respContent, err = handler(ctx, reqContent)
1828	}()
1829 
1830	if err != nil {
1831		s.writeError(ctx, resp, err)
1832		return
1833	}
1834	if respContent == nil {
1835		s.writeError(ctx, resp, twirp.InternalError("received a nil *FindSuccessorResponse and nil error while calling FindSuccessor. nil responses are not supported"))
1836		return
1837	}
1838 
1839	ctx = callResponsePrepared(ctx, s.hooks)
1840 
1841	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
1842	respBytes, err := marshaler.Marshal(respContent)
1843	if err != nil {
1844		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
1845		return
1846	}
1847 
1848	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1849	resp.Header().Set("Content-Type", "application/json")
1850	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1851	resp.WriteHeader(http.StatusOK)
1852 
1853	if n, err := resp.Write(respBytes); err != nil {
1854		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1855		twerr := twirp.NewError(twirp.Unknown, msg)
1856		ctx = callError(ctx, s.hooks, twerr)
1857	}
1858	callResponseSent(ctx, s.hooks)
1859}
1860 
1861func (s *vNodeServiceServer) serveFindSuccessorProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1862	var err error
1863	ctx = ctxsetters.WithMethodName(ctx, "FindSuccessor")
1864	ctx, err = callRequestRouted(ctx, s.hooks)
1865	if err != nil {
1866		s.writeError(ctx, resp, err)
1867		return
1868	}
1869 
1870	buf, err := io.ReadAll(req.Body)
1871	if err != nil {
1872		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
1873		return
1874	}
1875	reqContent := new(FindSuccessorRequest)
1876	if err = reqContent.UnmarshalVT(buf); err != nil {
1877		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
1878		return
1879	}
1880 
1881	handler := s.VNodeService.FindSuccessor
1882	if s.interceptor != nil {
1883		handler = func(ctx context.Context, req *FindSuccessorRequest) (*FindSuccessorResponse, error) {
1884			resp, err := s.interceptor(
1885				func(ctx context.Context, req interface{}) (interface{}, error) {
1886					typedReq, ok := req.(*FindSuccessorRequest)
1887					if !ok {
1888						return nil, twirp.InternalError("failed type assertion req.(*FindSuccessorRequest) when calling interceptor")
1889					}
1890					return s.VNodeService.FindSuccessor(ctx, typedReq)
1891				},
1892			)(ctx, req)
1893			if resp != nil {
1894				typedResp, ok := resp.(*FindSuccessorResponse)
1895				if !ok {
1896					return nil, twirp.InternalError("failed type assertion resp.(*FindSuccessorResponse) when calling interceptor")
1897				}
1898				return typedResp, err
1899			}
1900			return nil, err
1901		}
1902	}
1903 
1904	// Call service method
1905	var respContent *FindSuccessorResponse
1906	func() {
1907		defer ensurePanicResponses(ctx, resp, s.hooks)
1908		respContent, err = handler(ctx, reqContent)
1909	}()
1910 
1911	if err != nil {
1912		s.writeError(ctx, resp, err)
1913		return
1914	}
1915	if respContent == nil {
1916		s.writeError(ctx, resp, twirp.InternalError("received a nil *FindSuccessorResponse and nil error while calling FindSuccessor. nil responses are not supported"))
1917		return
1918	}
1919 
1920	ctx = callResponsePrepared(ctx, s.hooks)
1921 
1922	respBytes, err := respContent.MarshalVT()
1923	if err != nil {
1924		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
1925		return
1926	}
1927 
1928	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1929	resp.Header().Set("Content-Type", "application/protobuf")
1930	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1931	resp.WriteHeader(http.StatusOK)
1932	if n, err := resp.Write(respBytes); err != nil {
1933		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1934		twerr := twirp.NewError(twirp.Unknown, msg)
1935		ctx = callError(ctx, s.hooks, twerr)
1936	}
1937	callResponseSent(ctx, s.hooks)
1938}
1939 
1940func (s *vNodeServiceServer) serveGetSuccessors(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1941	header := req.Header.Get("Content-Type")
1942	i := strings.Index(header, ";")
1943	if i == -1 {
1944		i = len(header)
1945	}
1946	switch strings.TrimSpace(strings.ToLower(header[:i])) {
1947	case "application/json":
1948		s.serveGetSuccessorsJSON(ctx, resp, req)
1949	case "application/protobuf":
1950		s.serveGetSuccessorsProtobuf(ctx, resp, req)
1951	default:
1952		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
1953		twerr := badRouteError(msg, req.Method, req.URL.Path)
1954		s.writeError(ctx, resp, twerr)
1955	}
1956}
1957 
1958func (s *vNodeServiceServer) serveGetSuccessorsJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1959	var err error
1960	ctx = ctxsetters.WithMethodName(ctx, "GetSuccessors")
1961	ctx, err = callRequestRouted(ctx, s.hooks)
1962	if err != nil {
1963		s.writeError(ctx, resp, err)
1964		return
1965	}
1966 
1967	d := json.NewDecoder(req.Body)
1968	rawReqBody := json.RawMessage{}
1969	if err := d.Decode(&rawReqBody); err != nil {
1970		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1971		return
1972	}
1973	reqContent := new(GetSuccessorsRequest)
1974	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
1975	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
1976		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1977		return
1978	}
1979 
1980	handler := s.VNodeService.GetSuccessors
1981	if s.interceptor != nil {
1982		handler = func(ctx context.Context, req *GetSuccessorsRequest) (*GetSuccessorsResponse, error) {
1983			resp, err := s.interceptor(
1984				func(ctx context.Context, req interface{}) (interface{}, error) {
1985					typedReq, ok := req.(*GetSuccessorsRequest)
1986					if !ok {
1987						return nil, twirp.InternalError("failed type assertion req.(*GetSuccessorsRequest) when calling interceptor")
1988					}
1989					return s.VNodeService.GetSuccessors(ctx, typedReq)
1990				},
1991			)(ctx, req)
1992			if resp != nil {
1993				typedResp, ok := resp.(*GetSuccessorsResponse)
1994				if !ok {
1995					return nil, twirp.InternalError("failed type assertion resp.(*GetSuccessorsResponse) when calling interceptor")
1996				}
1997				return typedResp, err
1998			}
1999			return nil, err
2000		}
2001	}
2002 
2003	// Call service method
2004	var respContent *GetSuccessorsResponse
2005	func() {
2006		defer ensurePanicResponses(ctx, resp, s.hooks)
2007		respContent, err = handler(ctx, reqContent)
2008	}()
2009 
2010	if err != nil {
2011		s.writeError(ctx, resp, err)
2012		return
2013	}
2014	if respContent == nil {
2015		s.writeError(ctx, resp, twirp.InternalError("received a nil *GetSuccessorsResponse and nil error while calling GetSuccessors. nil responses are not supported"))
2016		return
2017	}
2018 
2019	ctx = callResponsePrepared(ctx, s.hooks)
2020 
2021	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2022	respBytes, err := marshaler.Marshal(respContent)
2023	if err != nil {
2024		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2025		return
2026	}
2027 
2028	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2029	resp.Header().Set("Content-Type", "application/json")
2030	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2031	resp.WriteHeader(http.StatusOK)
2032 
2033	if n, err := resp.Write(respBytes); err != nil {
2034		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2035		twerr := twirp.NewError(twirp.Unknown, msg)
2036		ctx = callError(ctx, s.hooks, twerr)
2037	}
2038	callResponseSent(ctx, s.hooks)
2039}
2040 
2041func (s *vNodeServiceServer) serveGetSuccessorsProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2042	var err error
2043	ctx = ctxsetters.WithMethodName(ctx, "GetSuccessors")
2044	ctx, err = callRequestRouted(ctx, s.hooks)
2045	if err != nil {
2046		s.writeError(ctx, resp, err)
2047		return
2048	}
2049 
2050	buf, err := io.ReadAll(req.Body)
2051	if err != nil {
2052		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2053		return
2054	}
2055	reqContent := new(GetSuccessorsRequest)
2056	if err = reqContent.UnmarshalVT(buf); err != nil {
2057		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2058		return
2059	}
2060 
2061	handler := s.VNodeService.GetSuccessors
2062	if s.interceptor != nil {
2063		handler = func(ctx context.Context, req *GetSuccessorsRequest) (*GetSuccessorsResponse, error) {
2064			resp, err := s.interceptor(
2065				func(ctx context.Context, req interface{}) (interface{}, error) {
2066					typedReq, ok := req.(*GetSuccessorsRequest)
2067					if !ok {
2068						return nil, twirp.InternalError("failed type assertion req.(*GetSuccessorsRequest) when calling interceptor")
2069					}
2070					return s.VNodeService.GetSuccessors(ctx, typedReq)
2071				},
2072			)(ctx, req)
2073			if resp != nil {
2074				typedResp, ok := resp.(*GetSuccessorsResponse)
2075				if !ok {
2076					return nil, twirp.InternalError("failed type assertion resp.(*GetSuccessorsResponse) when calling interceptor")
2077				}
2078				return typedResp, err
2079			}
2080			return nil, err
2081		}
2082	}
2083 
2084	// Call service method
2085	var respContent *GetSuccessorsResponse
2086	func() {
2087		defer ensurePanicResponses(ctx, resp, s.hooks)
2088		respContent, err = handler(ctx, reqContent)
2089	}()
2090 
2091	if err != nil {
2092		s.writeError(ctx, resp, err)
2093		return
2094	}
2095	if respContent == nil {
2096		s.writeError(ctx, resp, twirp.InternalError("received a nil *GetSuccessorsResponse and nil error while calling GetSuccessors. nil responses are not supported"))
2097		return
2098	}
2099 
2100	ctx = callResponsePrepared(ctx, s.hooks)
2101 
2102	respBytes, err := respContent.MarshalVT()
2103	if err != nil {
2104		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2105		return
2106	}
2107 
2108	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2109	resp.Header().Set("Content-Type", "application/protobuf")
2110	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2111	resp.WriteHeader(http.StatusOK)
2112	if n, err := resp.Write(respBytes); err != nil {
2113		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2114		twerr := twirp.NewError(twirp.Unknown, msg)
2115		ctx = callError(ctx, s.hooks, twerr)
2116	}
2117	callResponseSent(ctx, s.hooks)
2118}
2119 
2120func (s *vNodeServiceServer) serveGetPredecessor(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2121	header := req.Header.Get("Content-Type")
2122	i := strings.Index(header, ";")
2123	if i == -1 {
2124		i = len(header)
2125	}
2126	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2127	case "application/json":
2128		s.serveGetPredecessorJSON(ctx, resp, req)
2129	case "application/protobuf":
2130		s.serveGetPredecessorProtobuf(ctx, resp, req)
2131	default:
2132		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2133		twerr := badRouteError(msg, req.Method, req.URL.Path)
2134		s.writeError(ctx, resp, twerr)
2135	}
2136}
2137 
2138func (s *vNodeServiceServer) serveGetPredecessorJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2139	var err error
2140	ctx = ctxsetters.WithMethodName(ctx, "GetPredecessor")
2141	ctx, err = callRequestRouted(ctx, s.hooks)
2142	if err != nil {
2143		s.writeError(ctx, resp, err)
2144		return
2145	}
2146 
2147	d := json.NewDecoder(req.Body)
2148	rawReqBody := json.RawMessage{}
2149	if err := d.Decode(&rawReqBody); err != nil {
2150		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2151		return
2152	}
2153	reqContent := new(GetPredecessorRequest)
2154	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
2155	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
2156		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2157		return
2158	}
2159 
2160	handler := s.VNodeService.GetPredecessor
2161	if s.interceptor != nil {
2162		handler = func(ctx context.Context, req *GetPredecessorRequest) (*GetPredecessorResponse, error) {
2163			resp, err := s.interceptor(
2164				func(ctx context.Context, req interface{}) (interface{}, error) {
2165					typedReq, ok := req.(*GetPredecessorRequest)
2166					if !ok {
2167						return nil, twirp.InternalError("failed type assertion req.(*GetPredecessorRequest) when calling interceptor")
2168					}
2169					return s.VNodeService.GetPredecessor(ctx, typedReq)
2170				},
2171			)(ctx, req)
2172			if resp != nil {
2173				typedResp, ok := resp.(*GetPredecessorResponse)
2174				if !ok {
2175					return nil, twirp.InternalError("failed type assertion resp.(*GetPredecessorResponse) when calling interceptor")
2176				}
2177				return typedResp, err
2178			}
2179			return nil, err
2180		}
2181	}
2182 
2183	// Call service method
2184	var respContent *GetPredecessorResponse
2185	func() {
2186		defer ensurePanicResponses(ctx, resp, s.hooks)
2187		respContent, err = handler(ctx, reqContent)
2188	}()
2189 
2190	if err != nil {
2191		s.writeError(ctx, resp, err)
2192		return
2193	}
2194	if respContent == nil {
2195		s.writeError(ctx, resp, twirp.InternalError("received a nil *GetPredecessorResponse and nil error while calling GetPredecessor. nil responses are not supported"))
2196		return
2197	}
2198 
2199	ctx = callResponsePrepared(ctx, s.hooks)
2200 
2201	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2202	respBytes, err := marshaler.Marshal(respContent)
2203	if err != nil {
2204		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2205		return
2206	}
2207 
2208	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2209	resp.Header().Set("Content-Type", "application/json")
2210	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2211	resp.WriteHeader(http.StatusOK)
2212 
2213	if n, err := resp.Write(respBytes); err != nil {
2214		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2215		twerr := twirp.NewError(twirp.Unknown, msg)
2216		ctx = callError(ctx, s.hooks, twerr)
2217	}
2218	callResponseSent(ctx, s.hooks)
2219}
2220 
2221func (s *vNodeServiceServer) serveGetPredecessorProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2222	var err error
2223	ctx = ctxsetters.WithMethodName(ctx, "GetPredecessor")
2224	ctx, err = callRequestRouted(ctx, s.hooks)
2225	if err != nil {
2226		s.writeError(ctx, resp, err)
2227		return
2228	}
2229 
2230	buf, err := io.ReadAll(req.Body)
2231	if err != nil {
2232		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2233		return
2234	}
2235	reqContent := new(GetPredecessorRequest)
2236	if err = reqContent.UnmarshalVT(buf); err != nil {
2237		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2238		return
2239	}
2240 
2241	handler := s.VNodeService.GetPredecessor
2242	if s.interceptor != nil {
2243		handler = func(ctx context.Context, req *GetPredecessorRequest) (*GetPredecessorResponse, error) {
2244			resp, err := s.interceptor(
2245				func(ctx context.Context, req interface{}) (interface{}, error) {
2246					typedReq, ok := req.(*GetPredecessorRequest)
2247					if !ok {
2248						return nil, twirp.InternalError("failed type assertion req.(*GetPredecessorRequest) when calling interceptor")
2249					}
2250					return s.VNodeService.GetPredecessor(ctx, typedReq)
2251				},
2252			)(ctx, req)
2253			if resp != nil {
2254				typedResp, ok := resp.(*GetPredecessorResponse)
2255				if !ok {
2256					return nil, twirp.InternalError("failed type assertion resp.(*GetPredecessorResponse) when calling interceptor")
2257				}
2258				return typedResp, err
2259			}
2260			return nil, err
2261		}
2262	}
2263 
2264	// Call service method
2265	var respContent *GetPredecessorResponse
2266	func() {
2267		defer ensurePanicResponses(ctx, resp, s.hooks)
2268		respContent, err = handler(ctx, reqContent)
2269	}()
2270 
2271	if err != nil {
2272		s.writeError(ctx, resp, err)
2273		return
2274	}
2275	if respContent == nil {
2276		s.writeError(ctx, resp, twirp.InternalError("received a nil *GetPredecessorResponse and nil error while calling GetPredecessor. nil responses are not supported"))
2277		return
2278	}
2279 
2280	ctx = callResponsePrepared(ctx, s.hooks)
2281 
2282	respBytes, err := respContent.MarshalVT()
2283	if err != nil {
2284		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2285		return
2286	}
2287 
2288	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2289	resp.Header().Set("Content-Type", "application/protobuf")
2290	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2291	resp.WriteHeader(http.StatusOK)
2292	if n, err := resp.Write(respBytes); err != nil {
2293		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2294		twerr := twirp.NewError(twirp.Unknown, msg)
2295		ctx = callError(ctx, s.hooks, twerr)
2296	}
2297	callResponseSent(ctx, s.hooks)
2298}
2299 
2300func (s *vNodeServiceServer) serveRequestToJoin(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2301	header := req.Header.Get("Content-Type")
2302	i := strings.Index(header, ";")
2303	if i == -1 {
2304		i = len(header)
2305	}
2306	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2307	case "application/json":
2308		s.serveRequestToJoinJSON(ctx, resp, req)
2309	case "application/protobuf":
2310		s.serveRequestToJoinProtobuf(ctx, resp, req)
2311	default:
2312		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2313		twerr := badRouteError(msg, req.Method, req.URL.Path)
2314		s.writeError(ctx, resp, twerr)
2315	}
2316}
2317 
2318func (s *vNodeServiceServer) serveRequestToJoinJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2319	var err error
2320	ctx = ctxsetters.WithMethodName(ctx, "RequestToJoin")
2321	ctx, err = callRequestRouted(ctx, s.hooks)
2322	if err != nil {
2323		s.writeError(ctx, resp, err)
2324		return
2325	}
2326 
2327	d := json.NewDecoder(req.Body)
2328	rawReqBody := json.RawMessage{}
2329	if err := d.Decode(&rawReqBody); err != nil {
2330		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2331		return
2332	}
2333	reqContent := new(RequestToJoinRequest)
2334	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
2335	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
2336		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2337		return
2338	}
2339 
2340	handler := s.VNodeService.RequestToJoin
2341	if s.interceptor != nil {
2342		handler = func(ctx context.Context, req *RequestToJoinRequest) (*RequestToJoinResponse, error) {
2343			resp, err := s.interceptor(
2344				func(ctx context.Context, req interface{}) (interface{}, error) {
2345					typedReq, ok := req.(*RequestToJoinRequest)
2346					if !ok {
2347						return nil, twirp.InternalError("failed type assertion req.(*RequestToJoinRequest) when calling interceptor")
2348					}
2349					return s.VNodeService.RequestToJoin(ctx, typedReq)
2350				},
2351			)(ctx, req)
2352			if resp != nil {
2353				typedResp, ok := resp.(*RequestToJoinResponse)
2354				if !ok {
2355					return nil, twirp.InternalError("failed type assertion resp.(*RequestToJoinResponse) when calling interceptor")
2356				}
2357				return typedResp, err
2358			}
2359			return nil, err
2360		}
2361	}
2362 
2363	// Call service method
2364	var respContent *RequestToJoinResponse
2365	func() {
2366		defer ensurePanicResponses(ctx, resp, s.hooks)
2367		respContent, err = handler(ctx, reqContent)
2368	}()
2369 
2370	if err != nil {
2371		s.writeError(ctx, resp, err)
2372		return
2373	}
2374	if respContent == nil {
2375		s.writeError(ctx, resp, twirp.InternalError("received a nil *RequestToJoinResponse and nil error while calling RequestToJoin. nil responses are not supported"))
2376		return
2377	}
2378 
2379	ctx = callResponsePrepared(ctx, s.hooks)
2380 
2381	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2382	respBytes, err := marshaler.Marshal(respContent)
2383	if err != nil {
2384		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2385		return
2386	}
2387 
2388	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2389	resp.Header().Set("Content-Type", "application/json")
2390	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2391	resp.WriteHeader(http.StatusOK)
2392 
2393	if n, err := resp.Write(respBytes); err != nil {
2394		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2395		twerr := twirp.NewError(twirp.Unknown, msg)
2396		ctx = callError(ctx, s.hooks, twerr)
2397	}
2398	callResponseSent(ctx, s.hooks)
2399}
2400 
2401func (s *vNodeServiceServer) serveRequestToJoinProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2402	var err error
2403	ctx = ctxsetters.WithMethodName(ctx, "RequestToJoin")
2404	ctx, err = callRequestRouted(ctx, s.hooks)
2405	if err != nil {
2406		s.writeError(ctx, resp, err)
2407		return
2408	}
2409 
2410	buf, err := io.ReadAll(req.Body)
2411	if err != nil {
2412		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2413		return
2414	}
2415	reqContent := new(RequestToJoinRequest)
2416	if err = reqContent.UnmarshalVT(buf); err != nil {
2417		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2418		return
2419	}
2420 
2421	handler := s.VNodeService.RequestToJoin
2422	if s.interceptor != nil {
2423		handler = func(ctx context.Context, req *RequestToJoinRequest) (*RequestToJoinResponse, error) {
2424			resp, err := s.interceptor(
2425				func(ctx context.Context, req interface{}) (interface{}, error) {
2426					typedReq, ok := req.(*RequestToJoinRequest)
2427					if !ok {
2428						return nil, twirp.InternalError("failed type assertion req.(*RequestToJoinRequest) when calling interceptor")
2429					}
2430					return s.VNodeService.RequestToJoin(ctx, typedReq)
2431				},
2432			)(ctx, req)
2433			if resp != nil {
2434				typedResp, ok := resp.(*RequestToJoinResponse)
2435				if !ok {
2436					return nil, twirp.InternalError("failed type assertion resp.(*RequestToJoinResponse) when calling interceptor")
2437				}
2438				return typedResp, err
2439			}
2440			return nil, err
2441		}
2442	}
2443 
2444	// Call service method
2445	var respContent *RequestToJoinResponse
2446	func() {
2447		defer ensurePanicResponses(ctx, resp, s.hooks)
2448		respContent, err = handler(ctx, reqContent)
2449	}()
2450 
2451	if err != nil {
2452		s.writeError(ctx, resp, err)
2453		return
2454	}
2455	if respContent == nil {
2456		s.writeError(ctx, resp, twirp.InternalError("received a nil *RequestToJoinResponse and nil error while calling RequestToJoin. nil responses are not supported"))
2457		return
2458	}
2459 
2460	ctx = callResponsePrepared(ctx, s.hooks)
2461 
2462	respBytes, err := respContent.MarshalVT()
2463	if err != nil {
2464		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2465		return
2466	}
2467 
2468	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2469	resp.Header().Set("Content-Type", "application/protobuf")
2470	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2471	resp.WriteHeader(http.StatusOK)
2472	if n, err := resp.Write(respBytes); err != nil {
2473		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2474		twerr := twirp.NewError(twirp.Unknown, msg)
2475		ctx = callError(ctx, s.hooks, twerr)
2476	}
2477	callResponseSent(ctx, s.hooks)
2478}
2479 
2480func (s *vNodeServiceServer) serveFinishJoin(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2481	header := req.Header.Get("Content-Type")
2482	i := strings.Index(header, ";")
2483	if i == -1 {
2484		i = len(header)
2485	}
2486	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2487	case "application/json":
2488		s.serveFinishJoinJSON(ctx, resp, req)
2489	case "application/protobuf":
2490		s.serveFinishJoinProtobuf(ctx, resp, req)
2491	default:
2492		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2493		twerr := badRouteError(msg, req.Method, req.URL.Path)
2494		s.writeError(ctx, resp, twerr)
2495	}
2496}
2497 
2498func (s *vNodeServiceServer) serveFinishJoinJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2499	var err error
2500	ctx = ctxsetters.WithMethodName(ctx, "FinishJoin")
2501	ctx, err = callRequestRouted(ctx, s.hooks)
2502	if err != nil {
2503		s.writeError(ctx, resp, err)
2504		return
2505	}
2506 
2507	d := json.NewDecoder(req.Body)
2508	rawReqBody := json.RawMessage{}
2509	if err := d.Decode(&rawReqBody); err != nil {
2510		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2511		return
2512	}
2513	reqContent := new(MembershipConclusionRequest)
2514	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
2515	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
2516		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2517		return
2518	}
2519 
2520	handler := s.VNodeService.FinishJoin
2521	if s.interceptor != nil {
2522		handler = func(ctx context.Context, req *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
2523			resp, err := s.interceptor(
2524				func(ctx context.Context, req interface{}) (interface{}, error) {
2525					typedReq, ok := req.(*MembershipConclusionRequest)
2526					if !ok {
2527						return nil, twirp.InternalError("failed type assertion req.(*MembershipConclusionRequest) when calling interceptor")
2528					}
2529					return s.VNodeService.FinishJoin(ctx, typedReq)
2530				},
2531			)(ctx, req)
2532			if resp != nil {
2533				typedResp, ok := resp.(*MembershipConclusionResponse)
2534				if !ok {
2535					return nil, twirp.InternalError("failed type assertion resp.(*MembershipConclusionResponse) when calling interceptor")
2536				}
2537				return typedResp, err
2538			}
2539			return nil, err
2540		}
2541	}
2542 
2543	// Call service method
2544	var respContent *MembershipConclusionResponse
2545	func() {
2546		defer ensurePanicResponses(ctx, resp, s.hooks)
2547		respContent, err = handler(ctx, reqContent)
2548	}()
2549 
2550	if err != nil {
2551		s.writeError(ctx, resp, err)
2552		return
2553	}
2554	if respContent == nil {
2555		s.writeError(ctx, resp, twirp.InternalError("received a nil *MembershipConclusionResponse and nil error while calling FinishJoin. nil responses are not supported"))
2556		return
2557	}
2558 
2559	ctx = callResponsePrepared(ctx, s.hooks)
2560 
2561	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2562	respBytes, err := marshaler.Marshal(respContent)
2563	if err != nil {
2564		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2565		return
2566	}
2567 
2568	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2569	resp.Header().Set("Content-Type", "application/json")
2570	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2571	resp.WriteHeader(http.StatusOK)
2572 
2573	if n, err := resp.Write(respBytes); err != nil {
2574		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2575		twerr := twirp.NewError(twirp.Unknown, msg)
2576		ctx = callError(ctx, s.hooks, twerr)
2577	}
2578	callResponseSent(ctx, s.hooks)
2579}
2580 
2581func (s *vNodeServiceServer) serveFinishJoinProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2582	var err error
2583	ctx = ctxsetters.WithMethodName(ctx, "FinishJoin")
2584	ctx, err = callRequestRouted(ctx, s.hooks)
2585	if err != nil {
2586		s.writeError(ctx, resp, err)
2587		return
2588	}
2589 
2590	buf, err := io.ReadAll(req.Body)
2591	if err != nil {
2592		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2593		return
2594	}
2595	reqContent := new(MembershipConclusionRequest)
2596	if err = reqContent.UnmarshalVT(buf); err != nil {
2597		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2598		return
2599	}
2600 
2601	handler := s.VNodeService.FinishJoin
2602	if s.interceptor != nil {
2603		handler = func(ctx context.Context, req *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
2604			resp, err := s.interceptor(
2605				func(ctx context.Context, req interface{}) (interface{}, error) {
2606					typedReq, ok := req.(*MembershipConclusionRequest)
2607					if !ok {
2608						return nil, twirp.InternalError("failed type assertion req.(*MembershipConclusionRequest) when calling interceptor")
2609					}
2610					return s.VNodeService.FinishJoin(ctx, typedReq)
2611				},
2612			)(ctx, req)
2613			if resp != nil {
2614				typedResp, ok := resp.(*MembershipConclusionResponse)
2615				if !ok {
2616					return nil, twirp.InternalError("failed type assertion resp.(*MembershipConclusionResponse) when calling interceptor")
2617				}
2618				return typedResp, err
2619			}
2620			return nil, err
2621		}
2622	}
2623 
2624	// Call service method
2625	var respContent *MembershipConclusionResponse
2626	func() {
2627		defer ensurePanicResponses(ctx, resp, s.hooks)
2628		respContent, err = handler(ctx, reqContent)
2629	}()
2630 
2631	if err != nil {
2632		s.writeError(ctx, resp, err)
2633		return
2634	}
2635	if respContent == nil {
2636		s.writeError(ctx, resp, twirp.InternalError("received a nil *MembershipConclusionResponse and nil error while calling FinishJoin. nil responses are not supported"))
2637		return
2638	}
2639 
2640	ctx = callResponsePrepared(ctx, s.hooks)
2641 
2642	respBytes, err := respContent.MarshalVT()
2643	if err != nil {
2644		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2645		return
2646	}
2647 
2648	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2649	resp.Header().Set("Content-Type", "application/protobuf")
2650	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2651	resp.WriteHeader(http.StatusOK)
2652	if n, err := resp.Write(respBytes); err != nil {
2653		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2654		twerr := twirp.NewError(twirp.Unknown, msg)
2655		ctx = callError(ctx, s.hooks, twerr)
2656	}
2657	callResponseSent(ctx, s.hooks)
2658}
2659 
2660func (s *vNodeServiceServer) serveRequestToLeave(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2661	header := req.Header.Get("Content-Type")
2662	i := strings.Index(header, ";")
2663	if i == -1 {
2664		i = len(header)
2665	}
2666	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2667	case "application/json":
2668		s.serveRequestToLeaveJSON(ctx, resp, req)
2669	case "application/protobuf":
2670		s.serveRequestToLeaveProtobuf(ctx, resp, req)
2671	default:
2672		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2673		twerr := badRouteError(msg, req.Method, req.URL.Path)
2674		s.writeError(ctx, resp, twerr)
2675	}
2676}
2677 
2678func (s *vNodeServiceServer) serveRequestToLeaveJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2679	var err error
2680	ctx = ctxsetters.WithMethodName(ctx, "RequestToLeave")
2681	ctx, err = callRequestRouted(ctx, s.hooks)
2682	if err != nil {
2683		s.writeError(ctx, resp, err)
2684		return
2685	}
2686 
2687	d := json.NewDecoder(req.Body)
2688	rawReqBody := json.RawMessage{}
2689	if err := d.Decode(&rawReqBody); err != nil {
2690		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2691		return
2692	}
2693	reqContent := new(RequestToLeaveRequest)
2694	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
2695	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
2696		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2697		return
2698	}
2699 
2700	handler := s.VNodeService.RequestToLeave
2701	if s.interceptor != nil {
2702		handler = func(ctx context.Context, req *RequestToLeaveRequest) (*RequestToLeaveResponse, error) {
2703			resp, err := s.interceptor(
2704				func(ctx context.Context, req interface{}) (interface{}, error) {
2705					typedReq, ok := req.(*RequestToLeaveRequest)
2706					if !ok {
2707						return nil, twirp.InternalError("failed type assertion req.(*RequestToLeaveRequest) when calling interceptor")
2708					}
2709					return s.VNodeService.RequestToLeave(ctx, typedReq)
2710				},
2711			)(ctx, req)
2712			if resp != nil {
2713				typedResp, ok := resp.(*RequestToLeaveResponse)
2714				if !ok {
2715					return nil, twirp.InternalError("failed type assertion resp.(*RequestToLeaveResponse) when calling interceptor")
2716				}
2717				return typedResp, err
2718			}
2719			return nil, err
2720		}
2721	}
2722 
2723	// Call service method
2724	var respContent *RequestToLeaveResponse
2725	func() {
2726		defer ensurePanicResponses(ctx, resp, s.hooks)
2727		respContent, err = handler(ctx, reqContent)
2728	}()
2729 
2730	if err != nil {
2731		s.writeError(ctx, resp, err)
2732		return
2733	}
2734	if respContent == nil {
2735		s.writeError(ctx, resp, twirp.InternalError("received a nil *RequestToLeaveResponse and nil error while calling RequestToLeave. nil responses are not supported"))
2736		return
2737	}
2738 
2739	ctx = callResponsePrepared(ctx, s.hooks)
2740 
2741	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2742	respBytes, err := marshaler.Marshal(respContent)
2743	if err != nil {
2744		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2745		return
2746	}
2747 
2748	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2749	resp.Header().Set("Content-Type", "application/json")
2750	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2751	resp.WriteHeader(http.StatusOK)
2752 
2753	if n, err := resp.Write(respBytes); err != nil {
2754		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2755		twerr := twirp.NewError(twirp.Unknown, msg)
2756		ctx = callError(ctx, s.hooks, twerr)
2757	}
2758	callResponseSent(ctx, s.hooks)
2759}
2760 
2761func (s *vNodeServiceServer) serveRequestToLeaveProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2762	var err error
2763	ctx = ctxsetters.WithMethodName(ctx, "RequestToLeave")
2764	ctx, err = callRequestRouted(ctx, s.hooks)
2765	if err != nil {
2766		s.writeError(ctx, resp, err)
2767		return
2768	}
2769 
2770	buf, err := io.ReadAll(req.Body)
2771	if err != nil {
2772		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2773		return
2774	}
2775	reqContent := new(RequestToLeaveRequest)
2776	if err = reqContent.UnmarshalVT(buf); err != nil {
2777		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2778		return
2779	}
2780 
2781	handler := s.VNodeService.RequestToLeave
2782	if s.interceptor != nil {
2783		handler = func(ctx context.Context, req *RequestToLeaveRequest) (*RequestToLeaveResponse, error) {
2784			resp, err := s.interceptor(
2785				func(ctx context.Context, req interface{}) (interface{}, error) {
2786					typedReq, ok := req.(*RequestToLeaveRequest)
2787					if !ok {
2788						return nil, twirp.InternalError("failed type assertion req.(*RequestToLeaveRequest) when calling interceptor")
2789					}
2790					return s.VNodeService.RequestToLeave(ctx, typedReq)
2791				},
2792			)(ctx, req)
2793			if resp != nil {
2794				typedResp, ok := resp.(*RequestToLeaveResponse)
2795				if !ok {
2796					return nil, twirp.InternalError("failed type assertion resp.(*RequestToLeaveResponse) when calling interceptor")
2797				}
2798				return typedResp, err
2799			}
2800			return nil, err
2801		}
2802	}
2803 
2804	// Call service method
2805	var respContent *RequestToLeaveResponse
2806	func() {
2807		defer ensurePanicResponses(ctx, resp, s.hooks)
2808		respContent, err = handler(ctx, reqContent)
2809	}()
2810 
2811	if err != nil {
2812		s.writeError(ctx, resp, err)
2813		return
2814	}
2815	if respContent == nil {
2816		s.writeError(ctx, resp, twirp.InternalError("received a nil *RequestToLeaveResponse and nil error while calling RequestToLeave. nil responses are not supported"))
2817		return
2818	}
2819 
2820	ctx = callResponsePrepared(ctx, s.hooks)
2821 
2822	respBytes, err := respContent.MarshalVT()
2823	if err != nil {
2824		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2825		return
2826	}
2827 
2828	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2829	resp.Header().Set("Content-Type", "application/protobuf")
2830	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2831	resp.WriteHeader(http.StatusOK)
2832	if n, err := resp.Write(respBytes); err != nil {
2833		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2834		twerr := twirp.NewError(twirp.Unknown, msg)
2835		ctx = callError(ctx, s.hooks, twerr)
2836	}
2837	callResponseSent(ctx, s.hooks)
2838}
2839 
2840func (s *vNodeServiceServer) serveFinishLeave(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2841	header := req.Header.Get("Content-Type")
2842	i := strings.Index(header, ";")
2843	if i == -1 {
2844		i = len(header)
2845	}
2846	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2847	case "application/json":
2848		s.serveFinishLeaveJSON(ctx, resp, req)
2849	case "application/protobuf":
2850		s.serveFinishLeaveProtobuf(ctx, resp, req)
2851	default:
2852		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2853		twerr := badRouteError(msg, req.Method, req.URL.Path)
2854		s.writeError(ctx, resp, twerr)
2855	}
2856}
2857 
2858func (s *vNodeServiceServer) serveFinishLeaveJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2859	var err error
2860	ctx = ctxsetters.WithMethodName(ctx, "FinishLeave")
2861	ctx, err = callRequestRouted(ctx, s.hooks)
2862	if err != nil {
2863		s.writeError(ctx, resp, err)
2864		return
2865	}
2866 
2867	d := json.NewDecoder(req.Body)
2868	rawReqBody := json.RawMessage{}
2869	if err := d.Decode(&rawReqBody); err != nil {
2870		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2871		return
2872	}
2873	reqContent := new(MembershipConclusionRequest)
2874	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
2875	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
2876		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2877		return
2878	}
2879 
2880	handler := s.VNodeService.FinishLeave
2881	if s.interceptor != nil {
2882		handler = func(ctx context.Context, req *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
2883			resp, err := s.interceptor(
2884				func(ctx context.Context, req interface{}) (interface{}, error) {
2885					typedReq, ok := req.(*MembershipConclusionRequest)
2886					if !ok {
2887						return nil, twirp.InternalError("failed type assertion req.(*MembershipConclusionRequest) when calling interceptor")
2888					}
2889					return s.VNodeService.FinishLeave(ctx, typedReq)
2890				},
2891			)(ctx, req)
2892			if resp != nil {
2893				typedResp, ok := resp.(*MembershipConclusionResponse)
2894				if !ok {
2895					return nil, twirp.InternalError("failed type assertion resp.(*MembershipConclusionResponse) when calling interceptor")
2896				}
2897				return typedResp, err
2898			}
2899			return nil, err
2900		}
2901	}
2902 
2903	// Call service method
2904	var respContent *MembershipConclusionResponse
2905	func() {
2906		defer ensurePanicResponses(ctx, resp, s.hooks)
2907		respContent, err = handler(ctx, reqContent)
2908	}()
2909 
2910	if err != nil {
2911		s.writeError(ctx, resp, err)
2912		return
2913	}
2914	if respContent == nil {
2915		s.writeError(ctx, resp, twirp.InternalError("received a nil *MembershipConclusionResponse and nil error while calling FinishLeave. nil responses are not supported"))
2916		return
2917	}
2918 
2919	ctx = callResponsePrepared(ctx, s.hooks)
2920 
2921	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2922	respBytes, err := marshaler.Marshal(respContent)
2923	if err != nil {
2924		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2925		return
2926	}
2927 
2928	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2929	resp.Header().Set("Content-Type", "application/json")
2930	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2931	resp.WriteHeader(http.StatusOK)
2932 
2933	if n, err := resp.Write(respBytes); err != nil {
2934		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2935		twerr := twirp.NewError(twirp.Unknown, msg)
2936		ctx = callError(ctx, s.hooks, twerr)
2937	}
2938	callResponseSent(ctx, s.hooks)
2939}
2940 
2941func (s *vNodeServiceServer) serveFinishLeaveProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2942	var err error
2943	ctx = ctxsetters.WithMethodName(ctx, "FinishLeave")
2944	ctx, err = callRequestRouted(ctx, s.hooks)
2945	if err != nil {
2946		s.writeError(ctx, resp, err)
2947		return
2948	}
2949 
2950	buf, err := io.ReadAll(req.Body)
2951	if err != nil {
2952		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2953		return
2954	}
2955	reqContent := new(MembershipConclusionRequest)
2956	if err = reqContent.UnmarshalVT(buf); err != nil {
2957		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2958		return
2959	}
2960 
2961	handler := s.VNodeService.FinishLeave
2962	if s.interceptor != nil {
2963		handler = func(ctx context.Context, req *MembershipConclusionRequest) (*MembershipConclusionResponse, error) {
2964			resp, err := s.interceptor(
2965				func(ctx context.Context, req interface{}) (interface{}, error) {
2966					typedReq, ok := req.(*MembershipConclusionRequest)
2967					if !ok {
2968						return nil, twirp.InternalError("failed type assertion req.(*MembershipConclusionRequest) when calling interceptor")
2969					}
2970					return s.VNodeService.FinishLeave(ctx, typedReq)
2971				},
2972			)(ctx, req)
2973			if resp != nil {
2974				typedResp, ok := resp.(*MembershipConclusionResponse)
2975				if !ok {
2976					return nil, twirp.InternalError("failed type assertion resp.(*MembershipConclusionResponse) when calling interceptor")
2977				}
2978				return typedResp, err
2979			}
2980			return nil, err
2981		}
2982	}
2983 
2984	// Call service method
2985	var respContent *MembershipConclusionResponse
2986	func() {
2987		defer ensurePanicResponses(ctx, resp, s.hooks)
2988		respContent, err = handler(ctx, reqContent)
2989	}()
2990 
2991	if err != nil {
2992		s.writeError(ctx, resp, err)
2993		return
2994	}
2995	if respContent == nil {
2996		s.writeError(ctx, resp, twirp.InternalError("received a nil *MembershipConclusionResponse and nil error while calling FinishLeave. nil responses are not supported"))
2997		return
2998	}
2999 
3000	ctx = callResponsePrepared(ctx, s.hooks)
3001 
3002	respBytes, err := respContent.MarshalVT()
3003	if err != nil {
3004		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
3005		return
3006	}
3007 
3008	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3009	resp.Header().Set("Content-Type", "application/protobuf")
3010	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3011	resp.WriteHeader(http.StatusOK)
3012	if n, err := resp.Write(respBytes); err != nil {
3013		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3014		twerr := twirp.NewError(twirp.Unknown, msg)
3015		ctx = callError(ctx, s.hooks, twerr)
3016	}
3017	callResponseSent(ctx, s.hooks)
3018}
3019 
3020func (s *vNodeServiceServer) ServiceDescriptor() ([]byte, int) {
3021	return twirpFileDescriptor0, 0
3022}
3023 
3024func (s *vNodeServiceServer) ProtocGenTwirpVersion() string {
3025	return "v8.1.3"
3026}
3027 
3028// PathPrefix returns the base service path, in the form: "/<prefix>/<package>.<Service>/"
3029// that is everything in a Twirp route except for the <Method>. This can be used for routing,
3030// for example to identify the requests that are targeted to this service in a mux.
3031func (s *vNodeServiceServer) PathPrefix() string {
3032	return baseServicePath(s.pathPrefix, "protocol", "VNodeService")
3033}
3034 
3035// =====
3036// Utils
3037// =====
3038 
3039// HTTPClient is the interface used by generated clients to send HTTP requests.
3040// It is fulfilled by *(net/http).Client, which is sufficient for most users.
3041// Users can provide their own implementation for special retry policies.
3042//
3043// HTTPClient implementations should not follow redirects. Redirects are
3044// automatically disabled if *(net/http).Client is passed to client
3045// constructors. See the withoutRedirects function in this file for more
3046// details.
3047type HTTPClient interface {
3048	Do(req *http.Request) (*http.Response, error)
3049}
3050 
3051// TwirpServer is the interface generated server structs will support: they're
3052// HTTP handlers with additional methods for accessing metadata about the
3053// service. Those accessors are a low-level API for building reflection tools.
3054// Most people can think of TwirpServers as just http.Handlers.
3055type TwirpServer interface {
3056	http.Handler
3057 
3058	// ServiceDescriptor returns gzipped bytes describing the .proto file that
3059	// this service was generated from. Once unzipped, the bytes can be
3060	// unmarshalled as a
3061	// google.golang.org/protobuf/types/descriptorpb.FileDescriptorProto.
3062	//
3063	// The returned integer is the index of this particular service within that
3064	// FileDescriptorProto's 'Service' slice of ServiceDescriptorProtos. This is a
3065	// low-level field, expected to be used for reflection.
3066	ServiceDescriptor() ([]byte, int)
3067 
3068	// ProtocGenTwirpVersion is the semantic version string of the version of
3069	// twirp used to generate this file.
3070	ProtocGenTwirpVersion() string
3071 
3072	// PathPrefix returns the HTTP URL path prefix for all methods handled by this
3073	// service. This can be used with an HTTP mux to route Twirp requests.
3074	// The path prefix is in the form: "/<prefix>/<package>.<Service>/"
3075	// that is, everything in a Twirp route except for the <Method> at the end.
3076	PathPrefix() string
3077}
3078 
3079func newServerOpts(opts []interface{}) *twirp.ServerOptions {
3080	serverOpts := &twirp.ServerOptions{}
3081	for _, opt := range opts {
3082		switch o := opt.(type) {
3083		case twirp.ServerOption:
3084			o(serverOpts)
3085		case *twirp.ServerHooks: // backwards compatibility, allow to specify hooks as an argument
3086			twirp.WithServerHooks(o)(serverOpts)
3087		case nil: // backwards compatibility, allow nil value for the argument
3088			continue
3089		default:
3090			panic(fmt.Sprintf("Invalid option type %T, please use a twirp.ServerOption", o))
3091		}
3092	}
3093	return serverOpts
3094}
3095 
3096// WriteError writes an HTTP response with a valid Twirp error format (code, msg, meta).
3097// Useful outside of the Twirp server (e.g. http middleware), but does not trigger hooks.
3098// If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err)
3099func WriteError(resp http.ResponseWriter, err error) {
3100	writeError(context.Background(), resp, err, nil)
3101}
3102 
3103// writeError writes Twirp errors in the response and triggers hooks.
3104func writeError(ctx context.Context, resp http.ResponseWriter, err error, hooks *twirp.ServerHooks) {
3105	// Convert to a twirp.Error. Non-twirp errors are converted to internal errors.
3106	var twerr twirp.Error
3107	if !errors.As(err, &twerr) {
3108		twerr = twirp.InternalErrorWith(err)
3109	}
3110 
3111	statusCode := twirp.ServerHTTPStatusFromErrorCode(twerr.Code())
3112	ctx = ctxsetters.WithStatusCode(ctx, statusCode)
3113	ctx = callError(ctx, hooks, twerr)
3114 
3115	respBody := marshalErrorToJSON(twerr)
3116 
3117	resp.Header().Set("Content-Type", "application/json") // Error responses are always JSON
3118	resp.Header().Set("Content-Length", strconv.Itoa(len(respBody)))
3119	resp.WriteHeader(statusCode) // set HTTP status code and send response
3120 
3121	_, writeErr := resp.Write(respBody)
3122	if writeErr != nil {
3123		// We have three options here. We could log the error, call the Error
3124		// hook, or just silently ignore the error.
3125		//
3126		// Logging is unacceptable because we don't have a user-controlled
3127		// logger; writing out to stderr without permission is too rude.
3128		//
3129		// Calling the Error hook would confuse users: it would mean the Error
3130		// hook got called twice for one request, which is likely to lead to
3131		// duplicated log messages and metrics, no matter how well we document
3132		// the behavior.
3133		//
3134		// Silently ignoring the error is our least-bad option. It's highly
3135		// likely that the connection is broken and the original 'err' says
3136		// so anyway.
3137		_ = writeErr
3138	}
3139 
3140	callResponseSent(ctx, hooks)
3141}
3142 
3143// sanitizeBaseURL parses the the baseURL, and adds the "http" scheme if needed.
3144// If the URL is unparsable, the baseURL is returned unchanged.
3145func sanitizeBaseURL(baseURL string) string {
3146	u, err := url.Parse(baseURL)
3147	if err != nil {
3148		return baseURL // invalid URL will fail later when making requests
3149	}
3150	if u.Scheme == "" {
3151		u.Scheme = "http"
3152	}
3153	return u.String()
3154}
3155 
3156// baseServicePath composes the path prefix for the service (without <Method>).
3157// e.g.: baseServicePath("/twirp", "my.pkg", "MyService")
3158//
3159//	returns => "/twirp/my.pkg.MyService/"
3160//
3161// e.g.: baseServicePath("", "", "MyService")
3162//
3163//	returns => "/MyService/"
3164func baseServicePath(prefix, pkg, service string) string {
3165	fullServiceName := service
3166	if pkg != "" {
3167		fullServiceName = pkg + "." + service
3168	}
3169	return path.Join("/", prefix, fullServiceName) + "/"
3170}
3171 
3172// parseTwirpPath extracts path components form a valid Twirp route.
3173// Expected format: "[<prefix>]/<package>.<Service>/<Method>"
3174// e.g.: prefix, pkgService, method := parseTwirpPath("/twirp/pkg.Svc/MakeHat")
3175func parseTwirpPath(path string) (string, string, string) {
3176	parts := strings.Split(path, "/")
3177	if len(parts) < 2 {
3178		return "", "", ""
3179	}
3180	method := parts[len(parts)-1]
3181	pkgService := parts[len(parts)-2]
3182	prefix := strings.Join(parts[0:len(parts)-2], "/")
3183	return prefix, pkgService, method
3184}
3185 
3186// getCustomHTTPReqHeaders retrieves a copy of any headers that are set in
3187// a context through the twirp.WithHTTPRequestHeaders function.
3188// If there are no headers set, or if they have the wrong type, nil is returned.
3189func getCustomHTTPReqHeaders(ctx context.Context) http.Header {
3190	header, ok := twirp.HTTPRequestHeaders(ctx)
3191	if !ok || header == nil {
3192		return nil
3193	}
3194	copied := make(http.Header)
3195	for k, vv := range header {
3196		if vv == nil {
3197			copied[k] = nil
3198			continue
3199		}
3200		copied[k] = make([]string, len(vv))
3201		copy(copied[k], vv)
3202	}
3203	return copied
3204}
3205 
3206// newRequest makes an http.Request from a client, adding common headers.
3207func newRequest(ctx context.Context, url string, reqBody io.Reader, contentType string) (*http.Request, error) {
3208	req, err := http.NewRequest("POST", url, reqBody)
3209	if err != nil {
3210		return nil, err
3211	}
3212	req = req.WithContext(ctx)
3213	if customHeader := getCustomHTTPReqHeaders(ctx); customHeader != nil {
3214		req.Header = customHeader
3215	}
3216	req.Header.Set("Accept", contentType)
3217	req.Header.Set("Content-Type", contentType)
3218	req.Header.Set("Twirp-Version", "v8.1.3")
3219	return req, nil
3220}
3221 
3222// JSON serialization for errors
3223type twerrJSON struct {
3224	Code string            `json:"code"`
3225	Msg  string            `json:"msg"`
3226	Meta map[string]string `json:"meta,omitempty"`
3227}
3228 
3229// marshalErrorToJSON returns JSON from a twirp.Error, that can be used as HTTP error response body.
3230// If serialization fails, it will use a descriptive Internal error instead.
3231func marshalErrorToJSON(twerr twirp.Error) []byte {
3232	// make sure that msg is not too large
3233	msg := twerr.Msg()
3234	if len(msg) > 1e6 {
3235		msg = msg[:1e6]
3236	}
3237 
3238	tj := twerrJSON{
3239		Code: string(twerr.Code()),
3240		Msg:  msg,
3241		Meta: twerr.MetaMap(),
3242	}
3243 
3244	buf, err := json.Marshal(&tj)
3245	if err != nil {
3246		buf = []byte("{\"type\": \"" + twirp.Internal + "\", \"msg\": \"There was an error but it could not be serialized into JSON\"}") // fallback
3247	}
3248 
3249	return buf
3250}
3251 
3252// errorFromResponse builds a twirp.Error from a non-200 HTTP response.
3253// If the response has a valid serialized Twirp error, then it's returned.
3254// If not, the response status code is used to generate a similar twirp
3255// error. See twirpErrorFromIntermediary for more info on intermediary errors.
3256func errorFromResponse(resp *http.Response) twirp.Error {
3257	statusCode := resp.StatusCode
3258	statusText := http.StatusText(statusCode)
3259 
3260	if isHTTPRedirect(statusCode) {
3261		// Unexpected redirect: it must be an error from an intermediary.
3262		// Twirp clients don't follow redirects automatically, Twirp only handles
3263		// POST requests, redirects should only happen on GET and HEAD requests.
3264		location := resp.Header.Get("Location")
3265		msg := fmt.Sprintf("unexpected HTTP status code %d %q received, Location=%q", statusCode, statusText, location)
3266		return twirpErrorFromIntermediary(statusCode, msg, location)
3267	}
3268 
3269	respBodyBytes, err := io.ReadAll(resp.Body)
3270	if err != nil {
3271		return wrapInternal(err, "failed to read server error response body")
3272	}
3273 
3274	var tj twerrJSON
3275	dec := json.NewDecoder(bytes.NewReader(respBodyBytes))
3276	dec.DisallowUnknownFields()
3277	if err := dec.Decode(&tj); err != nil || tj.Code == "" {
3278		// Invalid JSON response; it must be an error from an intermediary.
3279		msg := fmt.Sprintf("Error from intermediary with HTTP status code %d %q", statusCode, statusText)
3280		return twirpErrorFromIntermediary(statusCode, msg, string(respBodyBytes))
3281	}
3282 
3283	errorCode := twirp.ErrorCode(tj.Code)
3284	if !twirp.IsValidErrorCode(errorCode) {
3285		msg := "invalid type returned from server error response: " + tj.Code
3286		return twirp.InternalError(msg).WithMeta("body", string(respBodyBytes))
3287	}
3288 
3289	twerr := twirp.NewError(errorCode, tj.Msg)
3290	for k, v := range tj.Meta {
3291		twerr = twerr.WithMeta(k, v)
3292	}
3293	return twerr
3294}
3295 
3296// twirpErrorFromIntermediary maps HTTP errors from non-twirp sources to twirp errors.
3297// The mapping is similar to gRPC: https://github.com/grpc/grpc/blob/master/doc/http-grpc-status-mapping.md.
3298// Returned twirp Errors have some additional metadata for inspection.
3299func twirpErrorFromIntermediary(status int, msg string, bodyOrLocation string) twirp.Error {
3300	var code twirp.ErrorCode
3301	if isHTTPRedirect(status) { // 3xx
3302		code = twirp.Internal
3303	} else {
3304		switch status {
3305		case 400: // Bad Request
3306			code = twirp.Internal
3307		case 401: // Unauthorized
3308			code = twirp.Unauthenticated
3309		case 403: // Forbidden
3310			code = twirp.PermissionDenied
3311		case 404: // Not Found
3312			code = twirp.BadRoute
3313		case 429: // Too Many Requests
3314			code = twirp.ResourceExhausted
3315		case 502, 503, 504: // Bad Gateway, Service Unavailable, Gateway Timeout
3316			code = twirp.Unavailable
3317		default: // All other codes
3318			code = twirp.Unknown
3319		}
3320	}
3321 
3322	twerr := twirp.NewError(code, msg)
3323	twerr = twerr.WithMeta("http_error_from_intermediary", "true") // to easily know if this error was from intermediary
3324	twerr = twerr.WithMeta("status_code", strconv.Itoa(status))
3325	if isHTTPRedirect(status) {
3326		twerr = twerr.WithMeta("location", bodyOrLocation)
3327	} else {
3328		twerr = twerr.WithMeta("body", bodyOrLocation)
3329	}
3330	return twerr
3331}
3332 
3333func isHTTPRedirect(status int) bool {
3334	return status >= 300 && status <= 399
3335}
3336 
3337// wrapInternal wraps an error with a prefix as an Internal error.
3338// The original error cause is accessible by github.com/pkg/errors.Cause.
3339func wrapInternal(err error, prefix string) twirp.Error {
3340	return twirp.InternalErrorWith(&wrappedError{prefix: prefix, cause: err})
3341}
3342 
3343type wrappedError struct {
3344	prefix string
3345	cause  error
3346}
3347 
3348func (e *wrappedError) Error() string { return e.prefix + ": " + e.cause.Error() }
3349func (e *wrappedError) Unwrap() error { return e.cause } // for go1.13 + errors.Is/As
3350func (e *wrappedError) Cause() error  { return e.cause } // for github.com/pkg/errors
3351 
3352// ensurePanicResponses makes sure that rpc methods causing a panic still result in a Twirp Internal
3353// error response (status 500), and error hooks are properly called with the panic wrapped as an error.
3354// The panic is re-raised so it can be handled normally with middleware.
3355func ensurePanicResponses(ctx context.Context, resp http.ResponseWriter, hooks *twirp.ServerHooks) {
3356	if r := recover(); r != nil {
3357		// Wrap the panic as an error so it can be passed to error hooks.
3358		// The original error is accessible from error hooks, but not visible in the response.
3359		err := errFromPanic(r)
3360		twerr := &internalWithCause{msg: "Internal service panic", cause: err}
3361		// Actually write the error
3362		writeError(ctx, resp, twerr, hooks)
3363		// If possible, flush the error to the wire.
3364		f, ok := resp.(http.Flusher)
3365		if ok {
3366			f.Flush()
3367		}
3368 
3369		panic(r)
3370	}
3371}
3372 
3373// errFromPanic returns the typed error if the recovered panic is an error, otherwise formats as error.
3374func errFromPanic(p interface{}) error {
3375	if err, ok := p.(error); ok {
3376		return err
3377	}
3378	return fmt.Errorf("panic: %v", p)
3379}
3380 
3381// internalWithCause is a Twirp Internal error wrapping an original error cause,
3382// but the original error message is not exposed on Msg(). The original error
3383// can be checked with go1.13+ errors.Is/As, and also by (github.com/pkg/errors).Unwrap
3384type internalWithCause struct {
3385	msg   string
3386	cause error
3387}
3388 
3389func (e *internalWithCause) Unwrap() error                               { return e.cause } // for go1.13 + errors.Is/As
3390func (e *internalWithCause) Cause() error                                { return e.cause } // for github.com/pkg/errors
3391func (e *internalWithCause) Error() string                               { return e.msg + ": " + e.cause.Error() }
3392func (e *internalWithCause) Code() twirp.ErrorCode                       { return twirp.Internal }
3393func (e *internalWithCause) Msg() string                                 { return e.msg }
3394func (e *internalWithCause) Meta(key string) string                      { return "" }
3395func (e *internalWithCause) MetaMap() map[string]string                  { return nil }
3396func (e *internalWithCause) WithMeta(key string, val string) twirp.Error { return e }
3397 
3398// malformedRequestError is used when the twirp server cannot unmarshal a request
3399func malformedRequestError(msg string) twirp.Error {
3400	return twirp.NewError(twirp.Malformed, msg)
3401}
3402 
3403// badRouteError is used when the twirp server cannot route a request
3404func badRouteError(msg string, method, url string) twirp.Error {
3405	err := twirp.NewError(twirp.BadRoute, msg)
3406	err = err.WithMeta("twirp_invalid_route", method+" "+url)
3407	return err
3408}
3409 
3410// withoutRedirects makes sure that the POST request can not be redirected.
3411// The standard library will, by default, redirect requests (including POSTs) if it gets a 302 or
3412// 303 response, and also 301s in go1.8. It redirects by making a second request, changing the
3413// method to GET and removing the body. This produces very confusing error messages, so instead we
3414// set a redirect policy that always errors. This stops Go from executing the redirect.
3415//
3416// We have to be a little careful in case the user-provided http.Client has its own CheckRedirect
3417// policy - if so, we'll run through that policy first.
3418//
3419// Because this requires modifying the http.Client, we make a new copy of the client and return it.
3420func withoutRedirects(in *http.Client) *http.Client {
3421	copy := *in
3422	copy.CheckRedirect = func(req *http.Request, via []*http.Request) error {
3423		if in.CheckRedirect != nil {
3424			// Run the input's redirect if it exists, in case it has side effects, but ignore any error it
3425			// returns, since we want to use ErrUseLastResponse.
3426			err := in.CheckRedirect(req, via)
3427			_ = err // Silly, but this makes sure generated code passes errcheck -blank, which some people use.
3428		}
3429		return http.ErrUseLastResponse
3430	}
3431	return &copy
3432}
3433 
3434// doProtobufRequest makes a Protobuf request to the remote Twirp service.
3435func doProtobufRequest(ctx context.Context, client HTTPClient, hooks *twirp.ClientHooks, url string, in, out vtMarshaler) (_ context.Context, err error) {
3436	reqBodyBytes, err := in.MarshalVT()
3437	if err != nil {
3438		return ctx, wrapInternal(err, "failed to marshal proto request")
3439	}
3440	reqBody := bytes.NewBuffer(reqBodyBytes)
3441	if err = ctx.Err(); err != nil {
3442		return ctx, wrapInternal(err, "aborted because context was done")
3443	}
3444 
3445	req, err := newRequest(ctx, url, reqBody, "application/protobuf")
3446	if err != nil {
3447		return ctx, wrapInternal(err, "could not build request")
3448	}
3449	ctx, err = callClientRequestPrepared(ctx, hooks, req)
3450	if err != nil {
3451		return ctx, err
3452	}
3453 
3454	req = req.WithContext(ctx)
3455	resp, err := client.Do(req)
3456	if err != nil {
3457		return ctx, wrapInternal(err, "failed to do request")
3458	}
3459	defer func() { _ = resp.Body.Close() }()
3460 
3461	if err = ctx.Err(); err != nil {
3462		return ctx, wrapInternal(err, "aborted because context was done")
3463	}
3464 
3465	if resp.StatusCode != 200 {
3466		return ctx, errorFromResponse(resp)
3467	}
3468 
3469	respBodyBytes, err := io.ReadAll(resp.Body)
3470	if err != nil {
3471		return ctx, wrapInternal(err, "failed to read response body")
3472	}
3473	if err = ctx.Err(); err != nil {
3474		return ctx, wrapInternal(err, "aborted because context was done")
3475	}
3476 
3477	if err = out.UnmarshalVT(respBodyBytes); err != nil {
3478		return ctx, wrapInternal(err, "failed to unmarshal proto response")
3479	}
3480	return ctx, nil
3481}
3482 
3483// doJSONRequest makes a JSON request to the remote Twirp service.
3484func doJSONRequest(ctx context.Context, client HTTPClient, hooks *twirp.ClientHooks, url string, in, out proto.Message) (_ context.Context, err error) {
3485	marshaler := &protojson.MarshalOptions{UseProtoNames: true}
3486	reqBytes, err := marshaler.Marshal(in)
3487	if err != nil {
3488		return ctx, wrapInternal(err, "failed to marshal json request")
3489	}
3490	if err = ctx.Err(); err != nil {
3491		return ctx, wrapInternal(err, "aborted because context was done")
3492	}
3493 
3494	req, err := newRequest(ctx, url, bytes.NewReader(reqBytes), "application/json")
3495	if err != nil {
3496		return ctx, wrapInternal(err, "could not build request")
3497	}
3498	ctx, err = callClientRequestPrepared(ctx, hooks, req)
3499	if err != nil {
3500		return ctx, err
3501	}
3502 
3503	req = req.WithContext(ctx)
3504	resp, err := client.Do(req)
3505	if err != nil {
3506		return ctx, wrapInternal(err, "failed to do request")
3507	}
3508 
3509	defer func() {
3510		cerr := resp.Body.Close()
3511		if err == nil && cerr != nil {
3512			err = wrapInternal(cerr, "failed to close response body")
3513		}
3514	}()
3515 
3516	if err = ctx.Err(); err != nil {
3517		return ctx, wrapInternal(err, "aborted because context was done")
3518	}
3519 
3520	if resp.StatusCode != 200 {
3521		return ctx, errorFromResponse(resp)
3522	}
3523 
3524	d := json.NewDecoder(resp.Body)
3525	rawRespBody := json.RawMessage{}
3526	if err := d.Decode(&rawRespBody); err != nil {
3527		return ctx, wrapInternal(err, "failed to unmarshal json response")
3528	}
3529	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
3530	if err = unmarshaler.Unmarshal(rawRespBody, out); err != nil {
3531		return ctx, wrapInternal(err, "failed to unmarshal json response")
3532	}
3533	if err = ctx.Err(); err != nil {
3534		return ctx, wrapInternal(err, "aborted because context was done")
3535	}
3536	return ctx, nil
3537}
3538 
3539// Call twirp.ServerHooks.RequestReceived if the hook is available
3540func callRequestReceived(ctx context.Context, h *twirp.ServerHooks) (context.Context, error) {
3541	if h == nil || h.RequestReceived == nil {
3542		return ctx, nil
3543	}
3544	return h.RequestReceived(ctx)
3545}
3546 
3547// Call twirp.ServerHooks.RequestRouted if the hook is available
3548func callRequestRouted(ctx context.Context, h *twirp.ServerHooks) (context.Context, error) {
3549	if h == nil || h.RequestRouted == nil {
3550		return ctx, nil
3551	}
3552	return h.RequestRouted(ctx)
3553}
3554 
3555// Call twirp.ServerHooks.ResponsePrepared if the hook is available
3556func callResponsePrepared(ctx context.Context, h *twirp.ServerHooks) context.Context {
3557	if h == nil || h.ResponsePrepared == nil {
3558		return ctx
3559	}
3560	return h.ResponsePrepared(ctx)
3561}
3562 
3563// Call twirp.ServerHooks.ResponseSent if the hook is available
3564func callResponseSent(ctx context.Context, h *twirp.ServerHooks) {
3565	if h == nil || h.ResponseSent == nil {
3566		return
3567	}
3568	h.ResponseSent(ctx)
3569}
3570 
3571// Call twirp.ServerHooks.Error if the hook is available
3572func callError(ctx context.Context, h *twirp.ServerHooks, err twirp.Error) context.Context {
3573	if h == nil || h.Error == nil {
3574		return ctx
3575	}
3576	return h.Error(ctx, err)
3577}
3578 
3579func callClientResponseReceived(ctx context.Context, h *twirp.ClientHooks) {
3580	if h == nil || h.ResponseReceived == nil {
3581		return
3582	}
3583	h.ResponseReceived(ctx)
3584}
3585 
3586func callClientRequestPrepared(ctx context.Context, h *twirp.ClientHooks, req *http.Request) (context.Context, error) {
3587	if h == nil || h.RequestPrepared == nil {
3588		return ctx, nil
3589	}
3590	return h.RequestPrepared(ctx, req)
3591}
3592 
3593func callClientError(ctx context.Context, h *twirp.ClientHooks, err twirp.Error) {
3594	if h == nil || h.Error == nil {
3595		return
3596	}
3597	h.Error(ctx, err)
3598}
3599 
3600var twirpFileDescriptor0 = []byte{
3601	// 593 bytes of a gzipped FileDescriptorProto
3602	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x51, 0x6f, 0xd3, 0x3c,
3603	0x14, 0x55, 0xb7, 0x7d, 0x5d, 0x77, 0xbb, 0xf5, 0x1b, 0x56, 0xdb, 0x85, 0x30, 0x8d, 0xca, 0x12,
3604	0x63, 0x02, 0x94, 0xa2, 0x21, 0x9e, 0x90, 0x86, 0x06, 0xda, 0x0a, 0x13, 0x4c, 0x55, 0x0b, 0x3c,
3605	0x00, 0x2f, 0x6d, 0x72, 0x69, 0x0d, 0x69, 0x1c, 0xe2, 0x74, 0x52, 0xf9, 0x35, 0xfc, 0x54, 0xd4,
3606	0xc4, 0xae, 0x9d, 0x2c, 0x61, 0x02, 0xf1, 0x54, 0xfb, 0xde, 0xe3, 0x73, 0x8e, 0x6f, 0x7d, 0x14,
3607	0x68, 0x8b, 0x10, 0xdd, 0x6e, 0x18, 0xf1, 0x98, 0x77, 0xdd, 0x29, 0x8f, 0x3c, 0x27, 0x59, 0x93,
3608	0x5a, 0xf2, 0xe3, 0x72, 0xdf, 0x6e, 0x19, 0x88, 0x80, 0x7b, 0x98, 0x02, 0xe8, 0x26, 0xfc, 0x77,
3609	0x36, 0x0b, 0xe3, 0x05, 0xbd, 0x05, 0xff, 0xbf, 0xf6, 0x30, 0x88, 0x59, 0xbc, 0x18, 0xe0, 0xf7,
3610	0x39, 0x8a, 0x98, 0x9e, 0xc0, 0xae, 0x2e, 0x89, 0x90, 0x07, 0x02, 0xc9, 0x03, 0xa8, 0x31, 0x59,
3611	0xb3, 0x2a, 0x9d, 0xca, 0x51, 0xfd, 0xb8, 0xe1, 0x28, 0x0d, 0xe7, 0x92, 0x7b, 0x38, 0x58, 0xf5,
3612	0xe9, 0x0e, 0xd4, 0xfb, 0x2c, 0x98, 0x28, 0xba, 0x06, 0x6c, 0xa7, 0xdb, 0x94, 0x8a, 0x9e, 0xc2,
3613	0xce, 0x25, 0x8f, 0xd9, 0x17, 0xa5, 0x47, 0x1e, 0x43, 0x3d, 0x8c, 0xd0, 0x43, 0x17, 0x85, 0xe0,
3614	0x51, 0x09, 0xbd, 0x09, 0xa1, 0xbb, 0xd0, 0x50, 0x14, 0x92, 0xf4, 0x08, 0x9a, 0xe7, 0x2c, 0xf0,
3615	0x86, 0x73, 0x37, 0x85, 0x28, 0xee, 0x5d, 0x58, 0xff, 0x86, 0xa9, 0xe5, 0x8d, 0xc1, 0x72, 0x49,
3616	0xcf, 0xa0, 0x95, 0x43, 0xca, 0x2b, 0x3e, 0x82, 0x2d, 0xa1, 0x8a, 0x25, 0x26, 0x34, 0x80, 0xee,
3617	0x41, 0xab, 0x87, 0x71, 0x5f, 0x9b, 0x52, 0xd7, 0xbd, 0x80, 0x76, 0xbe, 0x21, 0x05, 0xfe, 0xfc,
3618	0x9e, 0x6d, 0x68, 0xf6, 0x30, 0x5e, 0x59, 0x15, 0x4a, 0xa3, 0x97, 0x88, 0x9b, 0x75, 0x29, 0xe1,
3619	0x00, 0xac, 0x2c, 0x0a, 0xab, 0xd2, 0x59, 0x2f, 0x50, 0x30, 0x10, 0xf4, 0x04, 0x9a, 0x92, 0xf3,
3620	0x1d, 0xbf, 0xe0, 0x2c, 0x50, 0x63, 0x3b, 0x84, 0xea, 0x57, 0xce, 0x02, 0x2c, 0x73, 0x29, 0xbb,
3621	0x74, 0x01, 0xad, 0xdc, 0xf9, 0xbf, 0xbd, 0x6b, 0xce, 0xfa, 0xda, 0x8d, 0xd6, 0x9f, 0x1b, 0xd2,
3622	0x6f, 0x70, 0x74, 0x85, 0x86, 0x77, 0x7f, 0xb9, 0x2f, 0xf5, 0x9e, 0x76, 0xa9, 0x05, 0xed, 0x3c,
3623	0x81, 0x7c, 0x4c, 0xef, 0xe1, 0xce, 0x5b, 0x9c, 0x8d, 0x31, 0x12, 0x53, 0x16, 0xbe, 0xe4, 0x81,
3624	0xeb, 0xcf, 0x05, 0xe3, 0xab, 0xe1, 0xec, 0xc3, 0x96, 0x88, 0x47, 0x63, 0xe6, 0xb3, 0x1f, 0x98,
3625	0x68, 0xd4, 0x06, 0xba, 0x40, 0x2c, 0xd8, 0x8c, 0xd0, 0xc7, 0x91, 0x40, 0x6b, 0x2d, 0xe9, 0xa9,
3626	0x2d, 0x3d, 0x80, 0xfd, 0x62, 0xda, 0x54, 0xf6, 0xf8, 0x67, 0x15, 0xb6, 0x3f, 0x2c, 0x2d, 0x0e,
3627	0x31, 0xba, 0x62, 0x2e, 0x92, 0x53, 0xa8, 0xa9, 0x20, 0x92, 0xdb, 0xfa, 0x16, 0xb9, 0xbc, 0xda,
3628	0x76, 0x51, 0x4b, 0xfe, 0x0f, 0x4f, 0x61, 0x63, 0x19, 0x3e, 0xd2, 0xd2, 0x18, 0x23, 0x9b, 0x76,
3629	0x3b, 0x5f, 0x96, 0xc7, 0x9e, 0x41, 0x35, 0x0d, 0x18, 0xd9, 0x33, 0xa7, 0x67, 0xa4, 0xd6, 0xb6,
3630	0xae, 0x37, 0xe4, 0xe1, 0x3e, 0xec, 0x64, 0x12, 0x46, 0x0e, 0x34, 0xb4, 0x28, 0xa4, 0xf6, 0xdd,
3631	0xd2, 0xbe, 0x66, 0xcc, 0xbc, 0x77, 0x93, 0xb1, 0x28, 0x20, 0x26, 0x63, 0x71, 0x50, 0x86, 0xd0,
3632	0xc8, 0xa6, 0x94, 0x64, 0x8f, 0x5c, 0x0f, 0xb6, 0xdd, 0x29, 0x07, 0x68, 0x9b, 0x99, 0x34, 0x98,
3633	0x36, 0x8b, 0x62, 0x66, 0xda, 0x2c, 0x8e, 0xd1, 0x27, 0x80, 0x73, 0x16, 0x30, 0x31, 0x4d, 0xe8,
3634	0xee, 0x69, 0xf8, 0x6f, 0xde, 0xa7, 0x7d, 0x78, 0x13, 0x4c, 0xcf, 0x20, 0x1b, 0x00, 0x52, 0xe4,
3635	0xc7, 0xcc, 0x96, 0x39, 0x83, 0xe2, 0xec, 0x90, 0xcf, 0x50, 0x4f, 0x1d, 0xa7, 0x8c, 0xff, 0xd6,
3636	0xf2, 0x8b, 0x87, 0xaf, 0x2a, 0x1f, 0xef, 0x4f, 0xb8, 0x33, 0x63, 0xd1, 0x68, 0x82, 0x22, 0x1c,
3637	0xb9, 0xe8, 0xb8, 0xbc, 0xbb, 0xfc, 0xc6, 0xc5, 0x18, 0x75, 0xf5, 0xb7, 0xce, 0xe5, 0xfe, 0xb8,
3638	0x9a, 0xac, 0x9e, 0xfc, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x8e, 0x3d, 0x8a, 0xec, 0x25, 0x07, 0x00,
3639	0x00,
3640}