1
// Code generated by protoc-gen-twirp v8.1.3, DO NOT EDIT.
2
// source: spec/proto/tunnel.proto
3
 
4
package protocol
5
 
6
import context "context"
7
import fmt "fmt"
8
import http "net/http"
9
import io "io"
10
import json "encoding/json"
11
import strconv "strconv"
12
import strings "strings"
13
 
14
import protojson "google.golang.org/protobuf/encoding/protojson"
15
import twirp "github.com/twitchtv/twirp"
16
import ctxsetters "github.com/twitchtv/twirp/ctxsetters"
17
 
18
// Version compatibility assertion.
19
// If the constant is not defined in the package, that likely means
20
// the package needs to be updated to work with this generated code.
21
// See https://twitchtv.github.io/twirp/docs/version_matrix.html
22
const _ = twirp.TwirpPackageMinVersion_8_1_0
23
 
24
// =======================
25
// TunnelService Interface
26
// =======================
27
 
28
type TunnelService interface {
29
	MintDelegation(context.Context, *MintDelegationRequest) (*MintDelegationResponse, error)
30
 
31
	ListDelegations(context.Context, *ListDelegationsRequest) (*ListDelegationsResponse, error)
32
 
33
	RevokeDelegation(context.Context, *RevokeDelegationRequest) (*RevokeDelegationResponse, error)
34
 
35
	Ping(context.Context, *ClientPingRequest) (*ClientPingResponse, error)
36
 
37
	RegisterIdentity(context.Context, *RegisterIdentityRequest) (*RegisterIdentityResponse, error)
38
 
39
	GetNodes(context.Context, *GetNodesRequest) (*GetNodesResponse, error)
40
 
41
	GenerateHostname(context.Context, *GenerateHostnameRequest) (*GenerateHostnameResponse, error)
42
 
43
	RegisteredHostnames(context.Context, *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error)
44
 
45
	PublishTunnel(context.Context, *PublishTunnelRequest) (*PublishTunnelResponse, error)
46
 
47
	UnpublishTunnel(context.Context, *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error)
48
 
49
	ReleaseTunnel(context.Context, *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error)
50
 
51
	AcmeInstruction(context.Context, *InstructionRequest) (*InstructionResponse, error)
52
 
53
	AcmeValidate(context.Context, *ValidateRequest) (*ValidateResponse, error)
54
 
55
	OpenEphemeralSession(context.Context, *OpenEphemeralSessionRequest) (*OpenSessionResponse, error)
56
 
57
	OpenDelegatedSession(context.Context, *OpenDelegatedSessionRequest) (*OpenSessionResponse, error)
58
}
59
 
60
// =============================
61
// TunnelService Protobuf Client
62
// =============================
63
 
64
type tunnelServiceProtobufClient struct {
65
	client      HTTPClient
66
	urls        [15]string
67
	interceptor twirp.Interceptor
68
	opts        twirp.ClientOptions
69
}
70
 
71
// NewTunnelServiceProtobufClient creates a Protobuf client that implements the TunnelService interface.
72
// It communicates using Protobuf and can be configured with a custom HTTPClient.
73
func NewTunnelServiceProtobufClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) TunnelService {
74
	if c, ok := client.(*http.Client); ok {
75
		client = withoutRedirects(c)
76
	}
77
 
78
	clientOpts := twirp.ClientOptions{}
79
	for _, o := range opts {
80
		o(&clientOpts)
81
	}
82
 
83
	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
84
	literalURLs := false
85
	_ = clientOpts.ReadOpt("literalURLs", &literalURLs)
86
	var pathPrefix string
87
	if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
88
		pathPrefix = "/twirp" // default prefix
89
	}
90
 
91
	// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
92
	serviceURL := sanitizeBaseURL(baseURL)
93
	serviceURL += baseServicePath(pathPrefix, "protocol", "TunnelService")
94
	urls := [15]string{
95
		serviceURL + "MintDelegation",
96
		serviceURL + "ListDelegations",
97
		serviceURL + "RevokeDelegation",
98
		serviceURL + "Ping",
99
		serviceURL + "RegisterIdentity",
100
		serviceURL + "GetNodes",
101
		serviceURL + "GenerateHostname",
102
		serviceURL + "RegisteredHostnames",
103
		serviceURL + "PublishTunnel",
104
		serviceURL + "UnpublishTunnel",
105
		serviceURL + "ReleaseTunnel",
106
		serviceURL + "AcmeInstruction",
107
		serviceURL + "AcmeValidate",
108
		serviceURL + "OpenEphemeralSession",
109
		serviceURL + "OpenDelegatedSession",
110
	}
111
 
112
	return &tunnelServiceProtobufClient{
113
		client:      client,
114
		urls:        urls,
115
		interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...),
116
		opts:        clientOpts,
117
	}
118
}
119
 
120
func (c *tunnelServiceProtobufClient) MintDelegation(ctx context.Context, in *MintDelegationRequest) (*MintDelegationResponse, error) {
121
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
122
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
123
	ctx = ctxsetters.WithMethodName(ctx, "MintDelegation")
124
	caller := c.callMintDelegation
125
	if c.interceptor != nil {
126
		caller = func(ctx context.Context, req *MintDelegationRequest) (*MintDelegationResponse, error) {
127
			resp, err := c.interceptor(
128
				func(ctx context.Context, req interface{}) (interface{}, error) {
129
					typedReq, ok := req.(*MintDelegationRequest)
130
					if !ok {
131
						return nil, twirp.InternalError("failed type assertion req.(*MintDelegationRequest) when calling interceptor")
132
					}
133
					return c.callMintDelegation(ctx, typedReq)
134
				},
135
			)(ctx, req)
136
			if resp != nil {
137
				typedResp, ok := resp.(*MintDelegationResponse)
138
				if !ok {
139
					return nil, twirp.InternalError("failed type assertion resp.(*MintDelegationResponse) when calling interceptor")
140
				}
141
				return typedResp, err
142
			}
143
			return nil, err
144
		}
145
	}
146
	return caller(ctx, in)
147
}
148
 
149
func (c *tunnelServiceProtobufClient) callMintDelegation(ctx context.Context, in *MintDelegationRequest) (*MintDelegationResponse, error) {
150
	out := new(MintDelegationResponse)
151
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
152
	if err != nil {
153
		twerr, ok := err.(twirp.Error)
154
		if !ok {
155
			twerr = twirp.InternalErrorWith(err)
156
		}
157
		callClientError(ctx, c.opts.Hooks, twerr)
158
		return nil, err
159
	}
160
 
161
	callClientResponseReceived(ctx, c.opts.Hooks)
162
 
163
	return out, nil
164
}
165
 
166
func (c *tunnelServiceProtobufClient) ListDelegations(ctx context.Context, in *ListDelegationsRequest) (*ListDelegationsResponse, error) {
167
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
168
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
169
	ctx = ctxsetters.WithMethodName(ctx, "ListDelegations")
170
	caller := c.callListDelegations
171
	if c.interceptor != nil {
172
		caller = func(ctx context.Context, req *ListDelegationsRequest) (*ListDelegationsResponse, error) {
173
			resp, err := c.interceptor(
174
				func(ctx context.Context, req interface{}) (interface{}, error) {
175
					typedReq, ok := req.(*ListDelegationsRequest)
176
					if !ok {
177
						return nil, twirp.InternalError("failed type assertion req.(*ListDelegationsRequest) when calling interceptor")
178
					}
179
					return c.callListDelegations(ctx, typedReq)
180
				},
181
			)(ctx, req)
182
			if resp != nil {
183
				typedResp, ok := resp.(*ListDelegationsResponse)
184
				if !ok {
185
					return nil, twirp.InternalError("failed type assertion resp.(*ListDelegationsResponse) when calling interceptor")
186
				}
187
				return typedResp, err
188
			}
189
			return nil, err
190
		}
191
	}
192
	return caller(ctx, in)
193
}
194
 
195
func (c *tunnelServiceProtobufClient) callListDelegations(ctx context.Context, in *ListDelegationsRequest) (*ListDelegationsResponse, error) {
196
	out := new(ListDelegationsResponse)
197
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[1], in, out)
198
	if err != nil {
199
		twerr, ok := err.(twirp.Error)
200
		if !ok {
201
			twerr = twirp.InternalErrorWith(err)
202
		}
203
		callClientError(ctx, c.opts.Hooks, twerr)
204
		return nil, err
205
	}
206
 
207
	callClientResponseReceived(ctx, c.opts.Hooks)
208
 
209
	return out, nil
210
}
211
 
212
func (c *tunnelServiceProtobufClient) RevokeDelegation(ctx context.Context, in *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
213
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
214
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
215
	ctx = ctxsetters.WithMethodName(ctx, "RevokeDelegation")
216
	caller := c.callRevokeDelegation
217
	if c.interceptor != nil {
218
		caller = func(ctx context.Context, req *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
219
			resp, err := c.interceptor(
220
				func(ctx context.Context, req interface{}) (interface{}, error) {
221
					typedReq, ok := req.(*RevokeDelegationRequest)
222
					if !ok {
223
						return nil, twirp.InternalError("failed type assertion req.(*RevokeDelegationRequest) when calling interceptor")
224
					}
225
					return c.callRevokeDelegation(ctx, typedReq)
226
				},
227
			)(ctx, req)
228
			if resp != nil {
229
				typedResp, ok := resp.(*RevokeDelegationResponse)
230
				if !ok {
231
					return nil, twirp.InternalError("failed type assertion resp.(*RevokeDelegationResponse) when calling interceptor")
232
				}
233
				return typedResp, err
234
			}
235
			return nil, err
236
		}
237
	}
238
	return caller(ctx, in)
239
}
240
 
241
func (c *tunnelServiceProtobufClient) callRevokeDelegation(ctx context.Context, in *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
242
	out := new(RevokeDelegationResponse)
243
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[2], in, out)
244
	if err != nil {
245
		twerr, ok := err.(twirp.Error)
246
		if !ok {
247
			twerr = twirp.InternalErrorWith(err)
248
		}
249
		callClientError(ctx, c.opts.Hooks, twerr)
250
		return nil, err
251
	}
252
 
253
	callClientResponseReceived(ctx, c.opts.Hooks)
254
 
255
	return out, nil
256
}
257
 
258
func (c *tunnelServiceProtobufClient) Ping(ctx context.Context, in *ClientPingRequest) (*ClientPingResponse, error) {
259
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
260
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
261
	ctx = ctxsetters.WithMethodName(ctx, "Ping")
262
	caller := c.callPing
263
	if c.interceptor != nil {
264
		caller = func(ctx context.Context, req *ClientPingRequest) (*ClientPingResponse, error) {
265
			resp, err := c.interceptor(
266
				func(ctx context.Context, req interface{}) (interface{}, error) {
267
					typedReq, ok := req.(*ClientPingRequest)
268
					if !ok {
269
						return nil, twirp.InternalError("failed type assertion req.(*ClientPingRequest) when calling interceptor")
270
					}
271
					return c.callPing(ctx, typedReq)
272
				},
273
			)(ctx, req)
274
			if resp != nil {
275
				typedResp, ok := resp.(*ClientPingResponse)
276
				if !ok {
277
					return nil, twirp.InternalError("failed type assertion resp.(*ClientPingResponse) when calling interceptor")
278
				}
279
				return typedResp, err
280
			}
281
			return nil, err
282
		}
283
	}
284
	return caller(ctx, in)
285
}
286
 
287
func (c *tunnelServiceProtobufClient) callPing(ctx context.Context, in *ClientPingRequest) (*ClientPingResponse, error) {
288
	out := new(ClientPingResponse)
289
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[3], in, out)
290
	if err != nil {
291
		twerr, ok := err.(twirp.Error)
292
		if !ok {
293
			twerr = twirp.InternalErrorWith(err)
294
		}
295
		callClientError(ctx, c.opts.Hooks, twerr)
296
		return nil, err
297
	}
298
 
299
	callClientResponseReceived(ctx, c.opts.Hooks)
300
 
301
	return out, nil
302
}
303
 
304
func (c *tunnelServiceProtobufClient) RegisterIdentity(ctx context.Context, in *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
305
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
306
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
307
	ctx = ctxsetters.WithMethodName(ctx, "RegisterIdentity")
308
	caller := c.callRegisterIdentity
309
	if c.interceptor != nil {
310
		caller = func(ctx context.Context, req *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
311
			resp, err := c.interceptor(
312
				func(ctx context.Context, req interface{}) (interface{}, error) {
313
					typedReq, ok := req.(*RegisterIdentityRequest)
314
					if !ok {
315
						return nil, twirp.InternalError("failed type assertion req.(*RegisterIdentityRequest) when calling interceptor")
316
					}
317
					return c.callRegisterIdentity(ctx, typedReq)
318
				},
319
			)(ctx, req)
320
			if resp != nil {
321
				typedResp, ok := resp.(*RegisterIdentityResponse)
322
				if !ok {
323
					return nil, twirp.InternalError("failed type assertion resp.(*RegisterIdentityResponse) when calling interceptor")
324
				}
325
				return typedResp, err
326
			}
327
			return nil, err
328
		}
329
	}
330
	return caller(ctx, in)
331
}
332
 
333
func (c *tunnelServiceProtobufClient) callRegisterIdentity(ctx context.Context, in *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
334
	out := new(RegisterIdentityResponse)
335
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[4], in, out)
336
	if err != nil {
337
		twerr, ok := err.(twirp.Error)
338
		if !ok {
339
			twerr = twirp.InternalErrorWith(err)
340
		}
341
		callClientError(ctx, c.opts.Hooks, twerr)
342
		return nil, err
343
	}
344
 
345
	callClientResponseReceived(ctx, c.opts.Hooks)
346
 
347
	return out, nil
348
}
349
 
350
func (c *tunnelServiceProtobufClient) GetNodes(ctx context.Context, in *GetNodesRequest) (*GetNodesResponse, error) {
351
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
352
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
353
	ctx = ctxsetters.WithMethodName(ctx, "GetNodes")
354
	caller := c.callGetNodes
355
	if c.interceptor != nil {
356
		caller = func(ctx context.Context, req *GetNodesRequest) (*GetNodesResponse, error) {
357
			resp, err := c.interceptor(
358
				func(ctx context.Context, req interface{}) (interface{}, error) {
359
					typedReq, ok := req.(*GetNodesRequest)
360
					if !ok {
361
						return nil, twirp.InternalError("failed type assertion req.(*GetNodesRequest) when calling interceptor")
362
					}
363
					return c.callGetNodes(ctx, typedReq)
364
				},
365
			)(ctx, req)
366
			if resp != nil {
367
				typedResp, ok := resp.(*GetNodesResponse)
368
				if !ok {
369
					return nil, twirp.InternalError("failed type assertion resp.(*GetNodesResponse) when calling interceptor")
370
				}
371
				return typedResp, err
372
			}
373
			return nil, err
374
		}
375
	}
376
	return caller(ctx, in)
377
}
378
 
379
func (c *tunnelServiceProtobufClient) callGetNodes(ctx context.Context, in *GetNodesRequest) (*GetNodesResponse, error) {
380
	out := new(GetNodesResponse)
381
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[5], in, out)
382
	if err != nil {
383
		twerr, ok := err.(twirp.Error)
384
		if !ok {
385
			twerr = twirp.InternalErrorWith(err)
386
		}
387
		callClientError(ctx, c.opts.Hooks, twerr)
388
		return nil, err
389
	}
390
 
391
	callClientResponseReceived(ctx, c.opts.Hooks)
392
 
393
	return out, nil
394
}
395
 
396
func (c *tunnelServiceProtobufClient) GenerateHostname(ctx context.Context, in *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
397
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
398
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
399
	ctx = ctxsetters.WithMethodName(ctx, "GenerateHostname")
400
	caller := c.callGenerateHostname
401
	if c.interceptor != nil {
402
		caller = func(ctx context.Context, req *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
403
			resp, err := c.interceptor(
404
				func(ctx context.Context, req interface{}) (interface{}, error) {
405
					typedReq, ok := req.(*GenerateHostnameRequest)
406
					if !ok {
407
						return nil, twirp.InternalError("failed type assertion req.(*GenerateHostnameRequest) when calling interceptor")
408
					}
409
					return c.callGenerateHostname(ctx, typedReq)
410
				},
411
			)(ctx, req)
412
			if resp != nil {
413
				typedResp, ok := resp.(*GenerateHostnameResponse)
414
				if !ok {
415
					return nil, twirp.InternalError("failed type assertion resp.(*GenerateHostnameResponse) when calling interceptor")
416
				}
417
				return typedResp, err
418
			}
419
			return nil, err
420
		}
421
	}
422
	return caller(ctx, in)
423
}
424
 
425
func (c *tunnelServiceProtobufClient) callGenerateHostname(ctx context.Context, in *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
426
	out := new(GenerateHostnameResponse)
427
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[6], in, out)
428
	if err != nil {
429
		twerr, ok := err.(twirp.Error)
430
		if !ok {
431
			twerr = twirp.InternalErrorWith(err)
432
		}
433
		callClientError(ctx, c.opts.Hooks, twerr)
434
		return nil, err
435
	}
436
 
437
	callClientResponseReceived(ctx, c.opts.Hooks)
438
 
439
	return out, nil
440
}
441
 
442
func (c *tunnelServiceProtobufClient) RegisteredHostnames(ctx context.Context, in *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
443
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
444
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
445
	ctx = ctxsetters.WithMethodName(ctx, "RegisteredHostnames")
446
	caller := c.callRegisteredHostnames
447
	if c.interceptor != nil {
448
		caller = func(ctx context.Context, req *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
449
			resp, err := c.interceptor(
450
				func(ctx context.Context, req interface{}) (interface{}, error) {
451
					typedReq, ok := req.(*RegisteredHostnamesRequest)
452
					if !ok {
453
						return nil, twirp.InternalError("failed type assertion req.(*RegisteredHostnamesRequest) when calling interceptor")
454
					}
455
					return c.callRegisteredHostnames(ctx, typedReq)
456
				},
457
			)(ctx, req)
458
			if resp != nil {
459
				typedResp, ok := resp.(*RegisteredHostnamesResponse)
460
				if !ok {
461
					return nil, twirp.InternalError("failed type assertion resp.(*RegisteredHostnamesResponse) when calling interceptor")
462
				}
463
				return typedResp, err
464
			}
465
			return nil, err
466
		}
467
	}
468
	return caller(ctx, in)
469
}
470
 
471
func (c *tunnelServiceProtobufClient) callRegisteredHostnames(ctx context.Context, in *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
472
	out := new(RegisteredHostnamesResponse)
473
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
474
	if err != nil {
475
		twerr, ok := err.(twirp.Error)
476
		if !ok {
477
			twerr = twirp.InternalErrorWith(err)
478
		}
479
		callClientError(ctx, c.opts.Hooks, twerr)
480
		return nil, err
481
	}
482
 
483
	callClientResponseReceived(ctx, c.opts.Hooks)
484
 
485
	return out, nil
486
}
487
 
488
func (c *tunnelServiceProtobufClient) PublishTunnel(ctx context.Context, in *PublishTunnelRequest) (*PublishTunnelResponse, error) {
489
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
490
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
491
	ctx = ctxsetters.WithMethodName(ctx, "PublishTunnel")
492
	caller := c.callPublishTunnel
493
	if c.interceptor != nil {
494
		caller = func(ctx context.Context, req *PublishTunnelRequest) (*PublishTunnelResponse, error) {
495
			resp, err := c.interceptor(
496
				func(ctx context.Context, req interface{}) (interface{}, error) {
497
					typedReq, ok := req.(*PublishTunnelRequest)
498
					if !ok {
499
						return nil, twirp.InternalError("failed type assertion req.(*PublishTunnelRequest) when calling interceptor")
500
					}
501
					return c.callPublishTunnel(ctx, typedReq)
502
				},
503
			)(ctx, req)
504
			if resp != nil {
505
				typedResp, ok := resp.(*PublishTunnelResponse)
506
				if !ok {
507
					return nil, twirp.InternalError("failed type assertion resp.(*PublishTunnelResponse) when calling interceptor")
508
				}
509
				return typedResp, err
510
			}
511
			return nil, err
512
		}
513
	}
514
	return caller(ctx, in)
515
}
516
 
517
func (c *tunnelServiceProtobufClient) callPublishTunnel(ctx context.Context, in *PublishTunnelRequest) (*PublishTunnelResponse, error) {
518
	out := new(PublishTunnelResponse)
519
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
520
	if err != nil {
521
		twerr, ok := err.(twirp.Error)
522
		if !ok {
523
			twerr = twirp.InternalErrorWith(err)
524
		}
525
		callClientError(ctx, c.opts.Hooks, twerr)
526
		return nil, err
527
	}
528
 
529
	callClientResponseReceived(ctx, c.opts.Hooks)
530
 
531
	return out, nil
532
}
533
 
534
func (c *tunnelServiceProtobufClient) UnpublishTunnel(ctx context.Context, in *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
535
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
536
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
537
	ctx = ctxsetters.WithMethodName(ctx, "UnpublishTunnel")
538
	caller := c.callUnpublishTunnel
539
	if c.interceptor != nil {
540
		caller = func(ctx context.Context, req *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
541
			resp, err := c.interceptor(
542
				func(ctx context.Context, req interface{}) (interface{}, error) {
543
					typedReq, ok := req.(*UnpublishTunnelRequest)
544
					if !ok {
545
						return nil, twirp.InternalError("failed type assertion req.(*UnpublishTunnelRequest) when calling interceptor")
546
					}
547
					return c.callUnpublishTunnel(ctx, typedReq)
548
				},
549
			)(ctx, req)
550
			if resp != nil {
551
				typedResp, ok := resp.(*UnpublishTunnelResponse)
552
				if !ok {
553
					return nil, twirp.InternalError("failed type assertion resp.(*UnpublishTunnelResponse) when calling interceptor")
554
				}
555
				return typedResp, err
556
			}
557
			return nil, err
558
		}
559
	}
560
	return caller(ctx, in)
561
}
562
 
563
func (c *tunnelServiceProtobufClient) callUnpublishTunnel(ctx context.Context, in *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
564
	out := new(UnpublishTunnelResponse)
565
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[9], in, out)
566
	if err != nil {
567
		twerr, ok := err.(twirp.Error)
568
		if !ok {
569
			twerr = twirp.InternalErrorWith(err)
570
		}
571
		callClientError(ctx, c.opts.Hooks, twerr)
572
		return nil, err
573
	}
574
 
575
	callClientResponseReceived(ctx, c.opts.Hooks)
576
 
577
	return out, nil
578
}
579
 
580
func (c *tunnelServiceProtobufClient) ReleaseTunnel(ctx context.Context, in *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
581
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
582
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
583
	ctx = ctxsetters.WithMethodName(ctx, "ReleaseTunnel")
584
	caller := c.callReleaseTunnel
585
	if c.interceptor != nil {
586
		caller = func(ctx context.Context, req *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
587
			resp, err := c.interceptor(
588
				func(ctx context.Context, req interface{}) (interface{}, error) {
589
					typedReq, ok := req.(*ReleaseTunnelRequest)
590
					if !ok {
591
						return nil, twirp.InternalError("failed type assertion req.(*ReleaseTunnelRequest) when calling interceptor")
592
					}
593
					return c.callReleaseTunnel(ctx, typedReq)
594
				},
595
			)(ctx, req)
596
			if resp != nil {
597
				typedResp, ok := resp.(*ReleaseTunnelResponse)
598
				if !ok {
599
					return nil, twirp.InternalError("failed type assertion resp.(*ReleaseTunnelResponse) when calling interceptor")
600
				}
601
				return typedResp, err
602
			}
603
			return nil, err
604
		}
605
	}
606
	return caller(ctx, in)
607
}
608
 
