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