609
func (c *tunnelServiceProtobufClient) callReleaseTunnel(ctx context.Context, in *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
610
	out := new(ReleaseTunnelResponse)
611
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[10], in, out)
612
	if err != nil {
613
		twerr, ok := err.(twirp.Error)
614
		if !ok {
615
			twerr = twirp.InternalErrorWith(err)
616
		}
617
		callClientError(ctx, c.opts.Hooks, twerr)
618
		return nil, err
619
	}
620
 
621
	callClientResponseReceived(ctx, c.opts.Hooks)
622
 
623
	return out, nil
624
}
625
 
626
func (c *tunnelServiceProtobufClient) AcmeInstruction(ctx context.Context, in *InstructionRequest) (*InstructionResponse, error) {
627
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
628
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
629
	ctx = ctxsetters.WithMethodName(ctx, "AcmeInstruction")
630
	caller := c.callAcmeInstruction
631
	if c.interceptor != nil {
632
		caller = func(ctx context.Context, req *InstructionRequest) (*InstructionResponse, error) {
633
			resp, err := c.interceptor(
634
				func(ctx context.Context, req interface{}) (interface{}, error) {
635
					typedReq, ok := req.(*InstructionRequest)
636
					if !ok {
637
						return nil, twirp.InternalError("failed type assertion req.(*InstructionRequest) when calling interceptor")
638
					}
639
					return c.callAcmeInstruction(ctx, typedReq)
640
				},
641
			)(ctx, req)
642
			if resp != nil {
643
				typedResp, ok := resp.(*InstructionResponse)
644
				if !ok {
645
					return nil, twirp.InternalError("failed type assertion resp.(*InstructionResponse) when calling interceptor")
646
				}
647
				return typedResp, err
648
			}
649
			return nil, err
650
		}
651
	}
652
	return caller(ctx, in)
653
}
654
 
655
func (c *tunnelServiceProtobufClient) callAcmeInstruction(ctx context.Context, in *InstructionRequest) (*InstructionResponse, error) {
656
	out := new(InstructionResponse)
657
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[11], 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
 
672
func (c *tunnelServiceProtobufClient) AcmeValidate(ctx context.Context, in *ValidateRequest) (*ValidateResponse, error) {
673
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
674
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
675
	ctx = ctxsetters.WithMethodName(ctx, "AcmeValidate")
676
	caller := c.callAcmeValidate
677
	if c.interceptor != nil {
678
		caller = func(ctx context.Context, req *ValidateRequest) (*ValidateResponse, error) {
679
			resp, err := c.interceptor(
680
				func(ctx context.Context, req interface{}) (interface{}, error) {
681
					typedReq, ok := req.(*ValidateRequest)
682
					if !ok {
683
						return nil, twirp.InternalError("failed type assertion req.(*ValidateRequest) when calling interceptor")
684
					}
685
					return c.callAcmeValidate(ctx, typedReq)
686
				},
687
			)(ctx, req)
688
			if resp != nil {
689
				typedResp, ok := resp.(*ValidateResponse)
690
				if !ok {
691
					return nil, twirp.InternalError("failed type assertion resp.(*ValidateResponse) when calling interceptor")
692
				}
693
				return typedResp, err
694
			}
695
			return nil, err
696
		}
697
	}
698
	return caller(ctx, in)
699
}
700
 
701
func (c *tunnelServiceProtobufClient) callAcmeValidate(ctx context.Context, in *ValidateRequest) (*ValidateResponse, error) {
702
	out := new(ValidateResponse)
703
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[12], 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
 
718
func (c *tunnelServiceProtobufClient) OpenEphemeralSession(ctx context.Context, in *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
719
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
720
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
721
	ctx = ctxsetters.WithMethodName(ctx, "OpenEphemeralSession")
722
	caller := c.callOpenEphemeralSession
723
	if c.interceptor != nil {
724
		caller = func(ctx context.Context, req *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
725
			resp, err := c.interceptor(
726
				func(ctx context.Context, req interface{}) (interface{}, error) {
727
					typedReq, ok := req.(*OpenEphemeralSessionRequest)
728
					if !ok {
729
						return nil, twirp.InternalError("failed type assertion req.(*OpenEphemeralSessionRequest) when calling interceptor")
730
					}
731
					return c.callOpenEphemeralSession(ctx, typedReq)
732
				},
733
			)(ctx, req)
734
			if resp != nil {
735
				typedResp, ok := resp.(*OpenSessionResponse)
736
				if !ok {
737
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
738
				}
739
				return typedResp, err
740
			}
741
			return nil, err
742
		}
743
	}
744
	return caller(ctx, in)
745
}
746
 
747
func (c *tunnelServiceProtobufClient) callOpenEphemeralSession(ctx context.Context, in *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
748
	out := new(OpenSessionResponse)
749
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[13], 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
 
764
func (c *tunnelServiceProtobufClient) OpenDelegatedSession(ctx context.Context, in *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
765
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
766
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
767
	ctx = ctxsetters.WithMethodName(ctx, "OpenDelegatedSession")
768
	caller := c.callOpenDelegatedSession
769
	if c.interceptor != nil {
770
		caller = func(ctx context.Context, req *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
771
			resp, err := c.interceptor(
772
				func(ctx context.Context, req interface{}) (interface{}, error) {
773
					typedReq, ok := req.(*OpenDelegatedSessionRequest)
774
					if !ok {
775
						return nil, twirp.InternalError("failed type assertion req.(*OpenDelegatedSessionRequest) when calling interceptor")
776
					}
777
					return c.callOpenDelegatedSession(ctx, typedReq)
778
				},
779
			)(ctx, req)
780
			if resp != nil {
781
				typedResp, ok := resp.(*OpenSessionResponse)
782
				if !ok {
783
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
784
				}
785
				return typedResp, err
786
			}
787
			return nil, err
788
		}
789
	}
790
	return caller(ctx, in)
791
}
792
 
793
func (c *tunnelServiceProtobufClient) callOpenDelegatedSession(ctx context.Context, in *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
794
	out := new(OpenSessionResponse)
795
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[14], 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
 
810
// =========================
811
// TunnelService JSON Client
812
// =========================
813
 
814
type tunnelServiceJSONClient struct {
815
	client      HTTPClient
816
	urls        [15]string
817
	interceptor twirp.Interceptor
818
	opts        twirp.ClientOptions
819
}
820
 
821
// NewTunnelServiceJSONClient creates a JSON client that implements the TunnelService interface.
822
// It communicates using JSON and can be configured with a custom HTTPClient.
823
func NewTunnelServiceJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) TunnelService {
824
	if c, ok := client.(*http.Client); ok {
825
		client = withoutRedirects(c)
826
	}
827
 
828
	clientOpts := twirp.ClientOptions{}
829
	for _, o := range opts {
830
		o(&clientOpts)
831
	}
832
 
833
	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
834
	literalURLs := false
835
	_ = clientOpts.ReadOpt("literalURLs", &literalURLs)
836
	var pathPrefix string
837
	if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
838
		pathPrefix = "/twirp" // default prefix
839
	}
840
 
841
	// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
842
	serviceURL := sanitizeBaseURL(baseURL)
843
	serviceURL += baseServicePath(pathPrefix, "protocol", "TunnelService")
844
	urls := [15]string{
845
		serviceURL + "MintDelegation",
846
		serviceURL + "ListDelegations",
847
		serviceURL + "RevokeDelegation",
848
		serviceURL + "Ping",
849
		serviceURL + "RegisterIdentity",
850
		serviceURL + "GetNodes",
851
		serviceURL + "GenerateHostname",
852
		serviceURL + "RegisteredHostnames",
853
		serviceURL + "PublishTunnel",
854
		serviceURL + "UnpublishTunnel",
855
		serviceURL + "ReleaseTunnel",
856
		serviceURL + "AcmeInstruction",
857
		serviceURL + "AcmeValidate",
858
		serviceURL + "OpenEphemeralSession",
859
		serviceURL + "OpenDelegatedSession",
860
	}
861
 
862
	return &tunnelServiceJSONClient{
863
		client:      client,
864
		urls:        urls,
865
		interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...),
866
		opts:        clientOpts,
867
	}
868
}
869
 
870
func (c *tunnelServiceJSONClient) MintDelegation(ctx context.Context, in *MintDelegationRequest) (*MintDelegationResponse, error) {
871
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
872
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
873
	ctx = ctxsetters.WithMethodName(ctx, "MintDelegation")
874
	caller := c.callMintDelegation
875
	if c.interceptor != nil {
876
		caller = func(ctx context.Context, req *MintDelegationRequest) (*MintDelegationResponse, error) {
877
			resp, err := c.interceptor(
878
				func(ctx context.Context, req interface{}) (interface{}, error) {
879
					typedReq, ok := req.(*MintDelegationRequest)
880
					if !ok {
881
						return nil, twirp.InternalError("failed type assertion req.(*MintDelegationRequest) when calling interceptor")
882
					}
883
					return c.callMintDelegation(ctx, typedReq)
884
				},
885
			)(ctx, req)
886
			if resp != nil {
887
				typedResp, ok := resp.(*MintDelegationResponse)
888
				if !ok {
889
					return nil, twirp.InternalError("failed type assertion resp.(*MintDelegationResponse) when calling interceptor")
890
				}
891
				return typedResp, err
892
			}
893
			return nil, err
894
		}
895
	}
896
	return caller(ctx, in)
897
}
898
 
899
func (c *tunnelServiceJSONClient) callMintDelegation(ctx context.Context, in *MintDelegationRequest) (*MintDelegationResponse, error) {
900
	out := new(MintDelegationResponse)
901
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
902
	if err != nil {
903
		twerr, ok := err.(twirp.Error)
904
		if !ok {
905
			twerr = twirp.InternalErrorWith(err)
906
		}
907
		callClientError(ctx, c.opts.Hooks, twerr)
908
		return nil, err
909
	}
910
 
911
	callClientResponseReceived(ctx, c.opts.Hooks)
912
 
913
	return out, nil
914
}
915
 
916
func (c *tunnelServiceJSONClient) ListDelegations(ctx context.Context, in *ListDelegationsRequest) (*ListDelegationsResponse, error) {
917
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
918
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
919
	ctx = ctxsetters.WithMethodName(ctx, "ListDelegations")
920
	caller := c.callListDelegations
921
	if c.interceptor != nil {
922
		caller = func(ctx context.Context, req *ListDelegationsRequest) (*ListDelegationsResponse, error) {
923
			resp, err := c.interceptor(
924
				func(ctx context.Context, req interface{}) (interface{}, error) {
925
					typedReq, ok := req.(*ListDelegationsRequest)
926
					if !ok {
927
						return nil, twirp.InternalError("failed type assertion req.(*ListDelegationsRequest) when calling interceptor")
928
					}
929
					return c.callListDelegations(ctx, typedReq)
930
				},
931
			)(ctx, req)
932
			if resp != nil {
933
				typedResp, ok := resp.(*ListDelegationsResponse)
934
				if !ok {
935
					return nil, twirp.InternalError("failed type assertion resp.(*ListDelegationsResponse) when calling interceptor")
936
				}
937
				return typedResp, err
938
			}
939
			return nil, err
940
		}
941
	}
942
	return caller(ctx, in)
943
}
944
 
945
func (c *tunnelServiceJSONClient) callListDelegations(ctx context.Context, in *ListDelegationsRequest) (*ListDelegationsResponse, error) {
946
	out := new(ListDelegationsResponse)
947
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[1], in, out)
948
	if err != nil {
949
		twerr, ok := err.(twirp.Error)
950
		if !ok {
951
			twerr = twirp.InternalErrorWith(err)
952
		}
953
		callClientError(ctx, c.opts.Hooks, twerr)
954
		return nil, err
955
	}
956
 
957
	callClientResponseReceived(ctx, c.opts.Hooks)
958
 
959
	return out, nil
960
}
961
 
962
func (c *tunnelServiceJSONClient) RevokeDelegation(ctx context.Context, in *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
963
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
964
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
965
	ctx = ctxsetters.WithMethodName(ctx, "RevokeDelegation")
966
	caller := c.callRevokeDelegation
967
	if c.interceptor != nil {
968
		caller = func(ctx context.Context, req *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
969
			resp, err := c.interceptor(
970
				func(ctx context.Context, req interface{}) (interface{}, error) {
971
					typedReq, ok := req.(*RevokeDelegationRequest)
972
					if !ok {
973
						return nil, twirp.InternalError("failed type assertion req.(*RevokeDelegationRequest) when calling interceptor")
974
					}
975
					return c.callRevokeDelegation(ctx, typedReq)
976
				},
977
			)(ctx, req)
978
			if resp != nil {
979
				typedResp, ok := resp.(*RevokeDelegationResponse)
980
				if !ok {
981
					return nil, twirp.InternalError("failed type assertion resp.(*RevokeDelegationResponse) when calling interceptor")
982
				}
983
				return typedResp, err
984
			}
985
			return nil, err
986
		}
987
	}
988
	return caller(ctx, in)
989
}
990
 
991
func (c *tunnelServiceJSONClient) callRevokeDelegation(ctx context.Context, in *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
992
	out := new(RevokeDelegationResponse)
993
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[2], in, out)
994
	if err != nil {
995
		twerr, ok := err.(twirp.Error)
996
		if !ok {
997
			twerr = twirp.InternalErrorWith(err)
998
		}
999
		callClientError(ctx, c.opts.Hooks, twerr)
1000
		return nil, err
1001
	}
1002
 
1003
	callClientResponseReceived(ctx, c.opts.Hooks)
1004
 
1005
	return out, nil
1006
}
1007
 
1008
func (c *tunnelServiceJSONClient) Ping(ctx context.Context, in *ClientPingRequest) (*ClientPingResponse, error) {
1009
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1010
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1011
	ctx = ctxsetters.WithMethodName(ctx, "Ping")
1012
	caller := c.callPing
1013
	if c.interceptor != nil {
1014
		caller = func(ctx context.Context, req *ClientPingRequest) (*ClientPingResponse, error) {
1015
			resp, err := c.interceptor(
1016
				func(ctx context.Context, req interface{}) (interface{}, error) {
1017
					typedReq, ok := req.(*ClientPingRequest)
1018
					if !ok {
1019
						return nil, twirp.InternalError("failed type assertion req.(*ClientPingRequest) when calling interceptor")
1020
					}
1021
					return c.callPing(ctx, typedReq)
1022
				},
1023
			)(ctx, req)
1024
			if resp != nil {
1025
				typedResp, ok := resp.(*ClientPingResponse)
1026
				if !ok {
1027
					return nil, twirp.InternalError("failed type assertion resp.(*ClientPingResponse) when calling interceptor")
1028
				}
1029
				return typedResp, err
1030
			}
1031
			return nil, err
1032
		}
1033
	}
1034
	return caller(ctx, in)
1035
}
1036
 
1037
func (c *tunnelServiceJSONClient) callPing(ctx context.Context, in *ClientPingRequest) (*ClientPingResponse, error) {
1038
	out := new(ClientPingResponse)
1039
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[3], in, out)
1040
	if err != nil {
1041
		twerr, ok := err.(twirp.Error)
1042
		if !ok {
1043
			twerr = twirp.InternalErrorWith(err)
1044
		}
1045
		callClientError(ctx, c.opts.Hooks, twerr)
1046
		return nil, err
1047
	}
1048
 
1049
	callClientResponseReceived(ctx, c.opts.Hooks)
1050
 
1051
	return out, nil
1052
}
1053
 
1054
func (c *tunnelServiceJSONClient) RegisterIdentity(ctx context.Context, in *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
1055
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1056
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1057
	ctx = ctxsetters.WithMethodName(ctx, "RegisterIdentity")
1058
	caller := c.callRegisterIdentity
1059
	if c.interceptor != nil {
1060
		caller = func(ctx context.Context, req *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
1061
			resp, err := c.interceptor(
1062
				func(ctx context.Context, req interface{}) (interface{}, error) {
1063
					typedReq, ok := req.(*RegisterIdentityRequest)
1064
					if !ok {
1065
						return nil, twirp.InternalError("failed type assertion req.(*RegisterIdentityRequest) when calling interceptor")
1066
					}
1067
					return c.callRegisterIdentity(ctx, typedReq)
1068
				},
1069
			)(ctx, req)
1070
			if resp != nil {
1071
				typedResp, ok := resp.(*RegisterIdentityResponse)
1072
				if !ok {
1073
					return nil, twirp.InternalError("failed type assertion resp.(*RegisterIdentityResponse) when calling interceptor")
1074
				}
1075
				return typedResp, err
1076
			}
1077
			return nil, err
1078
		}
1079
	}
1080
	return caller(ctx, in)
1081
}
1082
 
1083
func (c *tunnelServiceJSONClient) callRegisterIdentity(ctx context.Context, in *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
1084
	out := new(RegisterIdentityResponse)
1085
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[4], in, out)
1086
	if err != nil {
1087
		twerr, ok := err.(twirp.Error)
1088
		if !ok {
1089
			twerr = twirp.InternalErrorWith(err)
1090
		}
1091
		callClientError(ctx, c.opts.Hooks, twerr)
1092
		return nil, err
1093
	}
1094
 
1095
	callClientResponseReceived(ctx, c.opts.Hooks)
1096
 
1097
	return out, nil
1098
}
1099
 
1100
func (c *tunnelServiceJSONClient) GetNodes(ctx context.Context, in *GetNodesRequest) (*GetNodesResponse, error) {
1101
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1102
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1103
	ctx = ctxsetters.WithMethodName(ctx, "GetNodes")
1104
	caller := c.callGetNodes
1105
	if c.interceptor != nil {
1106
		caller = func(ctx context.Context, req *GetNodesRequest) (*GetNodesResponse, error) {
1107
			resp, err := c.interceptor(
1108
				func(ctx context.Context, req interface{}) (interface{}, error) {
1109
					typedReq, ok := req.(*GetNodesRequest)
1110
					if !ok {
1111
						return nil, twirp.InternalError("failed type assertion req.(*GetNodesRequest) when calling interceptor")
1112
					}
1113
					return c.callGetNodes(ctx, typedReq)
1114
				},
1115
			)(ctx, req)
1116
			if resp != nil {
1117
				typedResp, ok := resp.(*GetNodesResponse)
1118
				if !ok {
1119
					return nil, twirp.InternalError("failed type assertion resp.(*GetNodesResponse) when calling interceptor")
1120
				}
1121
				return typedResp, err
1122
			}
1123
			return nil, err
1124
		}
1125
	}
1126
	return caller(ctx, in)
1127
}
1128
 
1129
func (c *tunnelServiceJSONClient) callGetNodes(ctx context.Context, in *GetNodesRequest) (*GetNodesResponse, error) {
1130
	out := new(GetNodesResponse)
1131
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[5], in, out)
1132
	if err != nil {
1133
		twerr, ok := err.(twirp.Error)
1134
		if !ok {
1135
			twerr = twirp.InternalErrorWith(err)
1136
		}
1137
		callClientError(ctx, c.opts.Hooks, twerr)
1138
		return nil, err
1139
	}
1140
 
1141
	callClientResponseReceived(ctx, c.opts.Hooks)
1142
 
1143
	return out, nil
1144
}
1145
 
1146
func (c *tunnelServiceJSONClient) GenerateHostname(ctx context.Context, in *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
1147
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1148
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1149
	ctx = ctxsetters.WithMethodName(ctx, "GenerateHostname")
1150
	caller := c.callGenerateHostname
1151
	if c.interceptor != nil {
1152
		caller = func(ctx context.Context, req *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
1153
			resp, err := c.interceptor(
1154
				func(ctx context.Context, req interface{}) (interface{}, error) {
1155
					typedReq, ok := req.(*GenerateHostnameRequest)
1156
					if !ok {
1157
						return nil, twirp.InternalError("failed type assertion req.(*GenerateHostnameRequest) when calling interceptor")
1158
					}
1159
					return c.callGenerateHostname(ctx, typedReq)
1160
				},
1161
			)(ctx, req)
1162
			if resp != nil {
1163
				typedResp, ok := resp.(*GenerateHostnameResponse)
1164
				if !ok {
1165
					return nil, twirp.InternalError("failed type assertion resp.(*GenerateHostnameResponse) when calling interceptor")
1166
				}
1167
				return typedResp, err
1168
			}
1169
			return nil, err
1170
		}
1171
	}
1172
	return caller(ctx, in)
1173
}
1174
 
1175
func (c *tunnelServiceJSONClient) callGenerateHostname(ctx context.Context, in *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
1176
	out := new(GenerateHostnameResponse)
1177
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[6], in, out)
1178
	if err != nil {
1179
		twerr, ok := err.(twirp.Error)
1180
		if !ok {
1181
			twerr = twirp.InternalErrorWith(err)
1182
		}
1183
		callClientError(ctx, c.opts.Hooks, twerr)
1184
		return nil, err
1185
	}
1186
 
1187
	callClientResponseReceived(ctx, c.opts.Hooks)
1188
 
1189
	return out, nil
1190
}
1191
 
1192
func (c *tunnelServiceJSONClient) RegisteredHostnames(ctx context.Context, in *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
1193
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1194
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1195
	ctx = ctxsetters.WithMethodName(ctx, "RegisteredHostnames")
1196
	caller := c.callRegisteredHostnames
1197
	if c.interceptor != nil {
1198
		caller = func(ctx context.Context, req *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
1199
			resp, err := c.interceptor(
1200
				func(ctx context.Context, req interface{}) (interface{}, error) {
1201
					typedReq, ok := req.(*RegisteredHostnamesRequest)
1202
					if !ok {
1203
						return nil, twirp.InternalError("failed type assertion req.(*RegisteredHostnamesRequest) when calling interceptor")
1204
					}
1205
					return c.callRegisteredHostnames(ctx, typedReq)
1206
				},
1207
			)(ctx, req)
1208
			if resp != nil {
1209
				typedResp, ok := resp.(*RegisteredHostnamesResponse)
1210
				if !ok {
1211
					return nil, twirp.InternalError("failed type assertion resp.(*RegisteredHostnamesResponse) when calling interceptor")
1212
				}
1213
				return typedResp, err
1214
			}
1215
			return nil, err
1216
		}
1217
	}
1218
	return caller(ctx, in)
1219
}
1220
 
1221
func (c *tunnelServiceJSONClient) callRegisteredHostnames(ctx context.Context, in *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
1222
	out := new(RegisteredHostnamesResponse)
1223
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
1224
	if err != nil {
1225
		twerr, ok := err.(twirp.Error)
1226
		if !ok {
1227
			twerr = twirp.InternalErrorWith(err)
1228
		}
1229
		callClientError(ctx, c.opts.Hooks, twerr)
1230
		return nil, err
1231
	}
1232
 
1233
	callClientResponseReceived(ctx, c.opts.Hooks)
1234
 
1235
	return out, nil
1236
}
1237
 
1238
func (c *tunnelServiceJSONClient) PublishTunnel(ctx context.Context, in *PublishTunnelRequest) (*PublishTunnelResponse, error) {
1239
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1240
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1241
	ctx = ctxsetters.WithMethodName(ctx, "PublishTunnel")
1242
	caller := c.callPublishTunnel
1243
	if c.interceptor != nil {
1244
		caller = func(ctx context.Context, req *PublishTunnelRequest) (*PublishTunnelResponse, error) {
1245
			resp, err := c.interceptor(
1246
				func(ctx context.Context, req interface{}) (interface{}, error) {
1247
					typedReq, ok := req.(*PublishTunnelRequest)
1248
					if !ok {
1249
						return nil, twirp.InternalError("failed type assertion req.(*PublishTunnelRequest) when calling interceptor")
1250
					}
1251
					return c.callPublishTunnel(ctx, typedReq)
1252
				},
1253
			)(ctx, req)
1254
			if resp != nil {
1255
				typedResp, ok := resp.(*PublishTunnelResponse)
1256
				if !ok {
1257
					return nil, twirp.InternalError("failed type assertion resp.(*PublishTunnelResponse) when calling interceptor")
1258
				}
1259
				return typedResp, err
1260
			}
1261
			return nil, err
1262
		}
1263
	}
1264
	return caller(ctx, in)
1265
}
1266
 
1267
func (c *tunnelServiceJSONClient) callPublishTunnel(ctx context.Context, in *PublishTunnelRequest) (*PublishTunnelResponse, error) {
1268
	out := new(PublishTunnelResponse)
1269
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
1270
	if err != nil {
1271
		twerr, ok := err.(twirp.Error)
1272
		if !ok {
1273
			twerr = twirp.InternalErrorWith(err)
1274
		}
1275
		callClientError(ctx, c.opts.Hooks, twerr)
1276
		return nil, err
1277
	}
1278
 
1279
	callClientResponseReceived(ctx, c.opts.Hooks)
1280
 
1281
	return out, nil
1282
}
1283
 
1284
func (c *tunnelServiceJSONClient) UnpublishTunnel(ctx context.Context, in *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
1285
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1286
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1287
	ctx = ctxsetters.WithMethodName(ctx, "UnpublishTunnel")
1288
	caller := c.callUnpublishTunnel
1289
	if c.interceptor != nil {
1290
		caller = func(ctx context.Context, req *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
1291
			resp, err := c.interceptor(
1292
				func(ctx context.Context, req interface{}) (interface{}, error) {
1293
					typedReq, ok := req.(*UnpublishTunnelRequest)
1294
					if !ok {
1295
						return nil, twirp.InternalError("failed type assertion req.(*UnpublishTunnelRequest) when calling interceptor")
1296
					}
1297
					return c.callUnpublishTunnel(ctx, typedReq)
1298
				},
1299
			)(ctx, req)
1300
			if resp != nil {
1301
				typedResp, ok := resp.(*UnpublishTunnelResponse)
1302
				if !ok {
1303
					return nil, twirp.InternalError("failed type assertion resp.(*UnpublishTunnelResponse) when calling interceptor")
1304
				}
1305
				return typedResp, err
1306
			}
1307
			return nil, err
1308
		}
1309
	}
1310
	return caller(ctx, in)
1311
}
1312
 
1313
func (c *tunnelServiceJSONClient) callUnpublishTunnel(ctx context.Context, in *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
1314
	out := new(UnpublishTunnelResponse)
1315
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[9], in, out)
1316
	if err != nil {
1317
		twerr, ok := err.(twirp.Error)
1318
		if !ok {
1319
			twerr = twirp.InternalErrorWith(err)
1320
		}
1321
		callClientError(ctx, c.opts.Hooks, twerr)
1322
		return nil, err
1323
	}
1324
 
1325
	callClientResponseReceived(ctx, c.opts.Hooks)
1326
 
1327
	return out, nil
1328
}
1329
 
1330
func (c *tunnelServiceJSONClient) ReleaseTunnel(ctx context.Context, in *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
1331
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1332
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1333
	ctx = ctxsetters.WithMethodName(ctx, "ReleaseTunnel")
1334
	caller := c.callReleaseTunnel
1335
	if c.interceptor != nil {
1336
		caller = func(ctx context.Context, req *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
1337
			resp, err := c.interceptor(
1338
				func(ctx context.Context, req interface{}) (interface{}, error) {
1339
					typedReq, ok := req.(*ReleaseTunnelRequest)
1340
					if !ok {
1341
						return nil, twirp.InternalError("failed type assertion req.(*ReleaseTunnelRequest) when calling interceptor")
1342
					}
1343
					return c.callReleaseTunnel(ctx, typedReq)
1344
				},
1345
			)(ctx, req)
1346
			if resp != nil {
1347
				typedResp, ok := resp.(*ReleaseTunnelResponse)
1348
				if !ok {
1349
					return nil, twirp.InternalError("failed type assertion resp.(*ReleaseTunnelResponse) when calling interceptor")
1350
				}
1351
				return typedResp, err
1352
			}
1353
			return nil, err
1354
		}
1355
	}
1356
	return caller(ctx, in)
1357
}
1358
 
1359
func (c *tunnelServiceJSONClient) callReleaseTunnel(ctx context.Context, in *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
1360
	out := new(ReleaseTunnelResponse)
1361
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[10], in, out)
1362
	if err != nil {
1363
		twerr, ok := err.(twirp.Error)
1364
		if !ok {
1365
			twerr = twirp.InternalErrorWith(err)
1366
		}
1367
		callClientError(ctx, c.opts.Hooks, twerr)
1368
		return nil, err
1369
	}
1370
 
1371
	callClientResponseReceived(ctx, c.opts.Hooks)
1372
 
1373
	return out, nil
1374
}
1375
 
1376
func (c *tunnelServiceJSONClient) AcmeInstruction(ctx context.Context, in *InstructionRequest) (*InstructionResponse, error) {
1377
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1378
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1379
	ctx = ctxsetters.WithMethodName(ctx, "AcmeInstruction")
1380
	caller := c.callAcmeInstruction
1381
	if c.interceptor != nil {
1382
		caller = func(ctx context.Context, req *InstructionRequest) (*InstructionResponse, error) {
1383
			resp, err := c.interceptor(
1384
				func(ctx context.Context, req interface{}) (interface{}, error) {
1385
					typedReq, ok := req.(*InstructionRequest)
1386
					if !ok {
1387
						return nil, twirp.InternalError("failed type assertion req.(*InstructionRequest) when calling interceptor")
1388
					}
1389
					return c.callAcmeInstruction(ctx, typedReq)
1390
				},
1391
			)(ctx, req)
1392
			if resp != nil {
1393
				typedResp, ok := resp.(*InstructionResponse)
1394
				if !ok {
1395
					return nil, twirp.InternalError("failed type assertion resp.(*InstructionResponse) when calling interceptor")
1396
				}
1397
				return typedResp, err
1398
			}
1399
			return nil, err
1400
		}
1401
	}
1402
	return caller(ctx, in)
1403
}
1404
 
1405
func (c *tunnelServiceJSONClient) callAcmeInstruction(ctx context.Context, in *InstructionRequest) (*InstructionResponse, error) {
1406
	out := new(InstructionResponse)
1407
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[11], in, out)
1408
	if err != nil {
1409
		twerr, ok := err.(twirp.Error)
1410
		if !ok {
1411
			twerr = twirp.InternalErrorWith(err)
1412
		}
1413
		callClientError(ctx, c.opts.Hooks, twerr)
1414
		return nil, err
1415
	}
1416
 
1417
	callClientResponseReceived(ctx, c.opts.Hooks)
1418
 
1419
	return out, nil
1420
}
1421
 
1422
func (c *tunnelServiceJSONClient) AcmeValidate(ctx context.Context, in *ValidateRequest) (*ValidateResponse, error) {
1423
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1424
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1425
	ctx = ctxsetters.WithMethodName(ctx, "AcmeValidate")
1426
	caller := c.callAcmeValidate
1427
	if c.interceptor != nil {
1428
		caller = func(ctx context.Context, req *ValidateRequest) (*ValidateResponse, error) {
1429
			resp, err := c.interceptor(
1430
				func(ctx context.Context, req interface{}) (interface{}, error) {
1431
					typedReq, ok := req.(*ValidateRequest)
1432
					if !ok {
1433
						return nil, twirp.InternalError("failed type assertion req.(*ValidateRequest) when calling interceptor")
1434
					}
1435
					return c.callAcmeValidate(ctx, typedReq)
1436
				},
1437
			)(ctx, req)
1438
			if resp != nil {
1439
				typedResp, ok := resp.(*ValidateResponse)
1440
				if !ok {
1441
					return nil, twirp.InternalError("failed type assertion resp.(*ValidateResponse) when calling interceptor")
1442
				}
1443
				return typedResp, err
1444
			}
1445
			return nil, err
1446
		}
1447
	}
1448
	return caller(ctx, in)
1449
}
1450
 
1451
func (c *tunnelServiceJSONClient) callAcmeValidate(ctx context.Context, in *ValidateRequest) (*ValidateResponse, error) {
1452
	out := new(ValidateResponse)
1453
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[12], in, out)
1454
	if err != nil {
1455
		twerr, ok := err.(twirp.Error)
1456
		if !ok {
1457
			twerr = twirp.InternalErrorWith(err)
1458
		}
1459
		callClientError(ctx, c.opts.Hooks, twerr)
1460
		return nil, err
1461
	}
1462
 
1463
	callClientResponseReceived(ctx, c.opts.Hooks)
1464
 
1465
	return out, nil
1466
}
1467
 
1468
func (c *tunnelServiceJSONClient) OpenEphemeralSession(ctx context.Context, in *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
1469
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1470
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1471
	ctx = ctxsetters.WithMethodName(ctx, "OpenEphemeralSession")
1472
	caller := c.callOpenEphemeralSession
1473
	if c.interceptor != nil {
1474
		caller = func(ctx context.Context, req *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
1475
			resp, err := c.interceptor(
1476
				func(ctx context.Context, req interface{}) (interface{}, error) {
1477
					typedReq, ok := req.(*OpenEphemeralSessionRequest)
1478
					if !ok {
1479
						return nil, twirp.InternalError("failed type assertion req.(*OpenEphemeralSessionRequest) when calling interceptor")
1480
					}
1481
					return c.callOpenEphemeralSession(ctx, typedReq)
1482
				},
1483
			)(ctx, req)
1484
			if resp != nil {
1485
				typedResp, ok := resp.(*OpenSessionResponse)
1486
				if !ok {
1487
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
1488
				}
1489
				return typedResp, err
1490
			}
1491
			return nil, err
1492
		}
1493
	}
1494
	return caller(ctx, in)
1495
}
1496
 
1497
func (c *tunnelServiceJSONClient) callOpenEphemeralSession(ctx context.Context, in *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
1498
	out := new(OpenSessionResponse)
1499
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[13], in, out)
1500
	if err != nil {
1501
		twerr, ok := err.(twirp.Error)
1502
		if !ok {
1503
			twerr = twirp.InternalErrorWith(err)
1504
		}
1505
		callClientError(ctx, c.opts.Hooks, twerr)
1506
		return nil, err
1507
	}
1508
 
1509
	callClientResponseReceived(ctx, c.opts.Hooks)
1510
 
1511
	return out, nil
1512
}
1513
 
1514
func (c *tunnelServiceJSONClient) OpenDelegatedSession(ctx context.Context, in *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
1515
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1516
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1517
	ctx = ctxsetters.WithMethodName(ctx, "OpenDelegatedSession")
1518
	caller := c.callOpenDelegatedSession
1519
	if c.interceptor != nil {
1520
		caller = func(ctx context.Context, req *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
1521
			resp, err := c.interceptor(
1522
				func(ctx context.Context, req interface{}) (interface{}, error) {
1523
					typedReq, ok := req.(*OpenDelegatedSessionRequest)
1524
					if !ok {
1525
						return nil, twirp.InternalError("failed type assertion req.(*OpenDelegatedSessionRequest) when calling interceptor")
1526
					}
1527
					return c.callOpenDelegatedSession(ctx, typedReq)
1528
				},
1529
			)(ctx, req)
1530
			if resp != nil {
1531
				typedResp, ok := resp.(*OpenSessionResponse)
1532
				if !ok {
1533
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
1534
				}
1535
				return typedResp, err
1536
			}
1537
			return nil, err
1538
		}
1539
	}
1540
	return caller(ctx, in)
1541
}
1542
 
1543
func (c *tunnelServiceJSONClient) callOpenDelegatedSession(ctx context.Context, in *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
1544
	out := new(OpenSessionResponse)
1545
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[14], in, out)
1546
	if err != nil {
1547
		twerr, ok := err.(twirp.Error)
1548
		if !ok {
1549
			twerr = twirp.InternalErrorWith(err)
1550
		}
1551
		callClientError(ctx, c.opts.Hooks, twerr)
1552
		return nil, err
1553
	}
1554
 
1555
	callClientResponseReceived(ctx, c.opts.Hooks)
1556
 
1557
	return out, nil
1558
}
1559
 
1560
// ============================
1561
// TunnelService Server Handler
1562
// ============================
1563
 
1564
type tunnelServiceServer struct {
1565
	TunnelService
1566
	interceptor      twirp.Interceptor
1567
	hooks            *twirp.ServerHooks
1568
	pathPrefix       string // prefix for routing
1569
	jsonSkipDefaults bool   // do not include unpopulated fields (default values) in the response
1570
	jsonCamelCase    bool   // JSON fields are serialized as lowerCamelCase rather than keeping the original proto names
1571
}
1572
 
1573
// NewTunnelServiceServer builds a TwirpServer that can be used as an http.Handler to handle
1574
// HTTP requests that are routed to the right method in the provided svc implementation.
1575
// The opts are twirp.ServerOption modifiers, for example twirp.WithServerHooks(hooks).
1576
func NewTunnelServiceServer(svc TunnelService, opts ...interface{}) TwirpServer {
1577
	serverOpts := newServerOpts(opts)
1578
 
1579
	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
1580
	jsonSkipDefaults := false
1581
	_ = serverOpts.ReadOpt("jsonSkipDefaults", &jsonSkipDefaults)
1582
	jsonCamelCase := false
1583
	_ = serverOpts.ReadOpt("jsonCamelCase", &jsonCamelCase)
1584
	var pathPrefix string
1585
	if ok := serverOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
1586
		pathPrefix = "/twirp" // default prefix
1587
	}
1588
 
1589
	return &tunnelServiceServer{
1590
		TunnelService:    svc,
1591
		hooks:            serverOpts.Hooks,
1592
		interceptor:      twirp.ChainInterceptors(serverOpts.Interceptors...),
1593
		pathPrefix:       pathPrefix,
1594
		jsonSkipDefaults: jsonSkipDefaults,
1595
		jsonCamelCase:    jsonCamelCase,
1596
	}
1597
}
1598
 
1599
// writeError writes an HTTP response with a valid Twirp error format, and triggers hooks.
1600
// If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err)
1601
func (s *tunnelServiceServer) writeError(ctx context.Context, resp http.ResponseWriter, err error) {
1602
	writeError(ctx, resp, err, s.hooks)
1603
}
1604
 
1605
// handleRequestBodyError is used to handle error when the twirp server cannot read request
1606
func (s *tunnelServiceServer) handleRequestBodyError(ctx context.Context, resp http.ResponseWriter, msg string, err error) {
1607
	if context.Canceled == ctx.Err() {
1608
		s.writeError(ctx, resp, twirp.NewError(twirp.Canceled, "failed to read request: context canceled"))
1609
		return
1610
	}
1611
	if context.DeadlineExceeded == ctx.Err() {
1612
		s.writeError(ctx, resp, twirp.NewError(twirp.DeadlineExceeded, "failed to read request: deadline exceeded"))
1613
		return
1614
	}
1615
	s.writeError(ctx, resp, twirp.WrapError(malformedRequestError(msg), err))
1616
}
1617
 
1618
// TunnelServicePathPrefix is a convenience constant that may identify URL paths.
1619
// Should be used with caution, it only matches routes generated by Twirp Go clients,
1620
// with the default "/twirp" prefix and default CamelCase service and method names.
1621
// More info: https://twitchtv.github.io/twirp/docs/routing.html
1622
const TunnelServicePathPrefix = "/twirp/protocol.TunnelService/"
1623
 
1624
func (s *tunnelServiceServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
1625
	ctx := req.Context()
1626
	ctx = ctxsetters.WithPackageName(ctx, "protocol")
1627
	ctx = ctxsetters.WithServiceName(ctx, "TunnelService")
1628
	ctx = ctxsetters.WithResponseWriter(ctx, resp)
1629
 
1630
	var err error
1631
	ctx, err = callRequestReceived(ctx, s.hooks)
1632
	if err != nil {
1633
		s.writeError(ctx, resp, err)
1634
		return
1635
	}
1636
 
1637
	if req.Method != "POST" {
1638
		msg := fmt.Sprintf("unsupported method %q (only POST is allowed)", req.Method)
1639
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
1640
		return
1641
	}
1642
 
1643
	// Verify path format: [<prefix>]/<package>.<Service>/<Method>
1644
	prefix, pkgService, method := parseTwirpPath(req.URL.Path)
1645
	if pkgService != "protocol.TunnelService" {
1646
		msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
1647
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
1648
		return
1649
	}
1650
	if prefix != s.pathPrefix {
1651
		msg := fmt.Sprintf("invalid path prefix %q, expected %q, on path %q", prefix, s.pathPrefix, req.URL.Path)
1652
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
1653
		return
1654
	}
1655
 
1656
	switch method {
1657
	case "MintDelegation":
1658
		s.serveMintDelegation(ctx, resp, req)
1659
		return
1660
	case "ListDelegations":
1661
		s.serveListDelegations(ctx, resp, req)
1662
		return
1663
	case "RevokeDelegation":
1664
		s.serveRevokeDelegation(ctx, resp, req)
1665
		return
1666
	case "Ping":
1667
		s.servePing(ctx, resp, req)
1668
		return
1669
	case "RegisterIdentity":
1670
		s.serveRegisterIdentity(ctx, resp, req)
1671
		return
1672
	case "GetNodes":
1673
		s.serveGetNodes(ctx, resp, req)
1674
		return
1675
	case "GenerateHostname":
1676
		s.serveGenerateHostname(ctx, resp, req)
1677
		return
1678
	case "RegisteredHostnames":
1679
		s.serveRegisteredHostnames(ctx, resp, req)
1680
		return
1681
	case "PublishTunnel":
1682
		s.servePublishTunnel(ctx, resp, req)
1683
		return
1684
	case "UnpublishTunnel":
1685
		s.serveUnpublishTunnel(ctx, resp, req)
1686
		return
1687
	case "ReleaseTunnel":
1688
		s.serveReleaseTunnel(ctx, resp, req)
1689
		return
1690
	case "AcmeInstruction":
1691
		s.serveAcmeInstruction(ctx, resp, req)
1692
		return
1693
	case "AcmeValidate":
1694
		s.serveAcmeValidate(ctx, resp, req)
1695
		return
1696
	case "OpenEphemeralSession":
1697
		s.serveOpenEphemeralSession(ctx, resp, req)
1698
		return
1699
	case "OpenDelegatedSession":
1700
		s.serveOpenDelegatedSession(ctx, resp, req)
1701
		return
1702
	default:
1703
		msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
1704
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
1705
		return
1706
	}
1707
}
1708
 
1709
func (s *tunnelServiceServer) serveMintDelegation(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1710
	header := req.Header.Get("Content-Type")
1711
	i := strings.Index(header, ";")
1712
	if i == -1 {
1713
		i = len(header)
1714
	}
1715
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
1716
	case "application/json":
1717
		s.serveMintDelegationJSON(ctx, resp, req)
1718
	case "application/protobuf":
1719
		s.serveMintDelegationProtobuf(ctx, resp, req)
1720
	default:
1721
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
1722
		twerr := badRouteError(msg, req.Method, req.URL.Path)
1723
		s.writeError(ctx, resp, twerr)
1724
	}
1725
}
1726
 
1727
func (s *tunnelServiceServer) serveMintDelegationJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1728
	var err error
1729
	ctx = ctxsetters.WithMethodName(ctx, "MintDelegation")
1730
	ctx, err = callRequestRouted(ctx, s.hooks)
1731
	if err != nil {
1732
		s.writeError(ctx, resp, err)
1733
		return
1734
	}
1735
 
1736
	d := json.NewDecoder(req.Body)
1737
	rawReqBody := json.RawMessage{}
1738
	if err := d.Decode(&rawReqBody); err != nil {
1739
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1740
		return
1741
	}
1742
	reqContent := new(MintDelegationRequest)
1743
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
1744
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
1745
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1746
		return
1747
	}
1748
 
1749
	handler := s.TunnelService.MintDelegation
1750
	if s.interceptor != nil {
1751
		handler = func(ctx context.Context, req *MintDelegationRequest) (*MintDelegationResponse, error) {
1752
			resp, err := s.interceptor(
1753
				func(ctx context.Context, req interface{}) (interface{}, error) {
1754
					typedReq, ok := req.(*MintDelegationRequest)
1755
					if !ok {
1756
						return nil, twirp.InternalError("failed type assertion req.(*MintDelegationRequest) when calling interceptor")
1757
					}
1758
					return s.TunnelService.MintDelegation(ctx, typedReq)
1759
				},
1760
			)(ctx, req)
1761
			if resp != nil {
1762
				typedResp, ok := resp.(*MintDelegationResponse)
1763
				if !ok {
1764
					return nil, twirp.InternalError("failed type assertion resp.(*MintDelegationResponse) when calling interceptor")
1765
				}
1766
				return typedResp, err
1767
			}
1768
			return nil, err
1769
		}
1770
	}
1771
 
1772
	// Call service method
1773
	var respContent *MintDelegationResponse
1774
	func() {
1775
		defer ensurePanicResponses(ctx, resp, s.hooks)
1776
		respContent, err = handler(ctx, reqContent)
1777
	}()
1778
 
1779
	if err != nil {
1780
		s.writeError(ctx, resp, err)
1781
		return
1782
	}
1783
	if respContent == nil {
1784
		s.writeError(ctx, resp, twirp.InternalError("received a nil *MintDelegationResponse and nil error while calling MintDelegation. nil responses are not supported"))
1785
		return
1786
	}
1787
 
1788
	ctx = callResponsePrepared(ctx, s.hooks)
1789
 
1790
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
1791
	respBytes, err := marshaler.Marshal(respContent)
1792
	if err != nil {
1793
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
1794
		return
1795
	}
1796
 
1797
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1798
	resp.Header().Set("Content-Type", "application/json")
1799
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1800
	resp.WriteHeader(http.StatusOK)
1801
 
1802
	if n, err := resp.Write(respBytes); err != nil {
1803
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1804
		twerr := twirp.NewError(twirp.Unknown, msg)
1805
		ctx = callError(ctx, s.hooks, twerr)
1806
	}
1807
	callResponseSent(ctx, s.hooks)
1808
}
1809
 
1810
func (s *tunnelServiceServer) serveMintDelegationProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1811
	var err error
1812
	ctx = ctxsetters.WithMethodName(ctx, "MintDelegation")
1813
	ctx, err = callRequestRouted(ctx, s.hooks)
1814
	if err != nil {
1815
		s.writeError(ctx, resp, err)
1816
		return
1817
	}
1818
 
1819
	buf, err := io.ReadAll(req.Body)
1820
	if err != nil {
1821
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
1822
		return
1823
	}
1824
	reqContent := new(MintDelegationRequest)
1825
	if err = reqContent.UnmarshalVT(buf); err != nil {
1826
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
1827
		return
1828
	}
1829
 
1830
	handler := s.TunnelService.MintDelegation
1831
	if s.interceptor != nil {
1832
		handler = func(ctx context.Context, req *MintDelegationRequest) (*MintDelegationResponse, error) {
1833
			resp, err := s.interceptor(
1834
				func(ctx context.Context, req interface{}) (interface{}, error) {
1835
					typedReq, ok := req.(*MintDelegationRequest)
1836
					if !ok {
1837
						return nil, twirp.InternalError("failed type assertion req.(*MintDelegationRequest) when calling interceptor")
1838
					}
1839
					return s.TunnelService.MintDelegation(ctx, typedReq)
1840
				},
1841
			)(ctx, req)
1842
			if resp != nil {
1843
				typedResp, ok := resp.(*MintDelegationResponse)
1844
				if !ok {
1845
					return nil, twirp.InternalError("failed type assertion resp.(*MintDelegationResponse) when calling interceptor")
1846
				}
1847
				return typedResp, err
1848
			}
1849
			return nil, err
1850
		}
1851
	}
1852
 
1853
	// Call service method
1854
	var respContent *MintDelegationResponse
1855
	func() {
1856
		defer ensurePanicResponses(ctx, resp, s.hooks)
1857
		respContent, err = handler(ctx, reqContent)
1858
	}()
1859
 
1860
	if err != nil {
1861
		s.writeError(ctx, resp, err)
1862
		return
1863
	}
1864
	if respContent == nil {
1865
		s.writeError(ctx, resp, twirp.InternalError("received a nil *MintDelegationResponse and nil error while calling MintDelegation. nil responses are not supported"))
1866
		return
1867
	}
1868
 
1869
	ctx = callResponsePrepared(ctx, s.hooks)
1870
 
1871
	respBytes, err := respContent.MarshalVT()
1872
	if err != nil {
1873
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
1874
		return
1875
	}
1876
 
1877
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1878
	resp.Header().Set("Content-Type", "application/protobuf")
1879
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1880
	resp.WriteHeader(http.StatusOK)
1881
	if n, err := resp.Write(respBytes); err != nil {
1882
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1883
		twerr := twirp.NewError(twirp.Unknown, msg)
1884
		ctx = callError(ctx, s.hooks, twerr)
1885
	}
1886
	callResponseSent(ctx, s.hooks)
1887
}
1888
 
1889
func (s *tunnelServiceServer) serveListDelegations(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1890
	header := req.Header.Get("Content-Type")
1891
	i := strings.Index(header, ";")
1892
	if i == -1 {
1893
		i = len(header)
1894
	}
1895
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
1896
	case "application/json":
1897
		s.serveListDelegationsJSON(ctx, resp, req)
1898
	case "application/protobuf":
1899
		s.serveListDelegationsProtobuf(ctx, resp, req)
1900
	default:
1901
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
1902
		twerr := badRouteError(msg, req.Method, req.URL.Path)
1903
		s.writeError(ctx, resp, twerr)
1904
	}
1905
}
1906
 
1907
func (s *tunnelServiceServer) serveListDelegationsJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1908
	var err error
1909
	ctx = ctxsetters.WithMethodName(ctx, "ListDelegations")
1910
	ctx, err = callRequestRouted(ctx, s.hooks)
1911
	if err != nil {
1912
		s.writeError(ctx, resp, err)
1913
		return
1914
	}
1915
 
1916
	d := json.NewDecoder(req.Body)
1917
	rawReqBody := json.RawMessage{}
1918
	if err := d.Decode(&rawReqBody); err != nil {
1919
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1920
		return
1921
	}
1922
	reqContent := new(ListDelegationsRequest)
1923
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
1924
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
1925
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
1926
		return
1927
	}
1928
 
1929
	handler := s.TunnelService.ListDelegations
1930
	if s.interceptor != nil {
1931
		handler = func(ctx context.Context, req *ListDelegationsRequest) (*ListDelegationsResponse, error) {
1932
			resp, err := s.interceptor(
1933
				func(ctx context.Context, req interface{}) (interface{}, error) {
1934
					typedReq, ok := req.(*ListDelegationsRequest)
1935
					if !ok {
1936
						return nil, twirp.InternalError("failed type assertion req.(*ListDelegationsRequest) when calling interceptor")
1937
					}
1938
					return s.TunnelService.ListDelegations(ctx, typedReq)
1939
				},
1940
			)(ctx, req)
1941
			if resp != nil {
1942
				typedResp, ok := resp.(*ListDelegationsResponse)
1943
				if !ok {
1944
					return nil, twirp.InternalError("failed type assertion resp.(*ListDelegationsResponse) when calling interceptor")
1945
				}
1946
				return typedResp, err
1947
			}
1948
			return nil, err
1949
		}
1950
	}
1951
 
1952
	// Call service method
1953
	var respContent *ListDelegationsResponse
1954
	func() {
1955
		defer ensurePanicResponses(ctx, resp, s.hooks)
1956
		respContent, err = handler(ctx, reqContent)
1957
	}()
1958
 
1959
	if err != nil {
1960
		s.writeError(ctx, resp, err)
1961
		return
1962
	}
1963
	if respContent == nil {
1964
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListDelegationsResponse and nil error while calling ListDelegations. nil responses are not supported"))
1965
		return
1966
	}
1967
 
1968
	ctx = callResponsePrepared(ctx, s.hooks)
1969
 
1970
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
1971
	respBytes, err := marshaler.Marshal(respContent)
1972
	if err != nil {
1973
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
1974
		return
1975
	}
1976
 
1977
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
1978
	resp.Header().Set("Content-Type", "application/json")
1979
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
1980
	resp.WriteHeader(http.StatusOK)
1981
 
1982
	if n, err := resp.Write(respBytes); err != nil {
1983
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
1984
		twerr := twirp.NewError(twirp.Unknown, msg)
1985
		ctx = callError(ctx, s.hooks, twerr)
1986
	}
1987
	callResponseSent(ctx, s.hooks)
1988
}
1989
 
1990
func (s *tunnelServiceServer) serveListDelegationsProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
1991
	var err error
1992
	ctx = ctxsetters.WithMethodName(ctx, "ListDelegations")
1993
	ctx, err = callRequestRouted(ctx, s.hooks)
1994
	if err != nil {
1995
		s.writeError(ctx, resp, err)
1996
		return
1997
	}
1998
 
1999
	buf, err := io.ReadAll(req.Body)
2000
	if err != nil {
2001
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2002
		return
2003
	}
2004
	reqContent := new(ListDelegationsRequest)
2005
	if err = reqContent.UnmarshalVT(buf); err != nil {
2006
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2007
		return
2008
	}
2009
 
2010
	handler := s.TunnelService.ListDelegations
2011
	if s.interceptor != nil {
2012
		handler = func(ctx context.Context, req *ListDelegationsRequest) (*ListDelegationsResponse, error) {
2013
			resp, err := s.interceptor(
2014
				func(ctx context.Context, req interface{}) (interface{}, error) {
2015
					typedReq, ok := req.(*ListDelegationsRequest)
2016
					if !ok {
2017
						return nil, twirp.InternalError("failed type assertion req.(*ListDelegationsRequest) when calling interceptor")
2018
					}
2019
					return s.TunnelService.ListDelegations(ctx, typedReq)
2020
				},
2021
			)(ctx, req)
2022
			if resp != nil {
2023
				typedResp, ok := resp.(*ListDelegationsResponse)
2024
				if !ok {
2025
					return nil, twirp.InternalError("failed type assertion resp.(*ListDelegationsResponse) when calling interceptor")
2026
				}
2027
				return typedResp, err
2028
			}
2029
			return nil, err
2030
		}
2031
	}
2032
 
2033
	// Call service method
2034
	var respContent *ListDelegationsResponse
2035
	func() {
2036
		defer ensurePanicResponses(ctx, resp, s.hooks)
2037
		respContent, err = handler(ctx, reqContent)
2038
	}()
2039
 
2040
	if err != nil {
2041
		s.writeError(ctx, resp, err)
2042
		return
2043
	}
2044
	if respContent == nil {
2045
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListDelegationsResponse and nil error while calling ListDelegations. nil responses are not supported"))
2046
		return
2047
	}
2048
 
2049
	ctx = callResponsePrepared(ctx, s.hooks)
2050
 
2051
	respBytes, err := respContent.MarshalVT()
2052
	if err != nil {
2053
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2054
		return
2055
	}
2056
 
2057
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2058
	resp.Header().Set("Content-Type", "application/protobuf")
2059
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2060
	resp.WriteHeader(http.StatusOK)
2061
	if n, err := resp.Write(respBytes); err != nil {
2062
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2063
		twerr := twirp.NewError(twirp.Unknown, msg)
2064
		ctx = callError(ctx, s.hooks, twerr)
2065
	}
2066
	callResponseSent(ctx, s.hooks)
2067
}
2068
 
2069
func (s *tunnelServiceServer) serveRevokeDelegation(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2070
	header := req.Header.Get("Content-Type")
2071
	i := strings.Index(header, ";")
2072
	if i == -1 {
2073
		i = len(header)
2074
	}
2075
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2076
	case "application/json":
2077
		s.serveRevokeDelegationJSON(ctx, resp, req)
2078
	case "application/protobuf":
2079
		s.serveRevokeDelegationProtobuf(ctx, resp, req)
2080
	default:
2081
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2082
		twerr := badRouteError(msg, req.Method, req.URL.Path)
2083
		s.writeError(ctx, resp, twerr)
2084
	}
2085
}
2086
 
2087
func (s *tunnelServiceServer) serveRevokeDelegationJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2088
	var err error
2089
	ctx = ctxsetters.WithMethodName(ctx, "RevokeDelegation")
2090
	ctx, err = callRequestRouted(ctx, s.hooks)
2091
	if err != nil {
2092
		s.writeError(ctx, resp, err)
2093
		return
2094
	}
2095
 
2096
	d := json.NewDecoder(req.Body)
2097
	rawReqBody := json.RawMessage{}
2098
	if err := d.Decode(&rawReqBody); err != nil {
2099
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2100
		return
2101
	}
2102
	reqContent := new(RevokeDelegationRequest)
2103
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
2104
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
2105
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2106
		return
2107
	}
2108
 
2109
	handler := s.TunnelService.RevokeDelegation
2110
	if s.interceptor != nil {
2111
		handler = func(ctx context.Context, req *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
2112
			resp, err := s.interceptor(
2113
				func(ctx context.Context, req interface{}) (interface{}, error) {
2114
					typedReq, ok := req.(*RevokeDelegationRequest)
2115
					if !ok {
2116
						return nil, twirp.InternalError("failed type assertion req.(*RevokeDelegationRequest) when calling interceptor")
2117
					}
2118
					return s.TunnelService.RevokeDelegation(ctx, typedReq)
2119
				},
2120
			)(ctx, req)
2121
			if resp != nil {
2122
				typedResp, ok := resp.(*RevokeDelegationResponse)
2123
				if !ok {
2124
					return nil, twirp.InternalError("failed type assertion resp.(*RevokeDelegationResponse) when calling interceptor")
2125
				}
2126
				return typedResp, err
2127
			}
2128
			return nil, err
2129
		}
2130
	}
2131
 
2132
	// Call service method
2133
	var respContent *RevokeDelegationResponse
2134
	func() {
2135
		defer ensurePanicResponses(ctx, resp, s.hooks)
2136
		respContent, err = handler(ctx, reqContent)
2137
	}()
2138
 
2139
	if err != nil {
2140
		s.writeError(ctx, resp, err)
2141
		return
2142
	}
2143
	if respContent == nil {
2144
		s.writeError(ctx, resp, twirp.InternalError("received a nil *RevokeDelegationResponse and nil error while calling RevokeDelegation. nil responses are not supported"))
2145
		return
2146
	}
2147
 
2148
	ctx = callResponsePrepared(ctx, s.hooks)
2149
 
2150
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2151
	respBytes, err := marshaler.Marshal(respContent)
2152
	if err != nil {
2153
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2154
		return
2155
	}
2156
 
2157
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2158
	resp.Header().Set("Content-Type", "application/json")
2159
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2160
	resp.WriteHeader(http.StatusOK)
2161
 
2162
	if n, err := resp.Write(respBytes); err != nil {
2163
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2164
		twerr := twirp.NewError(twirp.Unknown, msg)
2165
		ctx = callError(ctx, s.hooks, twerr)
2166
	}
2167
	callResponseSent(ctx, s.hooks)
2168
}
2169
 
2170
func (s *tunnelServiceServer) serveRevokeDelegationProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2171
	var err error
2172
	ctx = ctxsetters.WithMethodName(ctx, "RevokeDelegation")
2173
	ctx, err = callRequestRouted(ctx, s.hooks)
2174
	if err != nil {
2175
		s.writeError(ctx, resp, err)
2176
		return
2177
	}
2178
 
2179
	buf, err := io.ReadAll(req.Body)
2180
	if err != nil {
2181
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2182
		return
2183
	}
2184
	reqContent := new(RevokeDelegationRequest)
2185
	if err = reqContent.UnmarshalVT(buf); err != nil {
2186
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2187
		return
2188
	}
2189
 
2190
	handler := s.TunnelService.RevokeDelegation
2191
	if s.interceptor != nil {
2192
		handler = func(ctx context.Context, req *RevokeDelegationRequest) (*RevokeDelegationResponse, error) {
2193
			resp, err := s.interceptor(
2194
				func(ctx context.Context, req interface{}) (interface{}, error) {
2195
					typedReq, ok := req.(*RevokeDelegationRequest)
2196
					if !ok {
2197
						return nil, twirp.InternalError("failed type assertion req.(*RevokeDelegationRequest) when calling interceptor")
2198
					}
2199
					return s.TunnelService.RevokeDelegation(ctx, typedReq)
2200
				},
2201
			)(ctx, req)
2202
			if resp != nil {
2203
				typedResp, ok := resp.(*RevokeDelegationResponse)
2204
				if !ok {
2205
					return nil, twirp.InternalError("failed type assertion resp.(*RevokeDelegationResponse) when calling interceptor")
2206
				}
2207
				return typedResp, err
2208
			}
2209
			return nil, err
2210
		}
2211
	}
2212
 
2213
	// Call service method
2214
	var respContent *RevokeDelegationResponse
2215
	func() {
2216
		defer ensurePanicResponses(ctx, resp, s.hooks)
2217
		respContent, err = handler(ctx, reqContent)
2218
	}()
2219
 
2220
	if err != nil {
2221
		s.writeError(ctx, resp, err)
2222
		return
2223
	}
2224
	if respContent == nil {
2225
		s.writeError(ctx, resp, twirp.InternalError("received a nil *RevokeDelegationResponse and nil error while calling RevokeDelegation. nil responses are not supported"))
2226
		return
2227
	}
2228
 
2229
	ctx = callResponsePrepared(ctx, s.hooks)
2230
 
2231
	respBytes, err := respContent.MarshalVT()
2232
	if err != nil {
2233
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2234
		return
2235
	}
2236
 
2237
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2238
	resp.Header().Set("Content-Type", "application/protobuf")
2239
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2240
	resp.WriteHeader(http.StatusOK)
2241
	if n, err := resp.Write(respBytes); err != nil {
2242
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2243
		twerr := twirp.NewError(twirp.Unknown, msg)
2244
		ctx = callError(ctx, s.hooks, twerr)
2245
	}
2246
	callResponseSent(ctx, s.hooks)
2247
}
2248
 
2249
func (s *tunnelServiceServer) servePing(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2250
	header := req.Header.Get("Content-Type")
2251
	i := strings.Index(header, ";")
2252
	if i == -1 {
2253
		i = len(header)
2254
	}
2255
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2256
	case "application/json":
2257
		s.servePingJSON(ctx, resp, req)
2258
	case "application/protobuf":
2259
		s.servePingProtobuf(ctx, resp, req)
2260
	default:
2261
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2262
		twerr := badRouteError(msg, req.Method, req.URL.Path)
2263
		s.writeError(ctx, resp, twerr)
2264
	}
2265
}
2266
 
2267
func (s *tunnelServiceServer) servePingJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2268
	var err error
2269
	ctx = ctxsetters.WithMethodName(ctx, "Ping")
2270
	ctx, err = callRequestRouted(ctx, s.hooks)
2271
	if err != nil {
2272
		s.writeError(ctx, resp, err)
2273
		return
2274
	}
2275
 
2276
	d := json.NewDecoder(req.Body)
2277
	rawReqBody := json.RawMessage{}
2278
	if err := d.Decode(&rawReqBody); err != nil {
2279
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2280
		return
2281
	}
2282
	reqContent := new(ClientPingRequest)
2283
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
2284
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
2285
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2286
		return
2287
	}
2288
 
2289
	handler := s.TunnelService.Ping
2290
	if s.interceptor != nil {
2291
		handler = func(ctx context.Context, req *ClientPingRequest) (*ClientPingResponse, error) {
2292
			resp, err := s.interceptor(
2293
				func(ctx context.Context, req interface{}) (interface{}, error) {
2294
					typedReq, ok := req.(*ClientPingRequest)
2295
					if !ok {
2296
						return nil, twirp.InternalError("failed type assertion req.(*ClientPingRequest) when calling interceptor")
2297
					}
2298
					return s.TunnelService.Ping(ctx, typedReq)
2299
				},
2300
			)(ctx, req)
2301
			if resp != nil {
2302
				typedResp, ok := resp.(*ClientPingResponse)
2303
				if !ok {
2304
					return nil, twirp.InternalError("failed type assertion resp.(*ClientPingResponse) when calling interceptor")
2305
				}
2306
				return typedResp, err
2307
			}
2308
			return nil, err
2309
		}
2310
	}
2311
 
2312
	// Call service method
2313
	var respContent *ClientPingResponse
2314
	func() {
2315
		defer ensurePanicResponses(ctx, resp, s.hooks)
2316
		respContent, err = handler(ctx, reqContent)
2317
	}()
2318
 
2319
	if err != nil {
2320
		s.writeError(ctx, resp, err)
2321
		return
2322
	}
2323
	if respContent == nil {
2324
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ClientPingResponse and nil error while calling Ping. nil responses are not supported"))
2325
		return
2326
	}
2327
 
2328
	ctx = callResponsePrepared(ctx, s.hooks)
2329
 
2330
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2331
	respBytes, err := marshaler.Marshal(respContent)
2332
	if err != nil {
2333
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2334
		return
2335
	}
2336
 
2337
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2338
	resp.Header().Set("Content-Type", "application/json")
2339
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2340
	resp.WriteHeader(http.StatusOK)
2341
 
2342
	if n, err := resp.Write(respBytes); err != nil {
2343
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2344
		twerr := twirp.NewError(twirp.Unknown, msg)
2345
		ctx = callError(ctx, s.hooks, twerr)
2346
	}
2347
	callResponseSent(ctx, s.hooks)
2348
}
2349
 
2350
func (s *tunnelServiceServer) servePingProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2351
	var err error
2352
	ctx = ctxsetters.WithMethodName(ctx, "Ping")
2353
	ctx, err = callRequestRouted(ctx, s.hooks)
2354
	if err != nil {
2355
		s.writeError(ctx, resp, err)
2356
		return
2357
	}
2358
 
2359
	buf, err := io.ReadAll(req.Body)
2360
	if err != nil {
2361
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2362
		return
2363
	}
2364
	reqContent := new(ClientPingRequest)
2365
	if err = reqContent.UnmarshalVT(buf); err != nil {
2366
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2367
		return
2368
	}
2369
 
2370
	handler := s.TunnelService.Ping
2371
	if s.interceptor != nil {
2372
		handler = func(ctx context.Context, req *ClientPingRequest) (*ClientPingResponse, error) {
2373
			resp, err := s.interceptor(
2374
				func(ctx context.Context, req interface{}) (interface{}, error) {
2375
					typedReq, ok := req.(*ClientPingRequest)
2376
					if !ok {
2377
						return nil, twirp.InternalError("failed type assertion req.(*ClientPingRequest) when calling interceptor")
2378
					}
2379
					return s.TunnelService.Ping(ctx, typedReq)
2380
				},
2381
			)(ctx, req)
2382
			if resp != nil {
2383
				typedResp, ok := resp.(*ClientPingResponse)
2384
				if !ok {
2385
					return nil, twirp.InternalError("failed type assertion resp.(*ClientPingResponse) when calling interceptor")
2386
				}
2387
				return typedResp, err
2388
			}
2389
			return nil, err
2390
		}
2391
	}
2392
 
2393
	// Call service method
2394
	var respContent *ClientPingResponse
2395
	func() {
2396
		defer ensurePanicResponses(ctx, resp, s.hooks)
2397
		respContent, err = handler(ctx, reqContent)
2398
	}()
2399
 
2400
	if err != nil {
2401
		s.writeError(ctx, resp, err)
2402
		return
2403
	}
2404
	if respContent == nil {
2405
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ClientPingResponse and nil error while calling Ping. nil responses are not supported"))
2406
		return
2407
	}
2408
 
2409
	ctx = callResponsePrepared(ctx, s.hooks)
2410
 
2411
	respBytes, err := respContent.MarshalVT()
2412
	if err != nil {
2413
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2414
		return
2415
	}
2416
 
2417
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2418
	resp.Header().Set("Content-Type", "application/protobuf")
2419
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2420
	resp.WriteHeader(http.StatusOK)
2421
	if n, err := resp.Write(respBytes); err != nil {
2422
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2423
		twerr := twirp.NewError(twirp.Unknown, msg)
2424
		ctx = callError(ctx, s.hooks, twerr)
2425
	}
2426
	callResponseSent(ctx, s.hooks)
2427
}
2428
 
2429
func (s *tunnelServiceServer) serveRegisterIdentity(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2430
	header := req.Header.Get("Content-Type")
2431
	i := strings.Index(header, ";")
2432
	if i == -1 {
2433
		i = len(header)
2434
	}
2435
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2436
	case "application/json":
2437
		s.serveRegisterIdentityJSON(ctx, resp, req)
2438
	case "application/protobuf":
2439
		s.serveRegisterIdentityProtobuf(ctx, resp, req)
2440
	default:
2441
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2442
		twerr := badRouteError(msg, req.Method, req.URL.Path)
2443
		s.writeError(ctx, resp, twerr)
2444
	}
2445
}
2446
 
2447
func (s *tunnelServiceServer) serveRegisterIdentityJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2448
	var err error
2449
	ctx = ctxsetters.WithMethodName(ctx, "RegisterIdentity")
2450
	ctx, err = callRequestRouted(ctx, s.hooks)
2451
	if err != nil {
2452
		s.writeError(ctx, resp, err)
2453
		return
2454
	}
2455
 
2456
	d := json.NewDecoder(req.Body)
2457
	rawReqBody := json.RawMessage{}
2458
	if err := d.Decode(&rawReqBody); err != nil {
2459
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2460
		return
2461
	}
2462
	reqContent := new(RegisterIdentityRequest)
2463
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
2464
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
2465
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2466
		return
2467
	}
2468
 
2469
	handler := s.TunnelService.RegisterIdentity
2470
	if s.interceptor != nil {
2471
		handler = func(ctx context.Context, req *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
2472
			resp, err := s.interceptor(
2473
				func(ctx context.Context, req interface{}) (interface{}, error) {
2474
					typedReq, ok := req.(*RegisterIdentityRequest)
2475
					if !ok {
2476
						return nil, twirp.InternalError("failed type assertion req.(*RegisterIdentityRequest) when calling interceptor")
2477
					}
2478
					return s.TunnelService.RegisterIdentity(ctx, typedReq)
2479
				},
2480
			)(ctx, req)
2481
			if resp != nil {
2482
				typedResp, ok := resp.(*RegisterIdentityResponse)
2483
				if !ok {
2484
					return nil, twirp.InternalError("failed type assertion resp.(*RegisterIdentityResponse) when calling interceptor")
2485
				}
2486
				return typedResp, err
2487
			}
2488
			return nil, err
2489
		}
2490
	}
2491
 
2492
	// Call service method
2493
	var respContent *RegisterIdentityResponse
2494
	func() {
2495
		defer ensurePanicResponses(ctx, resp, s.hooks)
2496
		respContent, err = handler(ctx, reqContent)
2497
	}()
2498
 
2499
	if err != nil {
2500
		s.writeError(ctx, resp, err)
2501
		return
2502
	}
2503
	if respContent == nil {
2504
		s.writeError(ctx, resp, twirp.InternalError("received a nil *RegisterIdentityResponse and nil error while calling RegisterIdentity. nil responses are not supported"))
2505
		return
2506
	}
2507
 
2508
	ctx = callResponsePrepared(ctx, s.hooks)
2509
 
2510
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2511
	respBytes, err := marshaler.Marshal(respContent)
2512
	if err != nil {
2513
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2514
		return
2515
	}
2516
 
2517
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2518
	resp.Header().Set("Content-Type", "application/json")
2519
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2520
	resp.WriteHeader(http.StatusOK)
2521
 
2522
	if n, err := resp.Write(respBytes); err != nil {
2523
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2524
		twerr := twirp.NewError(twirp.Unknown, msg)
2525
		ctx = callError(ctx, s.hooks, twerr)
2526
	}
2527
	callResponseSent(ctx, s.hooks)
2528
}
2529
 
2530
func (s *tunnelServiceServer) serveRegisterIdentityProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2531
	var err error
2532
	ctx = ctxsetters.WithMethodName(ctx, "RegisterIdentity")
2533
	ctx, err = callRequestRouted(ctx, s.hooks)
2534
	if err != nil {
2535
		s.writeError(ctx, resp, err)
2536
		return
2537
	}
2538
 
2539
	buf, err := io.ReadAll(req.Body)
2540
	if err != nil {
2541
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2542
		return
2543
	}
2544
	reqContent := new(RegisterIdentityRequest)
2545
	if err = reqContent.UnmarshalVT(buf); err != nil {
2546
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2547
		return
2548
	}
2549
 
2550
	handler := s.TunnelService.RegisterIdentity
2551
	if s.interceptor != nil {
2552
		handler = func(ctx context.Context, req *RegisterIdentityRequest) (*RegisterIdentityResponse, error) {
2553
			resp, err := s.interceptor(
2554
				func(ctx context.Context, req interface{}) (interface{}, error) {
2555
					typedReq, ok := req.(*RegisterIdentityRequest)
2556
					if !ok {
2557
						return nil, twirp.InternalError("failed type assertion req.(*RegisterIdentityRequest) when calling interceptor")
2558
					}
2559
					return s.TunnelService.RegisterIdentity(ctx, typedReq)
2560
				},
2561
			)(ctx, req)
2562
			if resp != nil {
2563
				typedResp, ok := resp.(*RegisterIdentityResponse)
2564
				if !ok {
2565
					return nil, twirp.InternalError("failed type assertion resp.(*RegisterIdentityResponse) when calling interceptor")
2566
				}
2567
				return typedResp, err
2568
			}
2569
			return nil, err
2570
		}
2571
	}
2572
 
2573
	// Call service method
2574
	var respContent *RegisterIdentityResponse
2575
	func() {
2576
		defer ensurePanicResponses(ctx, resp, s.hooks)
2577
		respContent, err = handler(ctx, reqContent)
2578
	}()
2579
 
2580
	if err != nil {
2581
		s.writeError(ctx, resp, err)
2582
		return
2583
	}
2584
	if respContent == nil {
2585
		s.writeError(ctx, resp, twirp.InternalError("received a nil *RegisterIdentityResponse and nil error while calling RegisterIdentity. nil responses are not supported"))
2586
		return
2587
	}
2588
 
2589
	ctx = callResponsePrepared(ctx, s.hooks)
2590
 
2591
	respBytes, err := respContent.MarshalVT()
2592
	if err != nil {
2593
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2594
		return
2595
	}
2596
 
2597
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2598
	resp.Header().Set("Content-Type", "application/protobuf")
2599
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2600
	resp.WriteHeader(http.StatusOK)
2601
	if n, err := resp.Write(respBytes); err != nil {
2602
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2603
		twerr := twirp.NewError(twirp.Unknown, msg)
2604
		ctx = callError(ctx, s.hooks, twerr)
2605
	}
2606
	callResponseSent(ctx, s.hooks)
2607
}
2608
 
2609
func (s *tunnelServiceServer) serveGetNodes(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2610
	header := req.Header.Get("Content-Type")
2611
	i := strings.Index(header, ";")
2612
	if i == -1 {
2613
		i = len(header)
2614
	}
2615
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2616
	case "application/json":
2617
		s.serveGetNodesJSON(ctx, resp, req)
2618
	case "application/protobuf":
2619
		s.serveGetNodesProtobuf(ctx, resp, req)
2620
	default:
2621
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2622
		twerr := badRouteError(msg, req.Method, req.URL.Path)
2623
		s.writeError(ctx, resp, twerr)
2624
	}
2625
}
2626
 
2627
func (s *tunnelServiceServer) serveGetNodesJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2628
	var err error
2629
	ctx = ctxsetters.WithMethodName(ctx, "GetNodes")
2630
	ctx, err = callRequestRouted(ctx, s.hooks)
2631
	if err != nil {
2632
		s.writeError(ctx, resp, err)
2633
		return
2634
	}
2635
 
2636
	d := json.NewDecoder(req.Body)
2637
	rawReqBody := json.RawMessage{}
2638
	if err := d.Decode(&rawReqBody); err != nil {
2639
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2640
		return
2641
	}
2642
	reqContent := new(GetNodesRequest)
2643
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
2644
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
2645
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2646
		return
2647
	}
2648
 
2649
	handler := s.TunnelService.GetNodes
2650
	if s.interceptor != nil {
2651
		handler = func(ctx context.Context, req *GetNodesRequest) (*GetNodesResponse, error) {
2652
			resp, err := s.interceptor(
2653
				func(ctx context.Context, req interface{}) (interface{}, error) {
2654
					typedReq, ok := req.(*GetNodesRequest)
2655
					if !ok {
2656
						return nil, twirp.InternalError("failed type assertion req.(*GetNodesRequest) when calling interceptor")
2657
					}
2658
					return s.TunnelService.GetNodes(ctx, typedReq)
2659
				},
2660
			)(ctx, req)
2661
			if resp != nil {
2662
				typedResp, ok := resp.(*GetNodesResponse)
2663
				if !ok {
2664
					return nil, twirp.InternalError("failed type assertion resp.(*GetNodesResponse) when calling interceptor")
2665
				}
2666
				return typedResp, err
2667
			}
2668
			return nil, err
2669
		}
2670
	}
2671
 
2672
	// Call service method
2673
	var respContent *GetNodesResponse
2674
	func() {
2675
		defer ensurePanicResponses(ctx, resp, s.hooks)
2676
		respContent, err = handler(ctx, reqContent)
2677
	}()
2678
 
2679
	if err != nil {
2680
		s.writeError(ctx, resp, err)
2681
		return
2682
	}
2683
	if respContent == nil {
2684
		s.writeError(ctx, resp, twirp.InternalError("received a nil *GetNodesResponse and nil error while calling GetNodes. nil responses are not supported"))
2685
		return
2686
	}
2687
 
2688
	ctx = callResponsePrepared(ctx, s.hooks)
2689
 
2690
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2691
	respBytes, err := marshaler.Marshal(respContent)
2692
	if err != nil {
2693
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2694
		return
2695
	}
2696
 
2697
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2698
	resp.Header().Set("Content-Type", "application/json")
2699
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2700
	resp.WriteHeader(http.StatusOK)
2701
 
2702
	if n, err := resp.Write(respBytes); err != nil {
2703
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2704
		twerr := twirp.NewError(twirp.Unknown, msg)
2705
		ctx = callError(ctx, s.hooks, twerr)
2706
	}
2707
	callResponseSent(ctx, s.hooks)
2708
}
2709
 
2710
func (s *tunnelServiceServer) serveGetNodesProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2711
	var err error
2712
	ctx = ctxsetters.WithMethodName(ctx, "GetNodes")
2713
	ctx, err = callRequestRouted(ctx, s.hooks)
2714
	if err != nil {
2715
		s.writeError(ctx, resp, err)
2716
		return
2717
	}
2718
 
2719
	buf, err := io.ReadAll(req.Body)
2720
	if err != nil {
2721
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2722
		return
2723
	}
2724
	reqContent := new(GetNodesRequest)
2725
	if err = reqContent.UnmarshalVT(buf); err != nil {
2726
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2727
		return
2728
	}
2729
 
2730
	handler := s.TunnelService.GetNodes
2731
	if s.interceptor != nil {
2732
		handler = func(ctx context.Context, req *GetNodesRequest) (*GetNodesResponse, error) {
2733
			resp, err := s.interceptor(
2734
				func(ctx context.Context, req interface{}) (interface{}, error) {
2735
					typedReq, ok := req.(*GetNodesRequest)
2736
					if !ok {
2737
						return nil, twirp.InternalError("failed type assertion req.(*GetNodesRequest) when calling interceptor")
2738
					}
2739
					return s.TunnelService.GetNodes(ctx, typedReq)
2740
				},
2741
			)(ctx, req)
2742
			if resp != nil {
2743
				typedResp, ok := resp.(*GetNodesResponse)
2744
				if !ok {
2745
					return nil, twirp.InternalError("failed type assertion resp.(*GetNodesResponse) when calling interceptor")
2746
				}
2747
				return typedResp, err
2748
			}
2749
			return nil, err
2750
		}
2751
	}
2752
 
2753
	// Call service method
2754
	var respContent *GetNodesResponse
2755
	func() {
2756
		defer ensurePanicResponses(ctx, resp, s.hooks)
2757
		respContent, err = handler(ctx, reqContent)
2758
	}()
2759
 
2760
	if err != nil {
2761
		s.writeError(ctx, resp, err)
2762
		return
2763
	}
2764
	if respContent == nil {
2765
		s.writeError(ctx, resp, twirp.InternalError("received a nil *GetNodesResponse and nil error while calling GetNodes. nil responses are not supported"))
2766
		return
2767
	}
2768
 
2769
	ctx = callResponsePrepared(ctx, s.hooks)
2770
 
2771
	respBytes, err := respContent.MarshalVT()
2772
	if err != nil {
2773
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2774
		return
2775
	}
2776
 
2777
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2778
	resp.Header().Set("Content-Type", "application/protobuf")
2779
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2780
	resp.WriteHeader(http.StatusOK)
2781
	if n, err := resp.Write(respBytes); err != nil {
2782
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2783
		twerr := twirp.NewError(twirp.Unknown, msg)
2784
		ctx = callError(ctx, s.hooks, twerr)
2785
	}
2786
	callResponseSent(ctx, s.hooks)
2787
}
2788
 
2789
func (s *tunnelServiceServer) serveGenerateHostname(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2790
	header := req.Header.Get("Content-Type")
2791
	i := strings.Index(header, ";")
2792
	if i == -1 {
2793
		i = len(header)
2794
	}
2795
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2796
	case "application/json":
2797
		s.serveGenerateHostnameJSON(ctx, resp, req)
2798
	case "application/protobuf":
2799
		s.serveGenerateHostnameProtobuf(ctx, resp, req)
2800
	default:
2801
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2802
		twerr := badRouteError(msg, req.Method, req.URL.Path)
2803
		s.writeError(ctx, resp, twerr)
2804
	}
2805
}
2806
 
2807
func (s *tunnelServiceServer) serveGenerateHostnameJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2808
	var err error
2809
	ctx = ctxsetters.WithMethodName(ctx, "GenerateHostname")
2810
	ctx, err = callRequestRouted(ctx, s.hooks)
2811
	if err != nil {
2812
		s.writeError(ctx, resp, err)
2813
		return
2814
	}
2815
 
2816
	d := json.NewDecoder(req.Body)
2817
	rawReqBody := json.RawMessage{}
2818
	if err := d.Decode(&rawReqBody); err != nil {
2819
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2820
		return
2821
	}
2822
	reqContent := new(GenerateHostnameRequest)
2823
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
2824
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
2825
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
2826
		return
2827
	}
2828
 
2829
	handler := s.TunnelService.GenerateHostname
2830
	if s.interceptor != nil {
2831
		handler = func(ctx context.Context, req *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
2832
			resp, err := s.interceptor(
2833
				func(ctx context.Context, req interface{}) (interface{}, error) {
2834
					typedReq, ok := req.(*GenerateHostnameRequest)
2835
					if !ok {
2836
						return nil, twirp.InternalError("failed type assertion req.(*GenerateHostnameRequest) when calling interceptor")
2837
					}
2838
					return s.TunnelService.GenerateHostname(ctx, typedReq)
2839
				},
2840
			)(ctx, req)
2841
			if resp != nil {
2842
				typedResp, ok := resp.(*GenerateHostnameResponse)
2843
				if !ok {
2844
					return nil, twirp.InternalError("failed type assertion resp.(*GenerateHostnameResponse) when calling interceptor")
2845
				}
2846
				return typedResp, err
2847
			}
2848
			return nil, err
2849
		}
2850
	}
2851
 
2852
	// Call service method
2853
	var respContent *GenerateHostnameResponse
2854
	func() {
2855
		defer ensurePanicResponses(ctx, resp, s.hooks)
2856
		respContent, err = handler(ctx, reqContent)
2857
	}()
2858
 
2859
	if err != nil {
2860
		s.writeError(ctx, resp, err)
2861
		return
2862
	}
2863
	if respContent == nil {
2864
		s.writeError(ctx, resp, twirp.InternalError("received a nil *GenerateHostnameResponse and nil error while calling GenerateHostname. nil responses are not supported"))
2865
		return
2866
	}
2867
 
2868
	ctx = callResponsePrepared(ctx, s.hooks)
2869
 
2870
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
2871
	respBytes, err := marshaler.Marshal(respContent)
2872
	if err != nil {
2873
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
2874
		return
2875
	}
2876
 
2877
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2878
	resp.Header().Set("Content-Type", "application/json")
2879
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2880
	resp.WriteHeader(http.StatusOK)
2881
 
2882
	if n, err := resp.Write(respBytes); err != nil {
2883
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2884
		twerr := twirp.NewError(twirp.Unknown, msg)
2885
		ctx = callError(ctx, s.hooks, twerr)
2886
	}
2887
	callResponseSent(ctx, s.hooks)
2888
}
2889
 
2890
func (s *tunnelServiceServer) serveGenerateHostnameProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2891
	var err error
2892
	ctx = ctxsetters.WithMethodName(ctx, "GenerateHostname")
2893
	ctx, err = callRequestRouted(ctx, s.hooks)
2894
	if err != nil {
2895
		s.writeError(ctx, resp, err)
2896
		return
2897
	}
2898
 
2899
	buf, err := io.ReadAll(req.Body)
2900
	if err != nil {
2901
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
2902
		return
2903
	}
2904
	reqContent := new(GenerateHostnameRequest)
2905
	if err = reqContent.UnmarshalVT(buf); err != nil {
2906
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
2907
		return
2908
	}
2909
 
2910
	handler := s.TunnelService.GenerateHostname
2911
	if s.interceptor != nil {
2912
		handler = func(ctx context.Context, req *GenerateHostnameRequest) (*GenerateHostnameResponse, error) {
2913
			resp, err := s.interceptor(
2914
				func(ctx context.Context, req interface{}) (interface{}, error) {
2915
					typedReq, ok := req.(*GenerateHostnameRequest)
2916
					if !ok {
2917
						return nil, twirp.InternalError("failed type assertion req.(*GenerateHostnameRequest) when calling interceptor")
2918
					}
2919
					return s.TunnelService.GenerateHostname(ctx, typedReq)
2920
				},
2921
			)(ctx, req)
2922
			if resp != nil {
2923
				typedResp, ok := resp.(*GenerateHostnameResponse)
2924
				if !ok {
2925
					return nil, twirp.InternalError("failed type assertion resp.(*GenerateHostnameResponse) when calling interceptor")
2926
				}
2927
				return typedResp, err
2928
			}
2929
			return nil, err
2930
		}
2931
	}
2932
 
2933
	// Call service method
2934
	var respContent *GenerateHostnameResponse
2935
	func() {
2936
		defer ensurePanicResponses(ctx, resp, s.hooks)
2937
		respContent, err = handler(ctx, reqContent)
2938
	}()
2939
 
2940
	if err != nil {
2941
		s.writeError(ctx, resp, err)
2942
		return
2943
	}
2944
	if respContent == nil {
2945
		s.writeError(ctx, resp, twirp.InternalError("received a nil *GenerateHostnameResponse and nil error while calling GenerateHostname. nil responses are not supported"))
2946
		return
2947
	}
2948
 
2949
	ctx = callResponsePrepared(ctx, s.hooks)
2950
 
2951
	respBytes, err := respContent.MarshalVT()
2952
	if err != nil {
2953
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
2954
		return
2955
	}
2956
 
2957
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
2958
	resp.Header().Set("Content-Type", "application/protobuf")
2959
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
2960
	resp.WriteHeader(http.StatusOK)
2961
	if n, err := resp.Write(respBytes); err != nil {
2962
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
2963
		twerr := twirp.NewError(twirp.Unknown, msg)
2964
		ctx = callError(ctx, s.hooks, twerr)
2965
	}
2966
	callResponseSent(ctx, s.hooks)
2967
}
2968
 
2969
func (s *tunnelServiceServer) serveRegisteredHostnames(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2970
	header := req.Header.Get("Content-Type")
2971
	i := strings.Index(header, ";")
2972
	if i == -1 {
2973
		i = len(header)
2974
	}
2975
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
2976
	case "application/json":
2977
		s.serveRegisteredHostnamesJSON(ctx, resp, req)
2978
	case "application/protobuf":
2979
		s.serveRegisteredHostnamesProtobuf(ctx, resp, req)
2980
	default:
2981
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
2982
		twerr := badRouteError(msg, req.Method, req.URL.Path)
2983
		s.writeError(ctx, resp, twerr)
2984
	}
2985
}
2986
 
2987
func (s *tunnelServiceServer) serveRegisteredHostnamesJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
2988
	var err error
2989
	ctx = ctxsetters.WithMethodName(ctx, "RegisteredHostnames")
2990
	ctx, err = callRequestRouted(ctx, s.hooks)
2991
	if err != nil {
2992
		s.writeError(ctx, resp, err)
2993
		return
2994
	}
2995
 
2996
	d := json.NewDecoder(req.Body)
2997
	rawReqBody := json.RawMessage{}
2998
	if err := d.Decode(&rawReqBody); err != nil {
2999
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3000
		return
3001
	}
3002
	reqContent := new(RegisteredHostnamesRequest)
3003
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
3004
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
3005
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3006
		return
3007
	}
3008
 
3009
	handler := s.TunnelService.RegisteredHostnames
3010
	if s.interceptor != nil {
3011
		handler = func(ctx context.Context, req *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
3012
			resp, err := s.interceptor(
3013
				func(ctx context.Context, req interface{}) (interface{}, error) {
3014
					typedReq, ok := req.(*RegisteredHostnamesRequest)
3015
					if !ok {
3016
						return nil, twirp.InternalError("failed type assertion req.(*RegisteredHostnamesRequest) when calling interceptor")
3017
					}
3018
					return s.TunnelService.RegisteredHostnames(ctx, typedReq)
3019
				},
3020
			)(ctx, req)
3021
			if resp != nil {
3022
				typedResp, ok := resp.(*RegisteredHostnamesResponse)
3023
				if !ok {
3024
					return nil, twirp.InternalError("failed type assertion resp.(*RegisteredHostnamesResponse) when calling interceptor")
3025
				}
3026
				return typedResp, err
3027
			}
3028
			return nil, err
3029
		}
3030
	}
3031
 
3032
	// Call service method
3033
	var respContent *RegisteredHostnamesResponse
3034
	func() {
3035
		defer ensurePanicResponses(ctx, resp, s.hooks)
3036
		respContent, err = handler(ctx, reqContent)
3037
	}()
3038
 
3039
	if err != nil {
3040
		s.writeError(ctx, resp, err)
3041
		return
3042
	}
3043
	if respContent == nil {
3044
		s.writeError(ctx, resp, twirp.InternalError("received a nil *RegisteredHostnamesResponse and nil error while calling RegisteredHostnames. nil responses are not supported"))
3045
		return
3046
	}
3047
 
3048
	ctx = callResponsePrepared(ctx, s.hooks)
3049
 
3050
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
3051
	respBytes, err := marshaler.Marshal(respContent)
3052
	if err != nil {
3053
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
3054
		return
3055
	}
3056
 
3057
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3058
	resp.Header().Set("Content-Type", "application/json")
3059
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3060
	resp.WriteHeader(http.StatusOK)
3061
 
3062
	if n, err := resp.Write(respBytes); err != nil {
3063
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3064
		twerr := twirp.NewError(twirp.Unknown, msg)
3065
		ctx = callError(ctx, s.hooks, twerr)
3066
	}
3067
	callResponseSent(ctx, s.hooks)
3068
}
3069
 
3070
func (s *tunnelServiceServer) serveRegisteredHostnamesProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3071
	var err error
3072
	ctx = ctxsetters.WithMethodName(ctx, "RegisteredHostnames")
3073
	ctx, err = callRequestRouted(ctx, s.hooks)
3074
	if err != nil {
3075
		s.writeError(ctx, resp, err)
3076
		return
3077
	}
3078
 
3079
	buf, err := io.ReadAll(req.Body)
3080
	if err != nil {
3081
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
3082
		return
3083
	}
3084
	reqContent := new(RegisteredHostnamesRequest)
3085
	if err = reqContent.UnmarshalVT(buf); err != nil {
3086
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
3087
		return
3088
	}
3089
 
3090
	handler := s.TunnelService.RegisteredHostnames
3091
	if s.interceptor != nil {
3092
		handler = func(ctx context.Context, req *RegisteredHostnamesRequest) (*RegisteredHostnamesResponse, error) {
3093
			resp, err := s.interceptor(
3094
				func(ctx context.Context, req interface{}) (interface{}, error) {
3095
					typedReq, ok := req.(*RegisteredHostnamesRequest)
3096
					if !ok {
3097
						return nil, twirp.InternalError("failed type assertion req.(*RegisteredHostnamesRequest) when calling interceptor")
3098
					}
3099
					return s.TunnelService.RegisteredHostnames(ctx, typedReq)
3100
				},
3101
			)(ctx, req)
3102
			if resp != nil {
3103
				typedResp, ok := resp.(*RegisteredHostnamesResponse)
3104
				if !ok {
3105
					return nil, twirp.InternalError("failed type assertion resp.(*RegisteredHostnamesResponse) when calling interceptor")
3106
				}
3107
				return typedResp, err
3108
			}
3109
			return nil, err
3110
		}
3111
	}
3112
 
3113
	// Call service method
3114
	var respContent *RegisteredHostnamesResponse
3115
	func() {
3116
		defer ensurePanicResponses(ctx, resp, s.hooks)
3117
		respContent, err = handler(ctx, reqContent)
3118
	}()
3119
 
3120
	if err != nil {
3121
		s.writeError(ctx, resp, err)
3122
		return
3123
	}
3124
	if respContent == nil {
3125
		s.writeError(ctx, resp, twirp.InternalError("received a nil *RegisteredHostnamesResponse and nil error while calling RegisteredHostnames. nil responses are not supported"))
3126
		return
3127
	}
3128
 
3129
	ctx = callResponsePrepared(ctx, s.hooks)
3130
 
3131
	respBytes, err := respContent.MarshalVT()
3132
	if err != nil {
3133
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
3134
		return
3135
	}
3136
 
3137
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3138
	resp.Header().Set("Content-Type", "application/protobuf")
3139
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3140
	resp.WriteHeader(http.StatusOK)
3141
	if n, err := resp.Write(respBytes); err != nil {
3142
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3143
		twerr := twirp.NewError(twirp.Unknown, msg)
3144
		ctx = callError(ctx, s.hooks, twerr)
3145
	}
3146
	callResponseSent(ctx, s.hooks)
3147
}
3148
 
3149
func (s *tunnelServiceServer) servePublishTunnel(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3150
	header := req.Header.Get("Content-Type")
3151
	i := strings.Index(header, ";")
3152
	if i == -1 {
3153
		i = len(header)
3154
	}
3155
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
3156
	case "application/json":
3157
		s.servePublishTunnelJSON(ctx, resp, req)
3158
	case "application/protobuf":
3159
		s.servePublishTunnelProtobuf(ctx, resp, req)
3160
	default:
3161
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
3162
		twerr := badRouteError(msg, req.Method, req.URL.Path)
3163
		s.writeError(ctx, resp, twerr)
3164
	}
3165
}
3166
 
3167
func (s *tunnelServiceServer) servePublishTunnelJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3168
	var err error
3169
	ctx = ctxsetters.WithMethodName(ctx, "PublishTunnel")
3170
	ctx, err = callRequestRouted(ctx, s.hooks)
3171
	if err != nil {
3172
		s.writeError(ctx, resp, err)
3173
		return
3174
	}
3175
 
3176
	d := json.NewDecoder(req.Body)
3177
	rawReqBody := json.RawMessage{}
3178
	if err := d.Decode(&rawReqBody); err != nil {
3179
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3180
		return
3181
	}
3182
	reqContent := new(PublishTunnelRequest)
3183
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
3184
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
3185
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3186
		return
3187
	}
3188
 
3189
	handler := s.TunnelService.PublishTunnel
3190
	if s.interceptor != nil {
3191
		handler = func(ctx context.Context, req *PublishTunnelRequest) (*PublishTunnelResponse, error) {
3192
			resp, err := s.interceptor(
3193
				func(ctx context.Context, req interface{}) (interface{}, error) {
3194
					typedReq, ok := req.(*PublishTunnelRequest)
3195
					if !ok {
3196
						return nil, twirp.InternalError("failed type assertion req.(*PublishTunnelRequest) when calling interceptor")
3197
					}
3198
					return s.TunnelService.PublishTunnel(ctx, typedReq)
3199
				},
3200
			)(ctx, req)
3201
			if resp != nil {
3202
				typedResp, ok := resp.(*PublishTunnelResponse)
3203
				if !ok {
3204
					return nil, twirp.InternalError("failed type assertion resp.(*PublishTunnelResponse) when calling interceptor")
3205
				}
3206
				return typedResp, err
3207
			}
3208
			return nil, err
3209
		}
3210
	}
3211
 
3212
	// Call service method
3213
	var respContent *PublishTunnelResponse
3214
	func() {
3215
		defer ensurePanicResponses(ctx, resp, s.hooks)
3216
		respContent, err = handler(ctx, reqContent)
3217
	}()
3218
 
3219
	if err != nil {
3220
		s.writeError(ctx, resp, err)
3221
		return
3222
	}
3223
	if respContent == nil {
3224
		s.writeError(ctx, resp, twirp.InternalError("received a nil *PublishTunnelResponse and nil error while calling PublishTunnel. nil responses are not supported"))
3225
		return
3226
	}
3227
 
3228
	ctx = callResponsePrepared(ctx, s.hooks)
3229
 
3230
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
3231
	respBytes, err := marshaler.Marshal(respContent)
3232
	if err != nil {
3233
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
3234
		return
3235
	}
3236
 
3237
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3238
	resp.Header().Set("Content-Type", "application/json")
3239
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3240
	resp.WriteHeader(http.StatusOK)
3241
 
3242
	if n, err := resp.Write(respBytes); err != nil {
3243
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3244
		twerr := twirp.NewError(twirp.Unknown, msg)
3245
		ctx = callError(ctx, s.hooks, twerr)
3246
	}
3247
	callResponseSent(ctx, s.hooks)
3248
}
3249
 
3250
func (s *tunnelServiceServer) servePublishTunnelProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3251
	var err error
3252
	ctx = ctxsetters.WithMethodName(ctx, "PublishTunnel")
3253
	ctx, err = callRequestRouted(ctx, s.hooks)
3254
	if err != nil {
3255
		s.writeError(ctx, resp, err)
3256
		return
3257
	}
3258
 
3259
	buf, err := io.ReadAll(req.Body)
3260
	if err != nil {
3261
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
3262
		return
3263
	}
3264
	reqContent := new(PublishTunnelRequest)
3265
	if err = reqContent.UnmarshalVT(buf); err != nil {
3266
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
3267
		return
3268
	}
3269
 
3270
	handler := s.TunnelService.PublishTunnel
3271
	if s.interceptor != nil {
3272
		handler = func(ctx context.Context, req *PublishTunnelRequest) (*PublishTunnelResponse, error) {
3273
			resp, err := s.interceptor(
3274
				func(ctx context.Context, req interface{}) (interface{}, error) {
3275
					typedReq, ok := req.(*PublishTunnelRequest)
3276
					if !ok {
3277
						return nil, twirp.InternalError("failed type assertion req.(*PublishTunnelRequest) when calling interceptor")
3278
					}
3279
					return s.TunnelService.PublishTunnel(ctx, typedReq)
3280
				},
3281
			)(ctx, req)
3282
			if resp != nil {
3283
				typedResp, ok := resp.(*PublishTunnelResponse)
3284
				if !ok {
3285
					return nil, twirp.InternalError("failed type assertion resp.(*PublishTunnelResponse) when calling interceptor")
3286
				}
3287
				return typedResp, err
3288
			}
3289
			return nil, err
3290
		}
3291
	}
3292
 
3293
	// Call service method
3294
	var respContent *PublishTunnelResponse
3295
	func() {
3296
		defer ensurePanicResponses(ctx, resp, s.hooks)
3297
		respContent, err = handler(ctx, reqContent)
3298
	}()
3299
 
3300
	if err != nil {
3301
		s.writeError(ctx, resp, err)
3302
		return
3303
	}
3304
	if respContent == nil {
3305
		s.writeError(ctx, resp, twirp.InternalError("received a nil *PublishTunnelResponse and nil error while calling PublishTunnel. nil responses are not supported"))
3306
		return
3307
	}
3308
 
3309
	ctx = callResponsePrepared(ctx, s.hooks)
3310
 
3311
	respBytes, err := respContent.MarshalVT()
3312
	if err != nil {
3313
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
3314
		return
3315
	}
3316
 
3317
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3318
	resp.Header().Set("Content-Type", "application/protobuf")
3319
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3320
	resp.WriteHeader(http.StatusOK)
3321
	if n, err := resp.Write(respBytes); err != nil {
3322
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3323
		twerr := twirp.NewError(twirp.Unknown, msg)
3324
		ctx = callError(ctx, s.hooks, twerr)
3325
	}
3326
	callResponseSent(ctx, s.hooks)
3327
}
3328
 
3329
func (s *tunnelServiceServer) serveUnpublishTunnel(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3330
	header := req.Header.Get("Content-Type")
3331
	i := strings.Index(header, ";")
3332
	if i == -1 {
3333
		i = len(header)
3334
	}
3335
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
3336
	case "application/json":
3337
		s.serveUnpublishTunnelJSON(ctx, resp, req)
3338
	case "application/protobuf":
3339
		s.serveUnpublishTunnelProtobuf(ctx, resp, req)
3340
	default:
3341
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
3342
		twerr := badRouteError(msg, req.Method, req.URL.Path)
3343
		s.writeError(ctx, resp, twerr)
3344
	}
3345
}
3346
 
3347
func (s *tunnelServiceServer) serveUnpublishTunnelJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3348
	var err error
3349
	ctx = ctxsetters.WithMethodName(ctx, "UnpublishTunnel")
3350
	ctx, err = callRequestRouted(ctx, s.hooks)
3351
	if err != nil {
3352
		s.writeError(ctx, resp, err)
3353
		return
3354
	}
3355
 
3356
	d := json.NewDecoder(req.Body)
3357
	rawReqBody := json.RawMessage{}
3358
	if err := d.Decode(&rawReqBody); err != nil {
3359
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3360
		return
3361
	}
3362
	reqContent := new(UnpublishTunnelRequest)
3363
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
3364
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
3365
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3366
		return
3367
	}
3368
 
3369
	handler := s.TunnelService.UnpublishTunnel
3370
	if s.interceptor != nil {
3371
		handler = func(ctx context.Context, req *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
3372
			resp, err := s.interceptor(
3373
				func(ctx context.Context, req interface{}) (interface{}, error) {
3374
					typedReq, ok := req.(*UnpublishTunnelRequest)
3375
					if !ok {
3376
						return nil, twirp.InternalError("failed type assertion req.(*UnpublishTunnelRequest) when calling interceptor")
3377
					}
3378
					return s.TunnelService.UnpublishTunnel(ctx, typedReq)
3379
				},
3380
			)(ctx, req)
3381
			if resp != nil {
3382
				typedResp, ok := resp.(*UnpublishTunnelResponse)
3383
				if !ok {
3384
					return nil, twirp.InternalError("failed type assertion resp.(*UnpublishTunnelResponse) when calling interceptor")
3385
				}
3386
				return typedResp, err
3387
			}
3388
			return nil, err
3389
		}
3390
	}
3391
 
3392
	// Call service method
3393
	var respContent *UnpublishTunnelResponse
3394
	func() {
3395
		defer ensurePanicResponses(ctx, resp, s.hooks)
3396
		respContent, err = handler(ctx, reqContent)
3397
	}()
3398
 
3399
	if err != nil {
3400
		s.writeError(ctx, resp, err)
3401
		return
3402
	}
3403
	if respContent == nil {
3404
		s.writeError(ctx, resp, twirp.InternalError("received a nil *UnpublishTunnelResponse and nil error while calling UnpublishTunnel. nil responses are not supported"))
3405
		return
3406
	}
3407
 
3408
	ctx = callResponsePrepared(ctx, s.hooks)
3409
 
3410
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
3411
	respBytes, err := marshaler.Marshal(respContent)
3412
	if err != nil {
3413
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
3414
		return
3415
	}
3416
 
3417
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3418
	resp.Header().Set("Content-Type", "application/json")
3419
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3420
	resp.WriteHeader(http.StatusOK)
3421
 
3422
	if n, err := resp.Write(respBytes); err != nil {
3423
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3424
		twerr := twirp.NewError(twirp.Unknown, msg)
3425
		ctx = callError(ctx, s.hooks, twerr)
3426
	}
3427
	callResponseSent(ctx, s.hooks)
3428
}
3429
 
3430
func (s *tunnelServiceServer) serveUnpublishTunnelProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3431
	var err error
3432
	ctx = ctxsetters.WithMethodName(ctx, "UnpublishTunnel")
3433
	ctx, err = callRequestRouted(ctx, s.hooks)
3434
	if err != nil {
3435
		s.writeError(ctx, resp, err)
3436
		return
3437
	}
3438
 
3439
	buf, err := io.ReadAll(req.Body)
3440
	if err != nil {
3441
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
3442
		return
3443
	}
3444
	reqContent := new(UnpublishTunnelRequest)
3445
	if err = reqContent.UnmarshalVT(buf); err != nil {
3446
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
3447
		return
3448
	}
3449
 
3450
	handler := s.TunnelService.UnpublishTunnel
3451
	if s.interceptor != nil {
3452
		handler = func(ctx context.Context, req *UnpublishTunnelRequest) (*UnpublishTunnelResponse, error) {
3453
			resp, err := s.interceptor(
3454
				func(ctx context.Context, req interface{}) (interface{}, error) {
3455
					typedReq, ok := req.(*UnpublishTunnelRequest)
3456
					if !ok {
3457
						return nil, twirp.InternalError("failed type assertion req.(*UnpublishTunnelRequest) when calling interceptor")
3458
					}
3459
					return s.TunnelService.UnpublishTunnel(ctx, typedReq)
3460
				},
3461
			)(ctx, req)
3462
			if resp != nil {
3463
				typedResp, ok := resp.(*UnpublishTunnelResponse)
3464
				if !ok {
3465
					return nil, twirp.InternalError("failed type assertion resp.(*UnpublishTunnelResponse) when calling interceptor")
3466
				}
3467
				return typedResp, err
3468
			}
3469
			return nil, err
3470
		}
3471
	}
3472
 
3473
	// Call service method
3474
	var respContent *UnpublishTunnelResponse
3475
	func() {
3476
		defer ensurePanicResponses(ctx, resp, s.hooks)
3477
		respContent, err = handler(ctx, reqContent)
3478
	}()
3479
 
3480
	if err != nil {
3481
		s.writeError(ctx, resp, err)
3482
		return
3483
	}
3484
	if respContent == nil {
3485
		s.writeError(ctx, resp, twirp.InternalError("received a nil *UnpublishTunnelResponse and nil error while calling UnpublishTunnel. nil responses are not supported"))
3486
		return
3487
	}
3488
 
3489
	ctx = callResponsePrepared(ctx, s.hooks)
3490
 
3491
	respBytes, err := respContent.MarshalVT()
3492
	if err != nil {
3493
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
3494
		return
3495
	}
3496
 
3497
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3498
	resp.Header().Set("Content-Type", "application/protobuf")
3499
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3500
	resp.WriteHeader(http.StatusOK)
3501
	if n, err := resp.Write(respBytes); err != nil {
3502
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3503
		twerr := twirp.NewError(twirp.Unknown, msg)
3504
		ctx = callError(ctx, s.hooks, twerr)
3505
	}
3506
	callResponseSent(ctx, s.hooks)
3507
}
3508
 
3509
func (s *tunnelServiceServer) serveReleaseTunnel(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3510
	header := req.Header.Get("Content-Type")
3511
	i := strings.Index(header, ";")
3512
	if i == -1 {
3513
		i = len(header)
3514
	}
3515
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
3516
	case "application/json":
3517
		s.serveReleaseTunnelJSON(ctx, resp, req)
3518
	case "application/protobuf":
3519
		s.serveReleaseTunnelProtobuf(ctx, resp, req)
3520
	default:
3521
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
3522
		twerr := badRouteError(msg, req.Method, req.URL.Path)
3523
		s.writeError(ctx, resp, twerr)
3524
	}
3525
}
3526
 
3527
func (s *tunnelServiceServer) serveReleaseTunnelJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3528
	var err error
3529
	ctx = ctxsetters.WithMethodName(ctx, "ReleaseTunnel")
3530
	ctx, err = callRequestRouted(ctx, s.hooks)
3531
	if err != nil {
3532
		s.writeError(ctx, resp, err)
3533
		return
3534
	}
3535
 
3536
	d := json.NewDecoder(req.Body)
3537
	rawReqBody := json.RawMessage{}
3538
	if err := d.Decode(&rawReqBody); err != nil {
3539
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3540
		return
3541
	}
3542
	reqContent := new(ReleaseTunnelRequest)
3543
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
3544
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
3545
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3546
		return
3547
	}
3548
 
3549
	handler := s.TunnelService.ReleaseTunnel
3550
	if s.interceptor != nil {
3551
		handler = func(ctx context.Context, req *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
3552
			resp, err := s.interceptor(
3553
				func(ctx context.Context, req interface{}) (interface{}, error) {
3554
					typedReq, ok := req.(*ReleaseTunnelRequest)
3555
					if !ok {
3556
						return nil, twirp.InternalError("failed type assertion req.(*ReleaseTunnelRequest) when calling interceptor")
3557
					}
3558
					return s.TunnelService.ReleaseTunnel(ctx, typedReq)
3559
				},
3560
			)(ctx, req)
3561
			if resp != nil {
3562
				typedResp, ok := resp.(*ReleaseTunnelResponse)
3563
				if !ok {
3564
					return nil, twirp.InternalError("failed type assertion resp.(*ReleaseTunnelResponse) when calling interceptor")
3565
				}
3566
				return typedResp, err
3567
			}
3568
			return nil, err
3569
		}
3570
	}
3571
 
3572
	// Call service method
3573
	var respContent *ReleaseTunnelResponse
3574
	func() {
3575
		defer ensurePanicResponses(ctx, resp, s.hooks)
3576
		respContent, err = handler(ctx, reqContent)
3577
	}()
3578
 
3579
	if err != nil {
3580
		s.writeError(ctx, resp, err)
3581
		return
3582
	}
3583
	if respContent == nil {
3584
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ReleaseTunnelResponse and nil error while calling ReleaseTunnel. nil responses are not supported"))
3585
		return
3586
	}
3587
 
3588
	ctx = callResponsePrepared(ctx, s.hooks)
3589
 
3590
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
3591
	respBytes, err := marshaler.Marshal(respContent)
3592
	if err != nil {
3593
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
3594
		return
3595
	}
3596
 
3597
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3598
	resp.Header().Set("Content-Type", "application/json")
3599
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3600
	resp.WriteHeader(http.StatusOK)
3601
 
3602
	if n, err := resp.Write(respBytes); err != nil {
3603
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3604
		twerr := twirp.NewError(twirp.Unknown, msg)
3605
		ctx = callError(ctx, s.hooks, twerr)
3606
	}
3607
	callResponseSent(ctx, s.hooks)
3608
}
3609
 
3610
func (s *tunnelServiceServer) serveReleaseTunnelProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3611
	var err error
3612
	ctx = ctxsetters.WithMethodName(ctx, "ReleaseTunnel")
3613
	ctx, err = callRequestRouted(ctx, s.hooks)
3614
	if err != nil {
3615
		s.writeError(ctx, resp, err)
3616
		return
3617
	}
3618
 
3619
	buf, err := io.ReadAll(req.Body)
3620
	if err != nil {
3621
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
3622
		return
3623
	}
3624
	reqContent := new(ReleaseTunnelRequest)
3625
	if err = reqContent.UnmarshalVT(buf); err != nil {
3626
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
3627
		return
3628
	}
3629
 
3630
	handler := s.TunnelService.ReleaseTunnel
3631
	if s.interceptor != nil {
3632
		handler = func(ctx context.Context, req *ReleaseTunnelRequest) (*ReleaseTunnelResponse, error) {
3633
			resp, err := s.interceptor(
3634
				func(ctx context.Context, req interface{}) (interface{}, error) {
3635
					typedReq, ok := req.(*ReleaseTunnelRequest)
3636
					if !ok {
3637
						return nil, twirp.InternalError("failed type assertion req.(*ReleaseTunnelRequest) when calling interceptor")
3638
					}
3639
					return s.TunnelService.ReleaseTunnel(ctx, typedReq)
3640
				},
3641
			)(ctx, req)
3642
			if resp != nil {
3643
				typedResp, ok := resp.(*ReleaseTunnelResponse)
3644
				if !ok {
3645
					return nil, twirp.InternalError("failed type assertion resp.(*ReleaseTunnelResponse) when calling interceptor")
3646
				}
3647
				return typedResp, err
3648
			}
3649
			return nil, err
3650
		}
3651
	}
3652
 
3653
	// Call service method
3654
	var respContent *ReleaseTunnelResponse
3655
	func() {
3656
		defer ensurePanicResponses(ctx, resp, s.hooks)
3657
		respContent, err = handler(ctx, reqContent)
3658
	}()
3659
 
3660
	if err != nil {
3661
		s.writeError(ctx, resp, err)
3662
		return
3663
	}
3664
	if respContent == nil {
3665
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ReleaseTunnelResponse and nil error while calling ReleaseTunnel. nil responses are not supported"))
3666
		return
3667
	}
3668
 
3669
	ctx = callResponsePrepared(ctx, s.hooks)
3670
 
3671
	respBytes, err := respContent.MarshalVT()
3672
	if err != nil {
3673
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
3674
		return
3675
	}
3676
 
3677
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3678
	resp.Header().Set("Content-Type", "application/protobuf")
3679
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3680
	resp.WriteHeader(http.StatusOK)
3681
	if n, err := resp.Write(respBytes); err != nil {
3682
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3683
		twerr := twirp.NewError(twirp.Unknown, msg)
3684
		ctx = callError(ctx, s.hooks, twerr)
3685
	}
3686
	callResponseSent(ctx, s.hooks)
3687
}
3688
 
3689
func (s *tunnelServiceServer) serveAcmeInstruction(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3690
	header := req.Header.Get("Content-Type")
3691
	i := strings.Index(header, ";")
3692
	if i == -1 {
3693
		i = len(header)
3694
	}
3695
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
3696
	case "application/json":
3697
		s.serveAcmeInstructionJSON(ctx, resp, req)
3698
	case "application/protobuf":
3699
		s.serveAcmeInstructionProtobuf(ctx, resp, req)
3700
	default:
3701
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
3702
		twerr := badRouteError(msg, req.Method, req.URL.Path)
3703
		s.writeError(ctx, resp, twerr)
3704
	}
3705
}
3706
 
3707
func (s *tunnelServiceServer) serveAcmeInstructionJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3708
	var err error
3709
	ctx = ctxsetters.WithMethodName(ctx, "AcmeInstruction")
3710
	ctx, err = callRequestRouted(ctx, s.hooks)
3711
	if err != nil {
3712
		s.writeError(ctx, resp, err)
3713
		return
3714
	}
3715
 
3716
	d := json.NewDecoder(req.Body)
3717
	rawReqBody := json.RawMessage{}
3718
	if err := d.Decode(&rawReqBody); err != nil {
3719
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3720
		return
3721
	}
3722
	reqContent := new(InstructionRequest)
3723
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
3724
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
3725
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3726
		return
3727
	}
3728
 
3729
	handler := s.TunnelService.AcmeInstruction
3730
	if s.interceptor != nil {
3731
		handler = func(ctx context.Context, req *InstructionRequest) (*InstructionResponse, error) {
3732
			resp, err := s.interceptor(
3733
				func(ctx context.Context, req interface{}) (interface{}, error) {
3734
					typedReq, ok := req.(*InstructionRequest)
3735
					if !ok {
3736
						return nil, twirp.InternalError("failed type assertion req.(*InstructionRequest) when calling interceptor")
3737
					}
3738
					return s.TunnelService.AcmeInstruction(ctx, typedReq)
3739
				},
3740
			)(ctx, req)
3741
			if resp != nil {
3742
				typedResp, ok := resp.(*InstructionResponse)
3743
				if !ok {
3744
					return nil, twirp.InternalError("failed type assertion resp.(*InstructionResponse) when calling interceptor")
3745
				}
3746
				return typedResp, err
3747
			}
3748
			return nil, err
3749
		}
3750
	}
3751
 
3752
	// Call service method
3753
	var respContent *InstructionResponse
3754
	func() {
3755
		defer ensurePanicResponses(ctx, resp, s.hooks)
3756
		respContent, err = handler(ctx, reqContent)
3757
	}()
3758
 
3759
	if err != nil {
3760
		s.writeError(ctx, resp, err)
3761
		return
3762
	}
3763
	if respContent == nil {
3764
		s.writeError(ctx, resp, twirp.InternalError("received a nil *InstructionResponse and nil error while calling AcmeInstruction. nil responses are not supported"))
3765
		return
3766
	}
3767
 
3768
	ctx = callResponsePrepared(ctx, s.hooks)
3769
 
3770
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
3771
	respBytes, err := marshaler.Marshal(respContent)
3772
	if err != nil {
3773
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
3774
		return
3775
	}
3776
 
3777
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3778
	resp.Header().Set("Content-Type", "application/json")
3779
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3780
	resp.WriteHeader(http.StatusOK)
3781
 
3782
	if n, err := resp.Write(respBytes); err != nil {
3783
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3784
		twerr := twirp.NewError(twirp.Unknown, msg)
3785
		ctx = callError(ctx, s.hooks, twerr)
3786
	}
3787
	callResponseSent(ctx, s.hooks)
3788
}
3789
 
3790
func (s *tunnelServiceServer) serveAcmeInstructionProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3791
	var err error
3792
	ctx = ctxsetters.WithMethodName(ctx, "AcmeInstruction")
3793
	ctx, err = callRequestRouted(ctx, s.hooks)
3794
	if err != nil {
3795
		s.writeError(ctx, resp, err)
3796
		return
3797
	}
3798
 
3799
	buf, err := io.ReadAll(req.Body)
3800
	if err != nil {
3801
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
3802
		return
3803
	}
3804
	reqContent := new(InstructionRequest)
3805
	if err = reqContent.UnmarshalVT(buf); err != nil {
3806
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
3807
		return
3808
	}
3809
 
3810
	handler := s.TunnelService.AcmeInstruction
3811
	if s.interceptor != nil {
3812
		handler = func(ctx context.Context, req *InstructionRequest) (*InstructionResponse, error) {
3813
			resp, err := s.interceptor(
3814
				func(ctx context.Context, req interface{}) (interface{}, error) {
3815
					typedReq, ok := req.(*InstructionRequest)
3816
					if !ok {
3817
						return nil, twirp.InternalError("failed type assertion req.(*InstructionRequest) when calling interceptor")
3818
					}
3819
					return s.TunnelService.AcmeInstruction(ctx, typedReq)
3820
				},
3821
			)(ctx, req)
3822
			if resp != nil {
3823
				typedResp, ok := resp.(*InstructionResponse)
3824
				if !ok {
3825
					return nil, twirp.InternalError("failed type assertion resp.(*InstructionResponse) when calling interceptor")
3826
				}
3827
				return typedResp, err
3828
			}
3829
			return nil, err
3830
		}
3831
	}
3832
 
3833
	// Call service method
3834
	var respContent *InstructionResponse
3835
	func() {
3836
		defer ensurePanicResponses(ctx, resp, s.hooks)
3837
		respContent, err = handler(ctx, reqContent)
3838
	}()
3839
 
3840
	if err != nil {
3841
		s.writeError(ctx, resp, err)
3842
		return
3843
	}
3844
	if respContent == nil {
3845
		s.writeError(ctx, resp, twirp.InternalError("received a nil *InstructionResponse and nil error while calling AcmeInstruction. nil responses are not supported"))
3846
		return
3847
	}
3848
 
3849
	ctx = callResponsePrepared(ctx, s.hooks)
3850
 
3851
	respBytes, err := respContent.MarshalVT()
3852
	if err != nil {
3853
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
3854
		return
3855
	}
3856
 
3857
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3858
	resp.Header().Set("Content-Type", "application/protobuf")
3859
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3860
	resp.WriteHeader(http.StatusOK)
3861
	if n, err := resp.Write(respBytes); err != nil {
3862
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3863
		twerr := twirp.NewError(twirp.Unknown, msg)
3864
		ctx = callError(ctx, s.hooks, twerr)
3865
	}
3866
	callResponseSent(ctx, s.hooks)
3867
}
3868
 
3869
func (s *tunnelServiceServer) serveAcmeValidate(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3870
	header := req.Header.Get("Content-Type")
3871
	i := strings.Index(header, ";")
3872
	if i == -1 {
3873
		i = len(header)
3874
	}
3875
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
3876
	case "application/json":
3877
		s.serveAcmeValidateJSON(ctx, resp, req)
3878
	case "application/protobuf":
3879
		s.serveAcmeValidateProtobuf(ctx, resp, req)
3880
	default:
3881
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
3882
		twerr := badRouteError(msg, req.Method, req.URL.Path)
3883
		s.writeError(ctx, resp, twerr)
3884
	}
3885
}
3886
 
3887
func (s *tunnelServiceServer) serveAcmeValidateJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3888
	var err error
3889
	ctx = ctxsetters.WithMethodName(ctx, "AcmeValidate")
3890
	ctx, err = callRequestRouted(ctx, s.hooks)
3891
	if err != nil {
3892
		s.writeError(ctx, resp, err)
3893
		return
3894
	}
3895
 
3896
	d := json.NewDecoder(req.Body)
3897
	rawReqBody := json.RawMessage{}
3898
	if err := d.Decode(&rawReqBody); err != nil {
3899
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3900
		return
3901
	}
3902
	reqContent := new(ValidateRequest)
3903
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
3904
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
3905
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
3906
		return
3907
	}
3908
 
3909
	handler := s.TunnelService.AcmeValidate
3910
	if s.interceptor != nil {
3911
		handler = func(ctx context.Context, req *ValidateRequest) (*ValidateResponse, error) {
3912
			resp, err := s.interceptor(
3913
				func(ctx context.Context, req interface{}) (interface{}, error) {
3914
					typedReq, ok := req.(*ValidateRequest)
3915
					if !ok {
3916
						return nil, twirp.InternalError("failed type assertion req.(*ValidateRequest) when calling interceptor")
3917
					}
3918
					return s.TunnelService.AcmeValidate(ctx, typedReq)
3919
				},
3920
			)(ctx, req)
3921
			if resp != nil {
3922
				typedResp, ok := resp.(*ValidateResponse)
3923
				if !ok {
3924
					return nil, twirp.InternalError("failed type assertion resp.(*ValidateResponse) when calling interceptor")
3925
				}
3926
				return typedResp, err
3927
			}
3928
			return nil, err
3929
		}
3930
	}
3931
 
3932
	// Call service method
3933
	var respContent *ValidateResponse
3934
	func() {
3935
		defer ensurePanicResponses(ctx, resp, s.hooks)
3936
		respContent, err = handler(ctx, reqContent)
3937
	}()
3938
 
3939
	if err != nil {
3940
		s.writeError(ctx, resp, err)
3941
		return
3942
	}
3943
	if respContent == nil {
3944
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ValidateResponse and nil error while calling AcmeValidate. nil responses are not supported"))
3945
		return
3946
	}
3947
 
3948
	ctx = callResponsePrepared(ctx, s.hooks)
3949
 
3950
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
3951
	respBytes, err := marshaler.Marshal(respContent)
3952
	if err != nil {
3953
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
3954
		return
3955
	}
3956
 
3957
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
3958
	resp.Header().Set("Content-Type", "application/json")
3959
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
3960
	resp.WriteHeader(http.StatusOK)
3961
 
3962
	if n, err := resp.Write(respBytes); err != nil {
3963
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
3964
		twerr := twirp.NewError(twirp.Unknown, msg)
3965
		ctx = callError(ctx, s.hooks, twerr)
3966
	}
3967
	callResponseSent(ctx, s.hooks)
3968
}
3969
 
3970
func (s *tunnelServiceServer) serveAcmeValidateProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
3971
	var err error
3972
	ctx = ctxsetters.WithMethodName(ctx, "AcmeValidate")
3973
	ctx, err = callRequestRouted(ctx, s.hooks)
3974
	if err != nil {
3975
		s.writeError(ctx, resp, err)
3976
		return
3977
	}
3978
 
3979
	buf, err := io.ReadAll(req.Body)
3980
	if err != nil {
3981
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
3982
		return
3983
	}
3984
	reqContent := new(ValidateRequest)
3985
	if err = reqContent.UnmarshalVT(buf); err != nil {
3986
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
3987
		return
3988
	}
3989
 
3990
	handler := s.TunnelService.AcmeValidate
3991
	if s.interceptor != nil {
3992
		handler = func(ctx context.Context, req *ValidateRequest) (*ValidateResponse, error) {
3993
			resp, err := s.interceptor(
3994
				func(ctx context.Context, req interface{}) (interface{}, error) {
3995
					typedReq, ok := req.(*ValidateRequest)
3996
					if !ok {
3997
						return nil, twirp.InternalError("failed type assertion req.(*ValidateRequest) when calling interceptor")
3998
					}
3999
					return s.TunnelService.AcmeValidate(ctx, typedReq)
4000
				},
4001
			)(ctx, req)
4002
			if resp != nil {
4003
				typedResp, ok := resp.(*ValidateResponse)
4004
				if !ok {
4005
					return nil, twirp.InternalError("failed type assertion resp.(*ValidateResponse) when calling interceptor")
4006
				}
4007
				return typedResp, err
4008
			}
4009
			return nil, err
4010
		}
4011
	}
4012
 
4013
	// Call service method
4014
	var respContent *ValidateResponse
4015
	func() {
4016
		defer ensurePanicResponses(ctx, resp, s.hooks)
4017
		respContent, err = handler(ctx, reqContent)
4018
	}()
4019
 
4020
	if err != nil {
4021
		s.writeError(ctx, resp, err)
4022
		return
4023
	}
4024
	if respContent == nil {
4025
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ValidateResponse and nil error while calling AcmeValidate. nil responses are not supported"))
4026
		return
4027
	}
4028
 
4029
	ctx = callResponsePrepared(ctx, s.hooks)
4030
 
4031
	respBytes, err := respContent.MarshalVT()
4032
	if err != nil {
4033
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
4034
		return
4035
	}
4036
 
4037
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
4038
	resp.Header().Set("Content-Type", "application/protobuf")
4039
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
4040
	resp.WriteHeader(http.StatusOK)
4041
	if n, err := resp.Write(respBytes); err != nil {
4042
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
4043
		twerr := twirp.NewError(twirp.Unknown, msg)
4044
		ctx = callError(ctx, s.hooks, twerr)
4045
	}
4046
	callResponseSent(ctx, s.hooks)
4047
}
4048
 
4049
func (s *tunnelServiceServer) serveOpenEphemeralSession(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
4050
	header := req.Header.Get("Content-Type")
4051
	i := strings.Index(header, ";")
4052
	if i == -1 {
4053
		i = len(header)
4054
	}
4055
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
4056
	case "application/json":
4057
		s.serveOpenEphemeralSessionJSON(ctx, resp, req)
4058
	case "application/protobuf":
4059
		s.serveOpenEphemeralSessionProtobuf(ctx, resp, req)
4060
	default:
4061
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
4062
		twerr := badRouteError(msg, req.Method, req.URL.Path)
4063
		s.writeError(ctx, resp, twerr)
4064
	}
4065
}
4066
 
4067
func (s *tunnelServiceServer) serveOpenEphemeralSessionJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
4068
	var err error
4069
	ctx = ctxsetters.WithMethodName(ctx, "OpenEphemeralSession")
4070
	ctx, err = callRequestRouted(ctx, s.hooks)
4071
	if err != nil {
4072
		s.writeError(ctx, resp, err)
4073
		return
4074
	}
4075
 
4076
	d := json.NewDecoder(req.Body)
4077
	rawReqBody := json.RawMessage{}
4078
	if err := d.Decode(&rawReqBody); err != nil {
4079
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
4080
		return
4081
	}
4082
	reqContent := new(OpenEphemeralSessionRequest)
4083
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
4084
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
4085
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
4086
		return
4087
	}
4088
 
4089
	handler := s.TunnelService.OpenEphemeralSession
4090
	if s.interceptor != nil {
4091
		handler = func(ctx context.Context, req *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
4092
			resp, err := s.interceptor(
4093
				func(ctx context.Context, req interface{}) (interface{}, error) {
4094
					typedReq, ok := req.(*OpenEphemeralSessionRequest)
4095
					if !ok {
4096
						return nil, twirp.InternalError("failed type assertion req.(*OpenEphemeralSessionRequest) when calling interceptor")
4097
					}
4098
					return s.TunnelService.OpenEphemeralSession(ctx, typedReq)
4099
				},
4100
			)(ctx, req)
4101
			if resp != nil {
4102
				typedResp, ok := resp.(*OpenSessionResponse)
4103
				if !ok {
4104
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
4105
				}
4106
				return typedResp, err
4107
			}
4108
			return nil, err
4109
		}
4110
	}
4111
 
4112
	// Call service method
4113
	var respContent *OpenSessionResponse
4114
	func() {
4115
		defer ensurePanicResponses(ctx, resp, s.hooks)
4116
		respContent, err = handler(ctx, reqContent)
4117
	}()
4118
 
4119
	if err != nil {
4120
		s.writeError(ctx, resp, err)
4121
		return
4122
	}
4123
	if respContent == nil {
4124
		s.writeError(ctx, resp, twirp.InternalError("received a nil *OpenSessionResponse and nil error while calling OpenEphemeralSession. nil responses are not supported"))
4125
		return
4126
	}
4127
 
4128
	ctx = callResponsePrepared(ctx, s.hooks)
4129
 
4130
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
4131
	respBytes, err := marshaler.Marshal(respContent)
4132
	if err != nil {
4133
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
4134
		return
4135
	}
4136
 
4137
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
4138
	resp.Header().Set("Content-Type", "application/json")
4139
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
4140
	resp.WriteHeader(http.StatusOK)
4141
 
4142
	if n, err := resp.Write(respBytes); err != nil {
4143
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
4144
		twerr := twirp.NewError(twirp.Unknown, msg)
4145
		ctx = callError(ctx, s.hooks, twerr)
4146
	}
4147
	callResponseSent(ctx, s.hooks)
4148
}
4149
 
4150
func (s *tunnelServiceServer) serveOpenEphemeralSessionProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
4151
	var err error
4152
	ctx = ctxsetters.WithMethodName(ctx, "OpenEphemeralSession")
4153
	ctx, err = callRequestRouted(ctx, s.hooks)
4154
	if err != nil {
4155
		s.writeError(ctx, resp, err)
4156
		return
4157
	}
4158
 
4159
	buf, err := io.ReadAll(req.Body)
4160
	if err != nil {
4161
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
4162
		return
4163
	}
4164
	reqContent := new(OpenEphemeralSessionRequest)
4165
	if err = reqContent.UnmarshalVT(buf); err != nil {
4166
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
4167
		return
4168
	}
4169
 
4170
	handler := s.TunnelService.OpenEphemeralSession
4171
	if s.interceptor != nil {
4172
		handler = func(ctx context.Context, req *OpenEphemeralSessionRequest) (*OpenSessionResponse, error) {
4173
			resp, err := s.interceptor(
4174
				func(ctx context.Context, req interface{}) (interface{}, error) {
4175
					typedReq, ok := req.(*OpenEphemeralSessionRequest)
4176
					if !ok {
4177
						return nil, twirp.InternalError("failed type assertion req.(*OpenEphemeralSessionRequest) when calling interceptor")
4178
					}
4179
					return s.TunnelService.OpenEphemeralSession(ctx, typedReq)
4180
				},
4181
			)(ctx, req)
4182
			if resp != nil {
4183
				typedResp, ok := resp.(*OpenSessionResponse)
4184
				if !ok {
4185
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
4186
				}
4187
				return typedResp, err
4188
			}
4189
			return nil, err
4190
		}
4191
	}
4192
 
4193
	// Call service method
4194
	var respContent *OpenSessionResponse
4195
	func() {
4196
		defer ensurePanicResponses(ctx, resp, s.hooks)
4197
		respContent, err = handler(ctx, reqContent)
4198
	}()
4199
 
4200
	if err != nil {
4201
		s.writeError(ctx, resp, err)
4202
		return
4203
	}
4204
	if respContent == nil {
4205
		s.writeError(ctx, resp, twirp.InternalError("received a nil *OpenSessionResponse and nil error while calling OpenEphemeralSession. nil responses are not supported"))
4206
		return
4207
	}
4208
 
4209
	ctx = callResponsePrepared(ctx, s.hooks)
4210
 
4211
	respBytes, err := respContent.MarshalVT()
4212
	if err != nil {
4213
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
4214
		return
4215
	}
4216
 
4217
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
4218
	resp.Header().Set("Content-Type", "application/protobuf")
4219
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
4220
	resp.WriteHeader(http.StatusOK)
4221
	if n, err := resp.Write(respBytes); err != nil {
4222
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
4223
		twerr := twirp.NewError(twirp.Unknown, msg)
4224
		ctx = callError(ctx, s.hooks, twerr)
4225
	}
4226
	callResponseSent(ctx, s.hooks)
4227
}
4228
 
4229
func (s *tunnelServiceServer) serveOpenDelegatedSession(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
4230
	header := req.Header.Get("Content-Type")
4231
	i := strings.Index(header, ";")
4232
	if i == -1 {
4233
		i = len(header)
4234
	}
4235
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
4236
	case "application/json":
4237
		s.serveOpenDelegatedSessionJSON(ctx, resp, req)
4238
	case "application/protobuf":
4239
		s.serveOpenDelegatedSessionProtobuf(ctx, resp, req)
4240
	default:
4241
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
4242
		twerr := badRouteError(msg, req.Method, req.URL.Path)
4243
		s.writeError(ctx, resp, twerr)
4244
	}
4245
}
4246
 
4247
func (s *tunnelServiceServer) serveOpenDelegatedSessionJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
4248
	var err error
4249
	ctx = ctxsetters.WithMethodName(ctx, "OpenDelegatedSession")
4250
	ctx, err = callRequestRouted(ctx, s.hooks)
4251
	if err != nil {
4252
		s.writeError(ctx, resp, err)
4253
		return
4254
	}
4255
 
4256
	d := json.NewDecoder(req.Body)
4257
	rawReqBody := json.RawMessage{}
4258
	if err := d.Decode(&rawReqBody); err != nil {
4259
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
4260
		return
4261
	}
4262
	reqContent := new(OpenDelegatedSessionRequest)
4263
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
4264
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
4265
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
4266
		return
4267
	}
4268
 
4269
	handler := s.TunnelService.OpenDelegatedSession
4270
	if s.interceptor != nil {
4271
		handler = func(ctx context.Context, req *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
4272
			resp, err := s.interceptor(
4273
				func(ctx context.Context, req interface{}) (interface{}, error) {
4274
					typedReq, ok := req.(*OpenDelegatedSessionRequest)
4275
					if !ok {
4276
						return nil, twirp.InternalError("failed type assertion req.(*OpenDelegatedSessionRequest) when calling interceptor")
4277
					}
4278
					return s.TunnelService.OpenDelegatedSession(ctx, typedReq)
4279
				},
4280
			)(ctx, req)
4281
			if resp != nil {
4282
				typedResp, ok := resp.(*OpenSessionResponse)
4283
				if !ok {
4284
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
4285
				}
4286
				return typedResp, err
4287
			}
4288
			return nil, err
4289
		}
4290
	}
4291
 
4292
	// Call service method
4293
	var respContent *OpenSessionResponse
4294
	func() {
4295
		defer ensurePanicResponses(ctx, resp, s.hooks)
4296
		respContent, err = handler(ctx, reqContent)
4297
	}()
4298
 
4299
	if err != nil {
4300
		s.writeError(ctx, resp, err)
4301
		return
4302
	}
4303
	if respContent == nil {
4304
		s.writeError(ctx, resp, twirp.InternalError("received a nil *OpenSessionResponse and nil error while calling OpenDelegatedSession. nil responses are not supported"))
4305
		return
4306
	}
4307
 
4308
	ctx = callResponsePrepared(ctx, s.hooks)
4309
 
4310
	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
4311
	respBytes, err := marshaler.Marshal(respContent)
4312
	if err != nil {
4313
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
4314
		return
4315
	}
4316
 
4317
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
4318
	resp.Header().Set("Content-Type", "application/json")
4319
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
4320
	resp.WriteHeader(http.StatusOK)
4321
 
4322
	if n, err := resp.Write(respBytes); err != nil {
4323
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
4324
		twerr := twirp.NewError(twirp.Unknown, msg)
4325
		ctx = callError(ctx, s.hooks, twerr)
4326
	}
4327
	callResponseSent(ctx, s.hooks)
4328
}
4329
 
4330
func (s *tunnelServiceServer) serveOpenDelegatedSessionProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
4331
	var err error
4332
	ctx = ctxsetters.WithMethodName(ctx, "OpenDelegatedSession")
4333
	ctx, err = callRequestRouted(ctx, s.hooks)
4334
	if err != nil {
4335
		s.writeError(ctx, resp, err)
4336
		return
4337
	}
4338
 
4339
	buf, err := io.ReadAll(req.Body)
4340
	if err != nil {
4341
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
4342
		return
4343
	}
4344
	reqContent := new(OpenDelegatedSessionRequest)
4345
	if err = reqContent.UnmarshalVT(buf); err != nil {
4346
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
4347
		return
4348
	}
4349
 
4350
	handler := s.TunnelService.OpenDelegatedSession
4351
	if s.interceptor != nil {
4352
		handler = func(ctx context.Context, req *OpenDelegatedSessionRequest) (*OpenSessionResponse, error) {
4353
			resp, err := s.interceptor(
4354
				func(ctx context.Context, req interface{}) (interface{}, error) {
4355
					typedReq, ok := req.(*OpenDelegatedSessionRequest)
4356
					if !ok {
4357
						return nil, twirp.InternalError("failed type assertion req.(*OpenDelegatedSessionRequest) when calling interceptor")
4358
					}
4359
					return s.TunnelService.OpenDelegatedSession(ctx, typedReq)
4360
				},
4361
			)(ctx, req)
4362
			if resp != nil {
4363
				typedResp, ok := resp.(*OpenSessionResponse)
4364
				if !ok {
4365
					return nil, twirp.InternalError("failed type assertion resp.(*OpenSessionResponse) when calling interceptor")
4366
				}
4367
				return typedResp, err
4368
			}
4369
			return nil, err
4370
		}
4371
	}
4372
 
4373
	// Call service method
4374
	var respContent *OpenSessionResponse
4375
	func() {
4376
		defer ensurePanicResponses(ctx, resp, s.hooks)
4377
		respContent, err = handler(ctx, reqContent)
4378
	}()
4379
 
4380
	if err != nil {
4381
		s.writeError(ctx, resp, err)
4382
		return
4383
	}
4384
	if respContent == nil {
4385
		s.writeError(ctx, resp, twirp.InternalError("received a nil *OpenSessionResponse and nil error while calling OpenDelegatedSession. nil responses are not supported"))
4386
		return
4387
	}
4388
 
4389
	ctx = callResponsePrepared(ctx, s.hooks)
4390
 
4391
	respBytes, err := respContent.MarshalVT()
4392
	if err != nil {
4393
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
4394
		return
4395
	}
4396
 
4397
	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
4398
	resp.Header().Set("Content-Type", "application/protobuf")
4399
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
4400
	resp.WriteHeader(http.StatusOK)
4401
	if n, err := resp.Write(respBytes); err != nil {
4402
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
4403
		twerr := twirp.NewError(twirp.Unknown, msg)
4404
		ctx = callError(ctx, s.hooks, twerr)
4405
	}
4406
	callResponseSent(ctx, s.hooks)
4407
}
4408
 
4409
func (s *tunnelServiceServer) ServiceDescriptor() ([]byte, int) {
4410
	return twirpFileDescriptor5, 0
4411
}
4412
 
4413
func (s *tunnelServiceServer) ProtocGenTwirpVersion() string {
4414
	return "v8.1.3"
4415
}
4416
 
4417
// PathPrefix returns the base service path, in the form: "/<prefix>/<package>.<Service>/"
4418
// that is everything in a Twirp route except for the <Method>. This can be used for routing,
4419
// for example to identify the requests that are targeted to this service in a mux.
4420
func (s *tunnelServiceServer) PathPrefix() string {
4421
	return baseServicePath(s.pathPrefix, "protocol", "TunnelService")
4422
}
4423
 
4424
var twirpFileDescriptor5 = []byte{
4425
	// 1524 bytes of a gzipped FileDescriptorProto
4426
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xed, 0x6e, 0xdb, 0x36,
4427
	0x17, 0xae, 0x1c, 0x3b, 0xb1, 0x8f, 0x63, 0x47, 0x66, 0xbe, 0x5c, 0xb6, 0x69, 0x52, 0xbd, 0x7d,
4428
	0xdb, 0x6c, 0xdd, 0x6c, 0xc4, 0x1b, 0xb6, 0x62, 0x45, 0x81, 0x65, 0x8e, 0xd1, 0x04, 0xcd, 0x6c,
4429
	0x43, 0x71, 0xda, 0xad, 0xe8, 0x60, 0x28, 0x12, 0xeb, 0x08, 0x91, 0x45, 0x4d, 0xa2, 0xdb, 0x0e,
4430
	0xd8, 0xbf, 0x01, 0xbb, 0x80, 0xdc, 0xc2, 0x06, 0xec, 0xcf, 0xae, 0x21, 0x17, 0x33, 0xec, 0x42,
4431
	0x06, 0x89, 0x54, 0xf4, 0x61, 0xd9, 0xed, 0x80, 0xfd, 0x8a, 0xc9, 0xf3, 0x9c, 0xe7, 0x3c, 0x24,
4432
	0x0f, 0x0f, 0x4f, 0x04, 0x9b, 0x9e, 0x43, 0xf4, 0xa6, 0xe3, 0x52, 0x46, 0x9b, 0x6c, 0x62, 0xdb,
4433
	0xc4, 0x6a, 0x04, 0x03, 0x54, 0x0c, 0xfe, 0xe8, 0xd4, 0xc2, 0xeb, 0x31, 0x88, 0x4d, 0x0d, 0xc2,
4434
	0x01, 0x78, 0x2d, 0x36, 0xed, 0xd0, 0xb7, 0x62, 0x76, 0x67, 0x44, 0xe9, 0xc8, 0x22, 0x7c, 0xfe,
4435
	0x6c, 0xf2, 0xba, 0x69, 0x10, 0x4f, 0x77, 0x4d, 0x87, 0x51, 0x97, 0x23, 0x94, 0xcb, 0x1c, 0xe4,
4436
	0x8f, 0x4d, 0xfb, 0x02, 0x3d, 0x80, 0xbc, 0x66, 0x39, 0x76, 0x5d, 0xda, 0x91, 0x76, 0xab, 0xad,
4437
	0xd5, 0x46, 0x18, 0xb0, 0xe1, 0x5b, 0x1b, 0xfb, 0xc7, 0xfd, 0xae, 0x1a, 0x00, 0x10, 0x86, 0xe2,
4438
	0x39, 0xf5, 0x98, 0xad, 0x8d, 0x49, 0x3d, 0xb7, 0x23, 0xed, 0x96, 0xd4, 0xeb, 0x31, 0xda, 0x80,
4439
	0x45, 0x97, 0x8c, 0x29, 0x23, 0xf5, 0x85, 0xc0, 0x22, 0x46, 0xca, 0x9f, 0x12, 0xe4, 0x7d, 0x0a,
4440
	0x54, 0x86, 0xa5, 0xd3, 0xee, 0xb3, 0x6e, 0xef, 0x45, 0x57, 0xbe, 0x81, 0xee, 0x43, 0xe5, 0xa4,
4441
	0xdf, 0x69, 0x0f, 0x3a, 0xea, 0xb0, 0x7d, 0xd8, 0x53, 0x0f, 0x64, 0x09, 0xaf, 0x5e, 0x5e, 0xe1,
4442
	0x15, 0x7f, 0x29, 0x8c, 0xb8, 0x9f, 0xea, 0xe7, 0xd4, 0x35, 0x9a, 0x7b, 0x68, 0x17, 0xaa, 0xd7,
4443
	0xb8, 0xe3, 0xa3, 0x4e, 0x77, 0x20, 0xe7, 0xf0, 0xda, 0xe5, 0x15, 0x96, 0xaf, 0x81, 0x96, 0x49,
4444
	0x6c, 0xd6, 0xdc, 0x43, 0x35, 0x28, 0x1c, 0x0e, 0x06, 0xfd, 0x96, 0x5c, 0xc2, 0x8b, 0x97, 0x57,
4445
	0x38, 0x77, 0xde, 0x42, 0x1b, 0x90, 0xf7, 0xa7, 0x64, 0xc0, 0xcb, 0x97, 0x57, 0xb8, 0x78, 0xce,
4446
	0x98, 0xd3, 0xdc, 0x6b, 0xec, 0x21, 0x0c, 0x0b, 0x83, 0x76, 0x5f, 0x2e, 0xe3, 0xda, 0xe5, 0x15,
4447
	0xae, 0x84, 0x4c, 0x4c, 0x77, 0x9a, 0x7b, 0xca, 0x2f, 0x12, 0x54, 0xdb, 0x13, 0x8f, 0xd1, 0xf1,
4448
	0x61, 0xb8, 0xb2, 0x2f, 0x61, 0x85, 0x47, 0x19, 0x9a, 0x06, 0xb1, 0x99, 0xc9, 0x7e, 0x0a, 0x76,
4449
	0xaa, 0xdc, 0xaa, 0x46, 0x3b, 0xd5, 0xa5, 0x06, 0x51, 0xab, 0x1c, 0x76, 0x24, 0x50, 0xe8, 0x11,
4450
	0x2c, 0x0b, 0x47, 0x46, 0x2f, 0x88, 0x1d, 0x6c, 0x59, 0xb9, 0xb5, 0x1e, 0x79, 0xb5, 0x03, 0xeb,
4451
	0xc0, 0x37, 0xaa, 0x65, 0x3d, 0x1a, 0x28, 0x7f, 0x4b, 0x50, 0x1e, 0x04, 0x49, 0xa0, 0xd2, 0x09,
4452
	0x23, 0xe8, 0x09, 0x20, 0xc1, 0x64, 0x10, 0x8f, 0x99, 0xb6, 0xc6, 0x4c, 0x6a, 0xcf, 0x50, 0x51,
4453
	0xe3, 0xc8, 0x83, 0x08, 0x88, 0x1e, 0x43, 0x2d, 0xd8, 0xd0, 0x84, 0x77, 0x2e, 0xd3, 0x5b, 0x0e,
4454
	0x80, 0x71, 0xe7, 0x27, 0x80, 0x78, 0x3e, 0x26, 0xbc, 0x17, 0xb2, 0x63, 0x73, 0x64, 0xdc, 0x3d,
4455
	0x9e, 0x33, 0x90, 0xcc, 0x19, 0x45, 0x83, 0xda, 0x60, 0xca, 0xe1, 0x1e, 0x14, 0x02, 0x0d, 0x33,
4456
	0x96, 0xc7, 0x8d, 0xe8, 0x3e, 0x2c, 0xf2, 0x58, 0x33, 0xd6, 0x21, 0xac, 0xca, 0x77, 0xb0, 0xcc,
4457
	0x43, 0x9c, 0x30, 0x8d, 0x4d, 0x3c, 0xd4, 0x82, 0x45, 0x2f, 0xf8, 0x15, 0xf8, 0x55, 0x5b, 0x38,
4458
	0xf2, 0x8b, 0xe3, 0xda, 0x01, 0x07, 0x47, 0xa2, 0x35, 0x28, 0x10, 0xd7, 0xa5, 0xae, 0xc8, 0x6c,
4459
	0x3e, 0x50, 0xfe, 0x07, 0xe5, 0xd8, 0xf9, 0xf9, 0x20, 0x7e, 0xca, 0xbe, 0xec, 0x65, 0x95, 0x0f,
4460
	0x94, 0x55, 0xa8, 0x71, 0x50, 0xdf, 0xb4, 0x47, 0x2a, 0xf9, 0x71, 0x42, 0x3c, 0xa6, 0x1c, 0x03,
4461
	0x8a, 0x4f, 0x7a, 0x0e, 0xb5, 0x3d, 0x82, 0x14, 0xc8, 0xfb, 0x97, 0x7a, 0xc6, 0xb2, 0x03, 0x1b,
4462
	0x42, 0x90, 0xd7, 0x1c, 0xf2, 0x4e, 0x5c, 0xbe, 0xe0, 0xb7, 0x72, 0x13, 0x36, 0x55, 0x32, 0x32,
4463
	0x3d, 0x46, 0xdc, 0x30, 0xf3, 0xc2, 0x40, 0x0d, 0xa8, 0x4f, 0x9b, 0x44, 0xb8, 0x2c, 0xaa, 0x1a,
4464
	0xac, 0x3c, 0x25, 0xcc, 0x8f, 0xe7, 0x85, 0x14, 0x8f, 0x40, 0x8e, 0xa6, 0x84, 0xeb, 0x3d, 0x28,
4465
	0xf8, 0x6a, 0xbc, 0xba, 0xb4, 0xb3, 0x90, 0x75, 0x42, 0x81, 0xd1, 0xd7, 0xf5, 0x94, 0xd8, 0xc4,
4466
	0xd5, 0x18, 0x09, 0xaf, 0x52, 0x48, 0xfa, 0x05, 0xd4, 0xa7, 0x4d, 0x82, 0x3c, 0x9e, 0x2f, 0x52,
4467
	0x2a, 0x5f, 0x6e, 0x03, 0x0e, 0xd7, 0x43, 0x8c, 0xd0, 0xf3, 0x5a, 0xea, 0x63, 0xb8, 0x95, 0x69,
4468
	0x15, 0xc4, 0xb7, 0xa1, 0x14, 0x12, 0x71, 0xe5, 0x25, 0x35, 0x9a, 0x50, 0x5e, 0xc1, 0x5a, 0x7f,
4469
	0x72, 0x66, 0x99, 0xde, 0xb9, 0xb8, 0x77, 0x9c, 0x74, 0x9e, 0x1c, 0xb4, 0x0b, 0x4b, 0x1e, 0x71,
4470
	0xdf, 0x10, 0xd7, 0x4f, 0xa6, 0xac, 0x9d, 0x08, 0xcd, 0x4a, 0x07, 0xd6, 0x53, 0xec, 0x42, 0xd4,
4471
	0x27, 0x50, 0x72, 0xb8, 0x81, 0x18, 0x33, 0xb6, 0x33, 0x02, 0x28, 0x9f, 0xc3, 0xc6, 0xa9, 0xed,
4472
	0xfc, 0x4b, 0x99, 0xfe, 0x41, 0x4c, 0x79, 0xf1, 0xf0, 0x4a, 0x0b, 0xd6, 0x54, 0x62, 0x11, 0xcd,
4473
	0x23, 0x1f, 0x4e, 0xb7, 0x09, 0xeb, 0x29, 0x1f, 0x41, 0xf6, 0x03, 0xa0, 0x23, 0xdb, 0x63, 0xee,
4474
	0x44, 0xf7, 0xef, 0x71, 0x48, 0xf5, 0x10, 0x0a, 0x8e, 0x4b, 0xe9, 0xeb, 0xba, 0x94, 0xae, 0x7e,
4475
	0x7d, 0x7f, 0xba, 0xf7, 0xfa, 0x05, 0x75, 0x2f, 0x54, 0x8e, 0x99, 0xf7, 0xc0, 0x28, 0x6d, 0x58,
4476
	0x4d, 0xd0, 0x47, 0x79, 0x1c, 0x93, 0x19, 0xfc, 0x46, 0x75, 0x58, 0xd2, 0xa9, 0xcd, 0x88, 0xcd,
4477
	0x04, 0x4b, 0x38, 0x54, 0x5e, 0xc2, 0xca, 0x73, 0xcd, 0x32, 0x0d, 0x8d, 0x91, 0xff, 0x5c, 0xe0,
4478
	0x7d, 0x90, 0x23, 0xee, 0xd4, 0x2d, 0x93, 0x62, 0xb7, 0xec, 0x77, 0x09, 0xe4, 0x03, 0x62, 0x91,
4479
	0x91, 0xc6, 0x17, 0xa2, 0xfb, 0xf5, 0xac, 0x0e, 0x4b, 0x7e, 0xa6, 0x84, 0x65, 0xbd, 0xa2, 0x86,
4480
	0x43, 0x54, 0x85, 0x9c, 0x69, 0x88, 0x60, 0x39, 0xd3, 0xf0, 0xf5, 0xd2, 0xb7, 0x36, 0x71, 0xeb,
4481
	0x0b, 0x69, 0xbd, 0xf1, 0xe7, 0x84, 0x63, 0x12, 0x7a, 0xf3, 0xa9, 0xf4, 0xdd, 0x02, 0x20, 0xef,
4482
	0x1c, 0xd3, 0x25, 0xde, 0x50, 0x63, 0xf5, 0xc2, 0x8e, 0xb4, 0xbb, 0xa0, 0x96, 0xc4, 0xcc, 0x3e,
4483
	0x53, 0x7e, 0x86, 0x95, 0x48, 0xe5, 0x53, 0x57, 0xb3, 0x99, 0x90, 0x22, 0x5d, 0x4b, 0x99, 0xd7,
4484
	0x0f, 0x24, 0xd9, 0x17, 0x52, 0xec, 0xe8, 0x0e, 0x80, 0x69, 0xeb, 0x74, 0xec, 0x58, 0x84, 0x71,
4485
	0x69, 0x45, 0x35, 0x36, 0xa3, 0xa8, 0xb0, 0xfe, 0xad, 0x69, 0xb3, 0x48, 0xc1, 0x87, 0x5c, 0xc8,
4486
	0x64, 0xcc, 0x5c, 0x7a, 0x45, 0x43, 0xd8, 0x48, 0x73, 0x8a, 0x63, 0x6a, 0x42, 0x61, 0xe4, 0xaf,
4487
	0x50, 0xe4, 0xc0, 0xcd, 0x68, 0x4f, 0x53, 0x5b, 0xa0, 0x72, 0x5c, 0x54, 0xed, 0xf9, 0xb2, 0xf9,
4488
	0x40, 0xa9, 0xc3, 0xc6, 0xb1, 0xe9, 0xc5, 0x02, 0x78, 0x51, 0xc9, 0xdf, 0x9c, 0xb2, 0x88, 0xd8,
4489
	0x7b, 0xb0, 0x18, 0x70, 0x86, 0xe5, 0x74, 0x4e, 0x70, 0x01, 0x54, 0x3e, 0xf2, 0x4b, 0xfe, 0x1b,
4490
	0x7a, 0x41, 0xa6, 0xb7, 0x27, 0x75, 0x44, 0xca, 0x29, 0xd4, 0xa7, 0xa1, 0x22, 0x72, 0x1d, 0x96,
4491
	0xdc, 0xc0, 0xc6, 0x1d, 0x8a, 0x6a, 0x38, 0x44, 0xdb, 0x50, 0x36, 0x6d, 0x83, 0xbc, 0x1b, 0xf2,
4492
	0x77, 0x8f, 0x2f, 0x12, 0x82, 0xa9, 0x4e, 0xf0, 0xf8, 0x6d, 0xc1, 0xad, 0x9e, 0x43, 0xec, 0x8e,
4493
	0x73, 0x4e, 0xc6, 0xc4, 0xd5, 0xac, 0x13, 0xe2, 0x79, 0x91, 0x0a, 0x45, 0xe5, 0x66, 0x11, 0x93,
4494
	0x18, 0x49, 0x73, 0xf2, 0xad, 0x0c, 0x77, 0xcf, 0x3f, 0x3d, 0x97, 0x4e, 0x18, 0x19, 0x7a, 0x16,
4495
	0xe5, 0xa7, 0x57, 0x51, 0x4b, 0xc1, 0xcc, 0x89, 0x45, 0x99, 0xf2, 0x9b, 0x04, 0xab, 0x3e, 0xe9,
4496
	0x35, 0xd7, 0xfb, 0x1f, 0x8c, 0xac, 0x47, 0x0e, 0xdd, 0x84, 0x62, 0xb0, 0x8d, 0x43, 0xd3, 0x10,
4497
	0x0f, 0xfa, 0x52, 0x30, 0x3e, 0x32, 0x52, 0xf9, 0x93, 0x4f, 0xe7, 0x6c, 0xf8, 0x42, 0x17, 0x66,
4498
	0xbf, 0xd0, 0x1f, 0xb7, 0x41, 0x4e, 0xf7, 0x11, 0xa8, 0x02, 0xa5, 0x93, 0xc1, 0xfe, 0xe0, 0xf4,
4499
	0x64, 0xd8, 0x7b, 0x26, 0xdf, 0x40, 0x35, 0xa8, 0x88, 0x46, 0x78, 0xd8, 0x51, 0xd5, 0x9e, 0x2a,
4500
	0x4b, 0x3e, 0xa2, 0xdb, 0x1b, 0x1e, 0x1c, 0xa9, 0x9d, 0xf6, 0x40, 0xce, 0xb5, 0x7e, 0x05, 0xa8,
4501
	0x08, 0x16, 0xe2, 0xbe, 0x31, 0x75, 0x82, 0x4e, 0xa0, 0x9a, 0x4c, 0x5d, 0xb4, 0x1d, 0x85, 0xcf,
4502
	0xbc, 0x28, 0x78, 0x67, 0x36, 0x40, 0xec, 0xdc, 0x73, 0x58, 0x49, 0x25, 0x25, 0xda, 0x89, 0x37,
4503
	0xff, 0x59, 0x99, 0x8c, 0xef, 0xce, 0x41, 0x08, 0xde, 0xef, 0x41, 0x4e, 0xe7, 0x1c, 0x8a, 0xb9,
4504
	0xcd, 0x48, 0x5d, 0xac, 0xcc, 0x83, 0x08, 0xea, 0x7d, 0xc8, 0xfb, 0x4d, 0x13, 0xba, 0x95, 0xae,
4505
	0x7a, 0xb1, 0xfe, 0x0a, 0xdf, 0xce, 0x36, 0xc6, 0xd5, 0x25, 0x9b, 0xa2, 0xa4, 0xba, 0xcc, 0x5e,
4506
	0x0a, 0x2b, 0xf3, 0x20, 0xd7, 0xea, 0x8a, 0x61, 0xb3, 0x84, 0x62, 0xd7, 0x38, 0xd5, 0x53, 0x61,
4507
	0x9c, 0x65, 0x8a, 0xd4, 0xa5, 0x5b, 0xa3, 0xb8, 0xba, 0x19, 0x1d, 0x15, 0x56, 0xe6, 0x41, 0x04,
4508
	0xf5, 0x19, 0xac, 0x66, 0xf4, 0x47, 0xe8, 0xde, 0xf4, 0xc2, 0xa6, 0x9b, 0x2b, 0xfc, 0xff, 0xf7,
4509
	0xa0, 0x44, 0x8c, 0x3e, 0x54, 0x12, 0x8d, 0x0e, 0xba, 0x13, 0x7b, 0x4e, 0x33, 0x1a, 0x17, 0xbc,
4510
	0x3d, 0xd3, 0x1e, 0x25, 0x69, 0xaa, 0x7b, 0x89, 0x27, 0x69, 0x76, 0x3b, 0x84, 0xef, 0xce, 0x41,
4511
	0x44, 0x4a, 0x13, 0x6d, 0x4c, 0x5c, 0x69, 0x56, 0x4f, 0x84, 0xb7, 0x67, 0xda, 0x05, 0x63, 0x17,
4512
	0x56, 0xf6, 0xf5, 0x31, 0x89, 0x35, 0x29, 0x28, 0x96, 0x89, 0xd3, 0xad, 0x11, 0xde, 0x9a, 0x61,
4513
	0x15, 0x7c, 0x1d, 0x58, 0xf6, 0xf9, 0xc2, 0x9e, 0x22, 0x9e, 0x51, 0xa9, 0x1e, 0x06, 0xe3, 0x2c,
4514
	0x93, 0xa0, 0x79, 0x05, 0x6b, 0x59, 0xa5, 0x1a, 0xc5, 0x4e, 0x74, 0x4e, 0x29, 0xc7, 0x5b, 0x49,
4515
	0x58, 0xba, 0xfa, 0x0a, 0xf6, 0x74, 0xa5, 0x4f, 0xb3, 0xcf, 0x78, 0x09, 0xde, 0xc3, 0xfe, 0xd5,
4516
	0xd7, 0x50, 0xf2, 0x3f, 0x3c, 0x0c, 0xc5, 0x35, 0xe0, 0x9f, 0x34, 0x1a, 0xe1, 0x27, 0x8d, 0x46,
4517
	0xc7, 0x9e, 0x8c, 0x9f, 0x6b, 0xd6, 0x84, 0xf4, 0x9c, 0xa0, 0x02, 0xd5, 0xff, 0xfa, 0x83, 0x57,
4518
	0xf4, 0xa2, 0xef, 0xd5, 0xd5, 0xc6, 0xe4, 0x9b, 0x87, 0x87, 0xd2, 0xcb, 0x07, 0x23, 0xda, 0x18,
4519
	0x9b, 0xae, 0x36, 0x22, 0x9e, 0xa3, 0xe9, 0xa4, 0xa1, 0xd3, 0xa6, 0xf8, 0xa7, 0xbf, 0x19, 0x7d,
4520
	0x3a, 0xd1, 0xa9, 0x75, 0xb6, 0x18, 0xfc, 0xfa, 0xec, 0x9f, 0x01, 0x00, 0x05, 0x15, 0x22, 0x05,
4521
	0x8c, 0x11, 0x00, 0x00,
4522
}