1119 lines
40 KiB
Go
1119 lines
40 KiB
Go
|
// Code generated by protoc-gen-twirp v8.1.1, DO NOT EDIT.
|
||
|
|
// source: healthchecker/v1/healthchecker_v1.proto
|
||
|
|
|
||
|
|
package v1
|
||
|
|
|
||
|
|
import context "context"
|
||
|
|
import fmt "fmt"
|
||
|
|
import http "net/http"
|
||
|
|
import ioutil "io/ioutil"
|
||
|
|
import json "encoding/json"
|
||
|
|
import strconv "strconv"
|
||
|
|
import strings "strings"
|
||
|
|
|
||
|
|
import protojson "google.golang.org/protobuf/encoding/protojson"
|
||
|
|
import proto "google.golang.org/protobuf/proto"
|
||
|
|
import twirp "github.com/twitchtv/twirp"
|
||
|
|
import ctxsetters "github.com/twitchtv/twirp/ctxsetters"
|
||
|
|
|
||
|
|
import bytes "bytes"
|
||
|
|
import errors "errors"
|
||
|
|
import io "io"
|
||
|
|
import path "path"
|
||
|
|
import url "net/url"
|
||
|
|
|
||
|
|
// Version compatibility assertion.
|
||
|
|
// If the constant is not defined in the package, that likely means
|
||
|
|
// the package needs to be updated to work with this generated code.
|
||
|
|
// See https://twitchtv.github.io/twirp/docs/version_matrix.html
|
||
|
|
const _ = twirp.TwirpPackageMinVersion_8_1_0
|
||
|
|
|
||
|
|
// ======================
|
||
|
|
// CheckService Interface
|
||
|
|
// ======================
|
||
|
|
|
||
|
|
type CheckService interface {
|
||
|
|
Check(context.Context, *CheckRequest) (*CheckResponse, error)
|
||
|
|
}
|
||
|
|
|
||
|
|
// ============================
|
||
|
|
// CheckService Protobuf Client
|
||
|
|
// ============================
|
||
|
|
|
||
|
|
type checkServiceProtobufClient struct {
|
||
|
|
client HTTPClient
|
||
|
|
urls [1]string
|
||
|
|
interceptor twirp.Interceptor
|
||
|
|
opts twirp.ClientOptions
|
||
|
|
}
|
||
|
|
|
||
|
|
// NewCheckServiceProtobufClient creates a Protobuf client that implements the CheckService interface.
|
||
|
|
// It communicates using Protobuf and can be configured with a custom HTTPClient.
|
||
|
|
func NewCheckServiceProtobufClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) CheckService {
|
||
|
|
if c, ok := client.(*http.Client); ok {
|
||
|
|
client = withoutRedirects(c)
|
||
|
|
}
|
||
|
|
|
||
|
|
clientOpts := twirp.ClientOptions{}
|
||
|
|
for _, o := range opts {
|
||
|
|
o(&clientOpts)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Using ReadOpt allows backwards and forwads compatibility with new options in the future
|
||
|
|
literalURLs := false
|
||
|
|
_ = clientOpts.ReadOpt("literalURLs", &literalURLs)
|
||
|
|
var pathPrefix string
|
||
|
|
if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
|
||
|
|
pathPrefix = "/twirp" // default prefix
|
||
|
|
}
|
||
|
|
|
||
|
|
// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
|
||
|
|
serviceURL := sanitizeBaseURL(baseURL)
|
||
|
|
serviceURL += baseServicePath(pathPrefix, "healthchecker.v1", "CheckService")
|
||
|
|
urls := [1]string{
|
||
|
|
serviceURL + "Check",
|
||
|
|
}
|
||
|
|
|
||
|
|
return &checkServiceProtobufClient{
|
||
|
|
client: client,
|
||
|
|
urls: urls,
|
||
|
|
interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...),
|
||
|
|
opts: clientOpts,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func (c *checkServiceProtobufClient) Check(ctx context.Context, in *CheckRequest) (*CheckResponse, error) {
|
||
|
|
ctx = ctxsetters.WithPackageName(ctx, "healthchecker.v1")
|
||
|
|
ctx = ctxsetters.WithServiceName(ctx, "CheckService")
|
||
|
|
ctx = ctxsetters.WithMethodName(ctx, "Check")
|
||
|
|
caller := c.callCheck
|
||
|
|
if c.interceptor != nil {
|
||
|
|
caller = func(ctx context.Context, req *CheckRequest) (*CheckResponse, error) {
|
||
|
|
resp, err := c.interceptor(
|
||
|
|
func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
|
|
typedReq, ok := req.(*CheckRequest)
|
||
|
|
if !ok {
|
||
|
|
return nil, twirp.InternalError("failed type assertion req.(*CheckRequest) when calling interceptor")
|
||
|
|
}
|
||
|
|
return c.callCheck(ctx, typedReq)
|
||
|
|
},
|
||
|
|
)(ctx, req)
|
||
|
|
if resp != nil {
|
||
|
|
typedResp, ok := resp.(*CheckResponse)
|
||
|
|
if !ok {
|
||
|
|
return nil, twirp.InternalError("failed type assertion resp.(*CheckResponse) when calling interceptor")
|
||
|
|
}
|
||
|
|
return typedResp, err
|
||
|
|
}
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return caller(ctx, in)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (c *checkServiceProtobufClient) callCheck(ctx context.Context, in *CheckRequest) (*CheckResponse, error) {
|
||
|
|
out := new(CheckResponse)
|
||
|
|
ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
|
||
|
|
if err != nil {
|
||
|
|
twerr, ok := err.(twirp.Error)
|
||
|
|
if !ok {
|
||
|
|
twerr = twirp.InternalErrorWith(err)
|
||
|
|
}
|
||
|
|
callClientError(ctx, c.opts.Hooks, twerr)
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
callClientResponseReceived(ctx, c.opts.Hooks)
|
||
|
|
|
||
|
|
return out, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// ========================
|
||
|
|
// CheckService JSON Client
|
||
|
|
// ========================
|
||
|
|
|
||
|
|
type checkServiceJSONClient struct {
|
||
|
|
client HTTPClient
|
||
|
|
urls [1]string
|
||
|
|
interceptor twirp.Interceptor
|
||
|
|
opts twirp.ClientOptions
|
||
|
|
}
|
||
|
|
|
||
|
|
// NewCheckServiceJSONClient creates a JSON client that implements the CheckService interface.
|
||
|
|
// It communicates using JSON and can be configured with a custom HTTPClient.
|
||
|
|
func NewCheckServiceJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) CheckService {
|
||
|
|
if c, ok := client.(*http.Client); ok {
|
||
|
|
client = withoutRedirects(c)
|
||
|
|
}
|
||
|
|
|
||
|
|
clientOpts := twirp.ClientOptions{}
|
||
|
|
for _, o := range opts {
|
||
|
|
o(&clientOpts)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Using ReadOpt allows backwards and forwads compatibility with new options in the future
|
||
|
|
literalURLs := false
|
||
|
|
_ = clientOpts.ReadOpt("literalURLs", &literalURLs)
|
||
|
|
var pathPrefix string
|
||
|
|
if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
|
||
|
|
pathPrefix = "/twirp" // default prefix
|
||
|
|
}
|
||
|
|
|
||
|
|
// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
|
||
|
|
serviceURL := sanitizeBaseURL(baseURL)
|
||
|
|
serviceURL += baseServicePath(pathPrefix, "healthchecker.v1", "CheckService")
|
||
|
|
urls := [1]string{
|
||
|
|
serviceURL + "Check",
|
||
|
|
}
|
||
|
|
|
||
|
|
return &checkServiceJSONClient{
|
||
|
|
client: client,
|
||
|
|
urls: urls,
|
||
|
|
interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...),
|
||
|
|
opts: clientOpts,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func (c *checkServiceJSONClient) Check(ctx context.Context, in *CheckRequest) (*CheckResponse, error) {
|
||
|
|
ctx = ctxsetters.WithPackageName(ctx, "healthchecker.v1")
|
||
|
|
ctx = ctxsetters.WithServiceName(ctx, "CheckService")
|
||
|
|
ctx = ctxsetters.WithMethodName(ctx, "Check")
|
||
|
|
caller := c.callCheck
|
||
|
|
if c.interceptor != nil {
|
||
|
|
caller = func(ctx context.Context, req *CheckRequest) (*CheckResponse, error) {
|
||
|
|
resp, err := c.interceptor(
|
||
|
|
func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
|
|
typedReq, ok := req.(*CheckRequest)
|
||
|
|
if !ok {
|
||
|
|
return nil, twirp.InternalError("failed type assertion req.(*CheckRequest) when calling interceptor")
|
||
|
|
}
|
||
|
|
return c.callCheck(ctx, typedReq)
|
||
|
|
},
|
||
|
|
)(ctx, req)
|
||
|
|
if resp != nil {
|
||
|
|
typedResp, ok := resp.(*CheckResponse)
|
||
|
|
if !ok {
|
||
|
|
return nil, twirp.InternalError("failed type assertion resp.(*CheckResponse) when calling interceptor")
|
||
|
|
}
|
||
|
|
return typedResp, err
|
||
|
|
}
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return caller(ctx, in)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (c *checkServiceJSONClient) callCheck(ctx context.Context, in *CheckRequest) (*CheckResponse, error) {
|
||
|
|
out := new(CheckResponse)
|
||
|
|
ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
|
||
|
|
if err != nil {
|
||
|
|
twerr, ok := err.(twirp.Error)
|
||
|
|
if !ok {
|
||
|
|
twerr = twirp.InternalErrorWith(err)
|
||
|
|
}
|
||
|
|
callClientError(ctx, c.opts.Hooks, twerr)
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
callClientResponseReceived(ctx, c.opts.Hooks)
|
||
|
|
|
||
|
|
return out, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// ===========================
|
||
|
|
// CheckService Server Handler
|
||
|
|
// ===========================
|
||
|
|
|
||
|
|
type checkServiceServer struct {
|
||
|
|
CheckService
|
||
|
|
interceptor twirp.Interceptor
|
||
|
|
hooks *twirp.ServerHooks
|
||
|
|
pathPrefix string // prefix for routing
|
||
|
|
jsonSkipDefaults bool // do not include unpopulated fields (default values) in the response
|
||
|
|
jsonCamelCase bool // JSON fields are serialized as lowerCamelCase rather than keeping the original proto names
|
||
|
|
}
|
||
|
|
|
||
|
|
// NewCheckServiceServer builds a TwirpServer that can be used as an http.Handler to handle
|
||
|
|
// HTTP requests that are routed to the right method in the provided svc implementation.
|
||
|
|
// The opts are twirp.ServerOption modifiers, for example twirp.WithServerHooks(hooks).
|
||
|
|
func NewCheckServiceServer(svc CheckService, opts ...interface{}) TwirpServer {
|
||
|
|
serverOpts := newServerOpts(opts)
|
||
|
|
|
||
|
|
// Using ReadOpt allows backwards and forwads compatibility with new options in the future
|
||
|
|
jsonSkipDefaults := false
|
||
|
|
_ = serverOpts.ReadOpt("jsonSkipDefaults", &jsonSkipDefaults)
|
||
|
|
jsonCamelCase := false
|
||
|
|
_ = serverOpts.ReadOpt("jsonCamelCase", &jsonCamelCase)
|
||
|
|
var pathPrefix string
|
||
|
|
if ok := serverOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
|
||
|
|
pathPrefix = "/twirp" // default prefix
|
||
|
|
}
|
||
|
|
|
||
|
|
return &checkServiceServer{
|
||
|
|
CheckService: svc,
|
||
|
|
hooks: serverOpts.Hooks,
|
||
|
|
interceptor: twirp.ChainInterceptors(serverOpts.Interceptors...),
|
||
|
|
pathPrefix: pathPrefix,
|
||
|
|
jsonSkipDefaults: jsonSkipDefaults,
|
||
|
|
jsonCamelCase: jsonCamelCase,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// writeError writes an HTTP response with a valid Twirp error format, and triggers hooks.
|
||
|
|
// If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err)
|
||
|
|
func (s *checkServiceServer) writeError(ctx context.Context, resp http.ResponseWriter, err error) {
|
||
|
|
writeError(ctx, resp, err, s.hooks)
|
||
|
|
}
|
||
|
|
|
||
|
|
// handleRequestBodyError is used to handle error when the twirp server cannot read request
|
||
|
|
func (s *checkServiceServer) handleRequestBodyError(ctx context.Context, resp http.ResponseWriter, msg string, err error) {
|
||
|
|
if context.Canceled == ctx.Err() {
|
||
|
|
s.writeError(ctx, resp, twirp.NewError(twirp.Canceled, "failed to read request: context canceled"))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if context.DeadlineExceeded == ctx.Err() {
|
||
|
|
s.writeError(ctx, resp, twirp.NewError(twirp.DeadlineExceeded, "failed to read request: deadline exceeded"))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
s.writeError(ctx, resp, twirp.WrapError(malformedRequestError(msg), err))
|
||
|
|
}
|
||
|
|
|
||
|
|
// CheckServicePathPrefix is a convenience constant that may identify URL paths.
|
||
|
|
// Should be used with caution, it only matches routes generated by Twirp Go clients,
|
||
|
|
// with the default "/twirp" prefix and default CamelCase service and method names.
|
||
|
|
// More info: https://twitchtv.github.io/twirp/docs/routing.html
|
||
|
|
const CheckServicePathPrefix = "/twirp/healthchecker.v1.CheckService/"
|
||
|
|
|
||
|
|
func (s *checkServiceServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
|
||
|
|
ctx := req.Context()
|
||
|
|
ctx = ctxsetters.WithPackageName(ctx, "healthchecker.v1")
|
||
|
|
ctx = ctxsetters.WithServiceName(ctx, "CheckService")
|
||
|
|
ctx = ctxsetters.WithResponseWriter(ctx, resp)
|
||
|
|
|
||
|
|
var err error
|
||
|
|
ctx, err = callRequestReceived(ctx, s.hooks)
|
||
|
|
if err != nil {
|
||
|
|
s.writeError(ctx, resp, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
if req.Method != "POST" {
|
||
|
|
msg := fmt.Sprintf("unsupported method %q (only POST is allowed)", req.Method)
|
||
|
|
s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// Verify path format: [<prefix>]/<package>.<Service>/<Method>
|
||
|
|
prefix, pkgService, method := parseTwirpPath(req.URL.Path)
|
||
|
|
if pkgService != "healthchecker.v1.CheckService" {
|
||
|
|
msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
|
||
|
|
s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if prefix != s.pathPrefix {
|
||
|
|
msg := fmt.Sprintf("invalid path prefix %q, expected %q, on path %q", prefix, s.pathPrefix, req.URL.Path)
|
||
|
|
s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
switch method {
|
||
|
|
case "Check":
|
||
|
|
s.serveCheck(ctx, resp, req)
|
||
|
|
return
|
||
|
|
default:
|
||
|
|
msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
|
||
|
|
s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *checkServiceServer) serveCheck(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
|
||
|
|
header := req.Header.Get("Content-Type")
|
||
|
|
i := strings.Index(header, ";")
|
||
|
|
if i == -1 {
|
||
|
|
i = len(header)
|
||
|
|
}
|
||
|
|
switch strings.TrimSpace(strings.ToLower(header[:i])) {
|
||
|
|
case "application/json":
|
||
|
|
s.serveCheckJSON(ctx, resp, req)
|
||
|
|
case "application/protobuf":
|
||
|
|
s.serveCheckProtobuf(ctx, resp, req)
|
||
|
|
default:
|
||
|
|
msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
|
||
|
|
twerr := badRouteError(msg, req.Method, req.URL.Path)
|
||
|
|
s.writeError(ctx, resp, twerr)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *checkServiceServer) serveCheckJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
|
||
|
|
var err error
|
||
|
|
ctx = ctxsetters.WithMethodName(ctx, "Check")
|
||
|
|
ctx, err = callRequestRouted(ctx, s.hooks)
|
||
|
|
if err != nil {
|
||
|
|
s.writeError(ctx, resp, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
d := json.NewDecoder(req.Body)
|
||
|
|
rawReqBody := json.RawMessage{}
|
||
|
|
if err := d.Decode(&rawReqBody); err != nil {
|
||
|
|
s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
reqContent := new(CheckRequest)
|
||
|
|
unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
|
||
|
|
if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
|
||
|
|
s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
handler := s.CheckService.Check
|
||
|
|
if s.interceptor != nil {
|
||
|
|
handler = func(ctx context.Context, req *CheckRequest) (*CheckResponse, error) {
|
||
|
|
resp, err := s.interceptor(
|
||
|
|
func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
|
|
typedReq, ok := req.(*CheckRequest)
|
||
|
|
if !ok {
|
||
|
|
return nil, twirp.InternalError("failed type assertion req.(*CheckRequest) when calling interceptor")
|
||
|
|
}
|
||
|
|
return s.CheckService.Check(ctx, typedReq)
|
||
|
|
},
|
||
|
|
)(ctx, req)
|
||
|
|
if resp != nil {
|
||
|
|
typedResp, ok := resp.(*CheckResponse)
|
||
|
|
if !ok {
|
||
|
|
return nil, twirp.InternalError("failed type assertion resp.(*CheckResponse) when calling interceptor")
|
||
|
|
}
|
||
|
|
return typedResp, err
|
||
|
|
}
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Call service method
|
||
|
|
var respContent *CheckResponse
|
||
|
|
func() {
|
||
|
|
defer ensurePanicResponses(ctx, resp, s.hooks)
|
||
|
|
respContent, err = handler(ctx, reqContent)
|
||
|
|
}()
|
||
|
|
|
||
|
|
if err != nil {
|
||
|
|
s.writeError(ctx, resp, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if respContent == nil {
|
||
|
|
s.writeError(ctx, resp, twirp.InternalError("received a nil *CheckResponse and nil error while calling Check. nil responses are not supported"))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
ctx = callResponsePrepared(ctx, s.hooks)
|
||
|
|
|
||
|
|
marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
|
||
|
|
respBytes, err := marshaler.Marshal(respContent)
|
||
|
|
if err != nil {
|
||
|
|
s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
|
||
|
|
resp.Header().Set("Content-Type", "application/json")
|
||
|
|
resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
|
||
|
|
resp.WriteHeader(http.StatusOK)
|
||
|
|
|
||
|
|
if n, err := resp.Write(respBytes); err != nil {
|
||
|
|
msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
|
||
|
|
twerr := twirp.NewError(twirp.Unknown, msg)
|
||
|
|
ctx = callError(ctx, s.hooks, twerr)
|
||
|
|
}
|
||
|
|
callResponseSent(ctx, s.hooks)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *checkServiceServer) serveCheckProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
|
||
|
|
var err error
|
||
|
|
ctx = ctxsetters.WithMethodName(ctx, "Check")
|
||
|
|
ctx, err = callRequestRouted(ctx, s.hooks)
|
||
|
|
if err != nil {
|
||
|
|
s.writeError(ctx, resp, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
buf, err := ioutil.ReadAll(req.Body)
|
||
|
|
if err != nil {
|
||
|
|
s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
reqContent := new(CheckRequest)
|
||
|
|
if err = proto.Unmarshal(buf, reqContent); err != nil {
|
||
|
|
s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
handler := s.CheckService.Check
|
||
|
|
if s.interceptor != nil {
|
||
|
|
handler = func(ctx context.Context, req *CheckRequest) (*CheckResponse, error) {
|
||
|
|
resp, err := s.interceptor(
|
||
|
|
func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
|
|
typedReq, ok := req.(*CheckRequest)
|
||
|
|
if !ok {
|
||
|
|
return nil, twirp.InternalError("failed type assertion req.(*CheckRequest) when calling interceptor")
|
||
|
|
}
|
||
|
|
return s.CheckService.Check(ctx, typedReq)
|
||
|
|
},
|
||
|
|
)(ctx, req)
|
||
|
|
if resp != nil {
|
||
|
|
typedResp, ok := resp.(*CheckResponse)
|
||
|
|
if !ok {
|
||
|
|
return nil, twirp.InternalError("failed type assertion resp.(*CheckResponse) when calling interceptor")
|
||
|
|
}
|
||
|
|
return typedResp, err
|
||
|
|
}
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Call service method
|
||
|
|
var respContent *CheckResponse
|
||
|
|
func() {
|
||
|
|
defer ensurePanicResponses(ctx, resp, s.hooks)
|
||
|
|
respContent, err = handler(ctx, reqContent)
|
||
|
|
}()
|
||
|
|
|
||
|
|
if err != nil {
|
||
|
|
s.writeError(ctx, resp, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if respContent == nil {
|
||
|
|
s.writeError(ctx, resp, twirp.InternalError("received a nil *CheckResponse and nil error while calling Check. nil responses are not supported"))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
ctx = callResponsePrepared(ctx, s.hooks)
|
||
|
|
|
||
|
|
respBytes, err := proto.Marshal(respContent)
|
||
|
|
if err != nil {
|
||
|
|
s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
|
||
|
|
resp.Header().Set("Content-Type", "application/protobuf")
|
||
|
|
resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
|
||
|
|
resp.WriteHeader(http.StatusOK)
|
||
|
|
if n, err := resp.Write(respBytes); err != nil {
|
||
|
|
msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
|
||
|
|
twerr := twirp.NewError(twirp.Unknown, msg)
|
||
|
|
ctx = callError(ctx, s.hooks, twerr)
|
||
|
|
}
|
||
|
|
callResponseSent(ctx, s.hooks)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *checkServiceServer) ServiceDescriptor() ([]byte, int) {
|
||
|
|
return twirpFileDescriptor0, 0
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *checkServiceServer) ProtocGenTwirpVersion() string {
|
||
|
|
return "v8.1.1"
|
||
|
|
}
|
||
|
|
|
||
|
|
// PathPrefix returns the base service path, in the form: "/<prefix>/<package>.<Service>/"
|
||
|
|
// that is everything in a Twirp route except for the <Method>. This can be used for routing,
|
||
|
|
// for example to identify the requests that are targeted to this service in a mux.
|
||
|
|
func (s *checkServiceServer) PathPrefix() string {
|
||
|
|
return baseServicePath(s.pathPrefix, "healthchecker.v1", "CheckService")
|
||
|
|
}
|
||
|
|
|
||
|
|
// =====
|
||
|
|
// Utils
|
||
|
|
// =====
|
||
|
|
|
||
|
|
// HTTPClient is the interface used by generated clients to send HTTP requests.
|
||
|
|
// It is fulfilled by *(net/http).Client, which is sufficient for most users.
|
||
|
|
// Users can provide their own implementation for special retry policies.
|
||
|
|
//
|
||
|
|
// HTTPClient implementations should not follow redirects. Redirects are
|
||
|
|
// automatically disabled if *(net/http).Client is passed to client
|
||
|
|
// constructors. See the withoutRedirects function in this file for more
|
||
|
|
// details.
|
||
|
|
type HTTPClient interface {
|
||
|
|
Do(req *http.Request) (*http.Response, error)
|
||
|
|
}
|
||
|
|
|
||
|
|
// TwirpServer is the interface generated server structs will support: they're
|
||
|
|
// HTTP handlers with additional methods for accessing metadata about the
|
||
|
|
// service. Those accessors are a low-level API for building reflection tools.
|
||
|
|
// Most people can think of TwirpServers as just http.Handlers.
|
||
|
|
type TwirpServer interface {
|
||
|
|
http.Handler
|
||
|
|
|
||
|
|
// ServiceDescriptor returns gzipped bytes describing the .proto file that
|
||
|
|
// this service was generated from. Once unzipped, the bytes can be
|
||
|
|
// unmarshalled as a
|
||
|
|
// google.golang.org/protobuf/types/descriptorpb.FileDescriptorProto.
|
||
|
|
//
|
||
|
|
// The returned integer is the index of this particular service within that
|
||
|
|
// FileDescriptorProto's 'Service' slice of ServiceDescriptorProtos. This is a
|
||
|
|
// low-level field, expected to be used for reflection.
|
||
|
|
ServiceDescriptor() ([]byte, int)
|
||
|
|
|
||
|
|
// ProtocGenTwirpVersion is the semantic version string of the version of
|
||
|
|
// twirp used to generate this file.
|
||
|
|
ProtocGenTwirpVersion() string
|
||
|
|
|
||
|
|
// PathPrefix returns the HTTP URL path prefix for all methods handled by this
|
||
|
|
// service. This can be used with an HTTP mux to route Twirp requests.
|
||
|
|
// The path prefix is in the form: "/<prefix>/<package>.<Service>/"
|
||
|
|
// that is, everything in a Twirp route except for the <Method> at the end.
|
||
|
|
PathPrefix() string
|
||
|
|
}
|
||
|
|
|
||
|
|
func newServerOpts(opts []interface{}) *twirp.ServerOptions {
|
||
|
|
serverOpts := &twirp.ServerOptions{}
|
||
|
|
for _, opt := range opts {
|
||
|
|
switch o := opt.(type) {
|
||
|
|
case twirp.ServerOption:
|
||
|
|
o(serverOpts)
|
||
|
|
case *twirp.ServerHooks: // backwards compatibility, allow to specify hooks as an argument
|
||
|
|
twirp.WithServerHooks(o)(serverOpts)
|
||
|
|
case nil: // backwards compatibility, allow nil value for the argument
|
||
|
|
continue
|
||
|
|
default:
|
||
|
|
panic(fmt.Sprintf("Invalid option type %T, please use a twirp.ServerOption", o))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return serverOpts
|
||
|
|
}
|
||
|
|
|
||
|
|
// WriteError writes an HTTP response with a valid Twirp error format (code, msg, meta).
|
||
|
|
// Useful outside of the Twirp server (e.g. http middleware), but does not trigger hooks.
|
||
|
|
// If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err)
|
||
|
|
func WriteError(resp http.ResponseWriter, err error) {
|
||
|
|
writeError(context.Background(), resp, err, nil)
|
||
|
|
}
|
||
|
|
|
||
|
|
// writeError writes Twirp errors in the response and triggers hooks.
|
||
|
|
func writeError(ctx context.Context, resp http.ResponseWriter, err error, hooks *twirp.ServerHooks) {
|
||
|
|
// Convert to a twirp.Error. Non-twirp errors are converted to internal errors.
|
||
|
|
var twerr twirp.Error
|
||
|
|
if !errors.As(err, &twerr) {
|
||
|
|
twerr = twirp.InternalErrorWith(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
statusCode := twirp.ServerHTTPStatusFromErrorCode(twerr.Code())
|
||
|
|
ctx = ctxsetters.WithStatusCode(ctx, statusCode)
|
||
|
|
ctx = callError(ctx, hooks, twerr)
|
||
|
|
|
||
|
|
respBody := marshalErrorToJSON(twerr)
|
||
|
|
|
||
|
|
resp.Header().Set("Content-Type", "application/json") // Error responses are always JSON
|
||
|
|
resp.Header().Set("Content-Length", strconv.Itoa(len(respBody)))
|
||
|
|
resp.WriteHeader(statusCode) // set HTTP status code and send response
|
||
|
|
|
||
|
|
_, writeErr := resp.Write(respBody)
|
||
|
|
if writeErr != nil {
|
||
|
|
// We have three options here. We could log the error, call the Error
|
||
|
|
// hook, or just silently ignore the error.
|
||
|
|
//
|
||
|
|
// Logging is unacceptable because we don't have a user-controlled
|
||
|
|
// logger; writing out to stderr without permission is too rude.
|
||
|
|
//
|
||
|
|
// Calling the Error hook would confuse users: it would mean the Error
|
||
|
|
// hook got called twice for one request, which is likely to lead to
|
||
|
|
// duplicated log messages and metrics, no matter how well we document
|
||
|
|
// the behavior.
|
||
|
|
//
|
||
|
|
// Silently ignoring the error is our least-bad option. It's highly
|
||
|
|
// likely that the connection is broken and the original 'err' says
|
||
|
|
// so anyway.
|
||
|
|
_ = writeErr
|
||
|
|
}
|
||
|
|
|
||
|
|
callResponseSent(ctx, hooks)
|
||
|
|
}
|
||
|
|
|
||
|
|
// sanitizeBaseURL parses the the baseURL, and adds the "http" scheme if needed.
|
||
|
|
// If the URL is unparsable, the baseURL is returned unchaged.
|
||
|
|
func sanitizeBaseURL(baseURL string) string {
|
||
|
|
u, err := url.Parse(baseURL)
|
||
|
|
if err != nil {
|
||
|
|
return baseURL // invalid URL will fail later when making requests
|
||
|
|
}
|
||
|
|
if u.Scheme == "" {
|
||
|
|
u.Scheme = "http"
|
||
|
|
}
|
||
|
|
return u.String()
|
||
|
|
}
|
||
|
|
|
||
|
|
// baseServicePath composes the path prefix for the service (without <Method>).
|
||
|
|
// e.g.: baseServicePath("/twirp", "my.pkg", "MyService")
|
||
|
|
// returns => "/twirp/my.pkg.MyService/"
|
||
|
|
// e.g.: baseServicePath("", "", "MyService")
|
||
|
|
// returns => "/MyService/"
|
||
|
|
func baseServicePath(prefix, pkg, service string) string {
|
||
|
|
fullServiceName := service
|
||
|
|
if pkg != "" {
|
||
|
|
fullServiceName = pkg + "." + service
|
||
|
|
}
|
||
|
|
return path.Join("/", prefix, fullServiceName) + "/"
|
||
|
|
}
|
||
|
|
|
||
|
|
// parseTwirpPath extracts path components form a valid Twirp route.
|
||
|
|
// Expected format: "[<prefix>]/<package>.<Service>/<Method>"
|
||
|
|
// e.g.: prefix, pkgService, method := parseTwirpPath("/twirp/pkg.Svc/MakeHat")
|
||
|
|
func parseTwirpPath(path string) (string, string, string) {
|
||
|
|
parts := strings.Split(path, "/")
|
||
|
|
if len(parts) < 2 {
|
||
|
|
return "", "", ""
|
||
|
|
}
|
||
|
|
method := parts[len(parts)-1]
|
||
|
|
pkgService := parts[len(parts)-2]
|
||
|
|
prefix := strings.Join(parts[0:len(parts)-2], "/")
|
||
|
|
return prefix, pkgService, method
|
||
|
|
}
|
||
|
|
|
||
|
|
// getCustomHTTPReqHeaders retrieves a copy of any headers that are set in
|
||
|
|
// a context through the twirp.WithHTTPRequestHeaders function.
|
||
|
|
// If there are no headers set, or if they have the wrong type, nil is returned.
|
||
|
|
func getCustomHTTPReqHeaders(ctx context.Context) http.Header {
|
||
|
|
header, ok := twirp.HTTPRequestHeaders(ctx)
|
||
|
|
if !ok || header == nil {
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
copied := make(http.Header)
|
||
|
|
for k, vv := range header {
|
||
|
|
if vv == nil {
|
||
|
|
copied[k] = nil
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
copied[k] = make([]string, len(vv))
|
||
|
|
copy(copied[k], vv)
|
||
|
|
}
|
||
|
|
return copied
|
||
|
|
}
|
||
|
|
|
||
|
|
// newRequest makes an http.Request from a client, adding common headers.
|
||
|
|
func newRequest(ctx context.Context, url string, reqBody io.Reader, contentType string) (*http.Request, error) {
|
||
|
|
req, err := http.NewRequest("POST", url, reqBody)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
req = req.WithContext(ctx)
|
||
|
|
if customHeader := getCustomHTTPReqHeaders(ctx); customHeader != nil {
|
||
|
|
req.Header = customHeader
|
||
|
|
}
|
||
|
|
req.Header.Set("Accept", contentType)
|
||
|
|
req.Header.Set("Content-Type", contentType)
|
||
|
|
req.Header.Set("Twirp-Version", "v8.1.1")
|
||
|
|
return req, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// JSON serialization for errors
|
||
|
|
type twerrJSON struct {
|
||
|
|
Code string `json:"code"`
|
||
|
|
Msg string `json:"msg"`
|
||
|
|
Meta map[string]string `json:"meta,omitempty"`
|
||
|
|
}
|
||
|
|
|
||
|
|
// marshalErrorToJSON returns JSON from a twirp.Error, that can be used as HTTP error response body.
|
||
|
|
// If serialization fails, it will use a descriptive Internal error instead.
|
||
|
|
func marshalErrorToJSON(twerr twirp.Error) []byte {
|
||
|
|
// make sure that msg is not too large
|
||
|
|
msg := twerr.Msg()
|
||
|
|
if len(msg) > 1e6 {
|
||
|
|
msg = msg[:1e6]
|
||
|
|
}
|
||
|
|
|
||
|
|
tj := twerrJSON{
|
||
|
|
Code: string(twerr.Code()),
|
||
|
|
Msg: msg,
|
||
|
|
Meta: twerr.MetaMap(),
|
||
|
|
}
|
||
|
|
|
||
|
|
buf, err := json.Marshal(&tj)
|
||
|
|
if err != nil {
|
||
|
|
buf = []byte("{\"type\": \"" + twirp.Internal + "\", \"msg\": \"There was an error but it could not be serialized into JSON\"}") // fallback
|
||
|
|
}
|
||
|
|
|
||
|
|
return buf
|
||
|
|
}
|
||
|
|
|
||
|
|
// errorFromResponse builds a twirp.Error from a non-200 HTTP response.
|
||
|
|
// If the response has a valid serialized Twirp error, then it's returned.
|
||
|
|
// If not, the response status code is used to generate a similar twirp
|
||
|
|
// error. See twirpErrorFromIntermediary for more info on intermediary errors.
|
||
|
|
func errorFromResponse(resp *http.Response) twirp.Error {
|
||
|
|
statusCode := resp.StatusCode
|
||
|
|
statusText := http.StatusText(statusCode)
|
||
|
|
|
||
|
|
if isHTTPRedirect(statusCode) {
|
||
|
|
// Unexpected redirect: it must be an error from an intermediary.
|
||
|
|
// Twirp clients don't follow redirects automatically, Twirp only handles
|
||
|
|
// POST requests, redirects should only happen on GET and HEAD requests.
|
||
|
|
location := resp.Header.Get("Location")
|
||
|
|
msg := fmt.Sprintf("unexpected HTTP status code %d %q received, Location=%q", statusCode, statusText, location)
|
||
|
|
return twirpErrorFromIntermediary(statusCode, msg, location)
|
||
|
|
}
|
||
|
|
|
||
|
|
respBodyBytes, err := ioutil.ReadAll(resp.Body)
|
||
|
|
if err != nil {
|
||
|
|
return wrapInternal(err, "failed to read server error response body")
|
||
|
|
}
|
||
|
|
|
||
|
|
var tj twerrJSON
|
||
|
|
dec := json.NewDecoder(bytes.NewReader(respBodyBytes))
|
||
|
|
dec.DisallowUnknownFields()
|
||
|
|
if err := dec.Decode(&tj); err != nil || tj.Code == "" {
|
||
|
|
// Invalid JSON response; it must be an error from an intermediary.
|
||
|
|
msg := fmt.Sprintf("Error from intermediary with HTTP status code %d %q", statusCode, statusText)
|
||
|
|
return twirpErrorFromIntermediary(statusCode, msg, string(respBodyBytes))
|
||
|
|
}
|
||
|
|
|
||
|
|
errorCode := twirp.ErrorCode(tj.Code)
|
||
|
|
if !twirp.IsValidErrorCode(errorCode) {
|
||
|
|
msg := "invalid type returned from server error response: " + tj.Code
|
||
|
|
return twirp.InternalError(msg).WithMeta("body", string(respBodyBytes))
|
||
|
|
}
|
||
|
|
|
||
|
|
twerr := twirp.NewError(errorCode, tj.Msg)
|
||
|
|
for k, v := range tj.Meta {
|
||
|
|
twerr = twerr.WithMeta(k, v)
|
||
|
|
}
|
||
|
|
return twerr
|
||
|
|
}
|
||
|
|
|
||
|
|
// twirpErrorFromIntermediary maps HTTP errors from non-twirp sources to twirp errors.
|
||
|
|
// The mapping is similar to gRPC: https://github.com/grpc/grpc/blob/master/doc/http-grpc-status-mapping.md.
|
||
|
|
// Returned twirp Errors have some additional metadata for inspection.
|
||
|
|
func twirpErrorFromIntermediary(status int, msg string, bodyOrLocation string) twirp.Error {
|
||
|
|
var code twirp.ErrorCode
|
||
|
|
if isHTTPRedirect(status) { // 3xx
|
||
|
|
code = twirp.Internal
|
||
|
|
} else {
|
||
|
|
switch status {
|
||
|
|
case 400: // Bad Request
|
||
|
|
code = twirp.Internal
|
||
|
|
case 401: // Unauthorized
|
||
|
|
code = twirp.Unauthenticated
|
||
|
|
case 403: // Forbidden
|
||
|
|
code = twirp.PermissionDenied
|
||
|
|
case 404: // Not Found
|
||
|
|
code = twirp.BadRoute
|
||
|
|
case 429: // Too Many Requests
|
||
|
|
code = twirp.ResourceExhausted
|
||
|
|
case 502, 503, 504: // Bad Gateway, Service Unavailable, Gateway Timeout
|
||
|
|
code = twirp.Unavailable
|
||
|
|
default: // All other codes
|
||
|
|
code = twirp.Unknown
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
twerr := twirp.NewError(code, msg)
|
||
|
|
twerr = twerr.WithMeta("http_error_from_intermediary", "true") // to easily know if this error was from intermediary
|
||
|
|
twerr = twerr.WithMeta("status_code", strconv.Itoa(status))
|
||
|
|
if isHTTPRedirect(status) {
|
||
|
|
twerr = twerr.WithMeta("location", bodyOrLocation)
|
||
|
|
} else {
|
||
|
|
twerr = twerr.WithMeta("body", bodyOrLocation)
|
||
|
|
}
|
||
|
|
return twerr
|
||
|
|
}
|
||
|
|
|
||
|
|
func isHTTPRedirect(status int) bool {
|
||
|
|
return status >= 300 && status <= 399
|
||
|
|
}
|
||
|
|
|
||
|
|
// wrapInternal wraps an error with a prefix as an Internal error.
|
||
|
|
// The original error cause is accessible by github.com/pkg/errors.Cause.
|
||
|
|
func wrapInternal(err error, prefix string) twirp.Error {
|
||
|
|
return twirp.InternalErrorWith(&wrappedError{prefix: prefix, cause: err})
|
||
|
|
}
|
||
|
|
|
||
|
|
type wrappedError struct {
|
||
|
|
prefix string
|
||
|
|
cause error
|
||
|
|
}
|
||
|
|
|
||
|
|
func (e *wrappedError) Error() string { return e.prefix + ": " + e.cause.Error() }
|
||
|
|
func (e *wrappedError) Unwrap() error { return e.cause } // for go1.13 + errors.Is/As
|
||
|
|
func (e *wrappedError) Cause() error { return e.cause } // for github.com/pkg/errors
|
||
|
|
|
||
|
|
// ensurePanicResponses makes sure that rpc methods causing a panic still result in a Twirp Internal
|
||
|
|
// error response (status 500), and error hooks are properly called with the panic wrapped as an error.
|
||
|
|
// The panic is re-raised so it can be handled normally with middleware.
|
||
|
|
func ensurePanicResponses(ctx context.Context, resp http.ResponseWriter, hooks *twirp.ServerHooks) {
|
||
|
|
if r := recover(); r != nil {
|
||
|
|
// Wrap the panic as an error so it can be passed to error hooks.
|
||
|
|
// The original error is accessible from error hooks, but not visible in the response.
|
||
|
|
err := errFromPanic(r)
|
||
|
|
twerr := &internalWithCause{msg: "Internal service panic", cause: err}
|
||
|
|
// Actually write the error
|
||
|
|
writeError(ctx, resp, twerr, hooks)
|
||
|
|
// If possible, flush the error to the wire.
|
||
|
|
f, ok := resp.(http.Flusher)
|
||
|
|
if ok {
|
||
|
|
f.Flush()
|
||
|
|
}
|
||
|
|
|
||
|
|
panic(r)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// errFromPanic returns the typed error if the recovered panic is an error, otherwise formats as error.
|
||
|
|
func errFromPanic(p interface{}) error {
|
||
|
|
if err, ok := p.(error); ok {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
return fmt.Errorf("panic: %v", p)
|
||
|
|
}
|
||
|
|
|
||
|
|
// internalWithCause is a Twirp Internal error wrapping an original error cause,
|
||
|
|
// but the original error message is not exposed on Msg(). The original error
|
||
|
|
// can be checked with go1.13+ errors.Is/As, and also by (github.com/pkg/errors).Unwrap
|
||
|
|
type internalWithCause struct {
|
||
|
|
msg string
|
||
|
|
cause error
|
||
|
|
}
|
||
|
|
|
||
|
|
func (e *internalWithCause) Unwrap() error { return e.cause } // for go1.13 + errors.Is/As
|
||
|
|
func (e *internalWithCause) Cause() error { return e.cause } // for github.com/pkg/errors
|
||
|
|
func (e *internalWithCause) Error() string { return e.msg + ": " + e.cause.Error() }
|
||
|
|
func (e *internalWithCause) Code() twirp.ErrorCode { return twirp.Internal }
|
||
|
|
func (e *internalWithCause) Msg() string { return e.msg }
|
||
|
|
func (e *internalWithCause) Meta(key string) string { return "" }
|
||
|
|
func (e *internalWithCause) MetaMap() map[string]string { return nil }
|
||
|
|
func (e *internalWithCause) WithMeta(key string, val string) twirp.Error { return e }
|
||
|
|
|
||
|
|
// malformedRequestError is used when the twirp server cannot unmarshal a request
|
||
|
|
func malformedRequestError(msg string) twirp.Error {
|
||
|
|
return twirp.NewError(twirp.Malformed, msg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// badRouteError is used when the twirp server cannot route a request
|
||
|
|
func badRouteError(msg string, method, url string) twirp.Error {
|
||
|
|
err := twirp.NewError(twirp.BadRoute, msg)
|
||
|
|
err = err.WithMeta("twirp_invalid_route", method+" "+url)
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
// withoutRedirects makes sure that the POST request can not be redirected.
|
||
|
|
// The standard library will, by default, redirect requests (including POSTs) if it gets a 302 or
|
||
|
|
// 303 response, and also 301s in go1.8. It redirects by making a second request, changing the
|
||
|
|
// method to GET and removing the body. This produces very confusing error messages, so instead we
|
||
|
|
// set a redirect policy that always errors. This stops Go from executing the redirect.
|
||
|
|
//
|
||
|
|
// We have to be a little careful in case the user-provided http.Client has its own CheckRedirect
|
||
|
|
// policy - if so, we'll run through that policy first.
|
||
|
|
//
|
||
|
|
// Because this requires modifying the http.Client, we make a new copy of the client and return it.
|
||
|
|
func withoutRedirects(in *http.Client) *http.Client {
|
||
|
|
copy := *in
|
||
|
|
copy.CheckRedirect = func(req *http.Request, via []*http.Request) error {
|
||
|
|
if in.CheckRedirect != nil {
|
||
|
|
// Run the input's redirect if it exists, in case it has side effects, but ignore any error it
|
||
|
|
// returns, since we want to use ErrUseLastResponse.
|
||
|
|
err := in.CheckRedirect(req, via)
|
||
|
|
_ = err // Silly, but this makes sure generated code passes errcheck -blank, which some people use.
|
||
|
|
}
|
||
|
|
return http.ErrUseLastResponse
|
||
|
|
}
|
||
|
|
return ©
|
||
|
|
}
|
||
|
|
|
||
|
|
// doProtobufRequest makes a Protobuf request to the remote Twirp service.
|
||
|
|
func doProtobufRequest(ctx context.Context, client HTTPClient, hooks *twirp.ClientHooks, url string, in, out proto.Message) (_ context.Context, err error) {
|
||
|
|
reqBodyBytes, err := proto.Marshal(in)
|
||
|
|
if err != nil {
|
||
|
|
return ctx, wrapInternal(err, "failed to marshal proto request")
|
||
|
|
}
|
||
|
|
reqBody := bytes.NewBuffer(reqBodyBytes)
|
||
|
|
if err = ctx.Err(); err != nil {
|
||
|
|
return ctx, wrapInternal(err, "aborted because context was done")
|
||
|
|
}
|
||
|
|
|
||
|
|
req, err := newRequest(ctx, url, reqBody, "application/protobuf")
|
||
|
|
if err != nil {
|
||
|
|
return ctx, wrapInternal(err, "could not build request")
|
||
|
|
}
|
||
|
|
ctx, err = callClientRequestPrepared(ctx, hooks, req)
|
||
|
|
if err != nil {
|
||
|
|
return ctx, err
|
||
|
|
}
|
||
|
|
|
||
|
|
req = req.WithContext(ctx)
|
||
|
|
resp, err := client.Do(req)
|
||
|
|
if err != nil {
|
||
|
|
return ctx, wrapInternal(err, "failed to do request")
|
||
|
|
}
|
||
|
|
defer func() { _ = resp.Body.Close() }()
|
||
|
|
|
||
|
|
if err = ctx.Err(); err != nil {
|
||
|
|
return ctx, wrapInternal(err, "aborted because context was done")
|
||
|
|
}
|
||
|
|
|
||
|
|
if resp.StatusCode != 200 {
|
||
|
|
return ctx, errorFromResponse(resp)
|
||
|
|
}
|
||
|
|
|
||
|
|
respBodyBytes, err := ioutil.ReadAll(resp.Body)
|
||
|
|
if err != nil {
|
||
|
|
return ctx, wrapInternal(err, "failed to read response body")
|
||
|
|
}
|
||
|
|
if err = ctx.Err(); err != nil {
|
||
|
|
return ctx, wrapInternal(err, "aborted because context was done")
|
||
|
|
}
|
||
|
|
|
||
|
|
if err = proto.Unmarshal(respBodyBytes, out); err != nil {
|
||
|
|
return ctx, wrapInternal(err, "failed to unmarshal proto response")
|
||
|
|
}
|
||
|
|
return ctx, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// doJSONRequest makes a JSON request to the remote Twirp service.
|
||
|
|
func doJSONRequest(ctx context.Context, client HTTPClient, hooks *twirp.ClientHooks, url string, in, out proto.Message) (_ context.Context, err error) {
|
||
|
|
marshaler := &protojson.MarshalOptions{UseProtoNames: true}
|
||
|
|
reqBytes, err := marshaler.Marshal(in)
|
||
|
|
if err != nil {
|
||
|
|
return ctx, wrapInternal(err, "failed to marshal json request")
|
||
|
|
}
|
||
|
|
if err = ctx.Err(); err != nil {
|
||
|
|
return ctx, wrapInternal(err, "aborted because context was done")
|
||
|
|
}
|
||
|
|
|
||
|
|
req, err := newRequest(ctx, url, bytes.NewReader(reqBytes), "application/json")
|
||
|
|
if err != nil {
|
||
|
|
return ctx, wrapInternal(err, "could not build request")
|
||
|
|
}
|
||
|
|
ctx, err = callClientRequestPrepared(ctx, hooks, req)
|
||
|
|
if err != nil {
|
||
|
|
return ctx, err
|
||
|
|
}
|
||
|
|
|
||
|
|
req = req.WithContext(ctx)
|
||
|
|
resp, err := client.Do(req)
|
||
|
|
if err != nil {
|
||
|
|
return ctx, wrapInternal(err, "failed to do request")
|
||
|
|
}
|
||
|
|
|
||
|
|
defer func() {
|
||
|
|
cerr := resp.Body.Close()
|
||
|
|
if err == nil && cerr != nil {
|
||
|
|
err = wrapInternal(cerr, "failed to close response body")
|
||
|
|
}
|
||
|
|
}()
|
||
|
|
|
||
|
|
if err = ctx.Err(); err != nil {
|
||
|
|
return ctx, wrapInternal(err, "aborted because context was done")
|
||
|
|
}
|
||
|
|
|
||
|
|
if resp.StatusCode != 200 {
|
||
|
|
return ctx, errorFromResponse(resp)
|
||
|
|
}
|
||
|
|
|
||
|
|
d := json.NewDecoder(resp.Body)
|
||
|
|
rawRespBody := json.RawMessage{}
|
||
|
|
if err := d.Decode(&rawRespBody); err != nil {
|
||
|
|
return ctx, wrapInternal(err, "failed to unmarshal json response")
|
||
|
|
}
|
||
|
|
unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
|
||
|
|
if err = unmarshaler.Unmarshal(rawRespBody, out); err != nil {
|
||
|
|
return ctx, wrapInternal(err, "failed to unmarshal json response")
|
||
|
|
}
|
||
|
|
if err = ctx.Err(); err != nil {
|
||
|
|
return ctx, wrapInternal(err, "aborted because context was done")
|
||
|
|
}
|
||
|
|
return ctx, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// Call twirp.ServerHooks.RequestReceived if the hook is available
|
||
|
|
func callRequestReceived(ctx context.Context, h *twirp.ServerHooks) (context.Context, error) {
|
||
|
|
if h == nil || h.RequestReceived == nil {
|
||
|
|
return ctx, nil
|
||
|
|
}
|
||
|
|
return h.RequestReceived(ctx)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Call twirp.ServerHooks.RequestRouted if the hook is available
|
||
|
|
func callRequestRouted(ctx context.Context, h *twirp.ServerHooks) (context.Context, error) {
|
||
|
|
if h == nil || h.RequestRouted == nil {
|
||
|
|
return ctx, nil
|
||
|
|
}
|
||
|
|
return h.RequestRouted(ctx)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Call twirp.ServerHooks.ResponsePrepared if the hook is available
|
||
|
|
func callResponsePrepared(ctx context.Context, h *twirp.ServerHooks) context.Context {
|
||
|
|
if h == nil || h.ResponsePrepared == nil {
|
||
|
|
return ctx
|
||
|
|
}
|
||
|
|
return h.ResponsePrepared(ctx)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Call twirp.ServerHooks.ResponseSent if the hook is available
|
||
|
|
func callResponseSent(ctx context.Context, h *twirp.ServerHooks) {
|
||
|
|
if h == nil || h.ResponseSent == nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
h.ResponseSent(ctx)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Call twirp.ServerHooks.Error if the hook is available
|
||
|
|
func callError(ctx context.Context, h *twirp.ServerHooks, err twirp.Error) context.Context {
|
||
|
|
if h == nil || h.Error == nil {
|
||
|
|
return ctx
|
||
|
|
}
|
||
|
|
return h.Error(ctx, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
func callClientResponseReceived(ctx context.Context, h *twirp.ClientHooks) {
|
||
|
|
if h == nil || h.ResponseReceived == nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
h.ResponseReceived(ctx)
|
||
|
|
}
|
||
|
|
|
||
|
|
func callClientRequestPrepared(ctx context.Context, h *twirp.ClientHooks, req *http.Request) (context.Context, error) {
|
||
|
|
if h == nil || h.RequestPrepared == nil {
|
||
|
|
return ctx, nil
|
||
|
|
}
|
||
|
|
return h.RequestPrepared(ctx, req)
|
||
|
|
}
|
||
|
|
|
||
|
|
func callClientError(ctx context.Context, h *twirp.ClientHooks, err twirp.Error) {
|
||
|
|
if h == nil || h.Error == nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
h.Error(ctx, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
var twirpFileDescriptor0 = []byte{
|
||
|
|
// 459 bytes of a gzipped FileDescriptorProto
|
||
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x5d, 0x6f, 0xd3, 0x30,
|
||
|
|
0x14, 0x25, 0x19, 0x5d, 0xbb, 0xbb, 0x96, 0x65, 0x96, 0x80, 0xae, 0x0f, 0x6c, 0xf4, 0x85, 0x81,
|
||
|
|
0x34, 0x47, 0xed, 0x1e, 0x10, 0x4f, 0xa8, 0x5f, 0x40, 0x85, 0xd4, 0x4d, 0x4e, 0xf9, 0x10, 0x2f,
|
||
|
|
0x95, 0x93, 0xdc, 0xb5, 0xd1, 0xd2, 0x24, 0xc4, 0x6e, 0xe8, 0x1f, 0xe0, 0x77, 0xf2, 0x57, 0x50,
|
||
|
|
0xec, 0x14, 0xb5, 0x45, 0x11, 0x3c, 0xde, 0x7b, 0xcf, 0x39, 0x3e, 0xbe, 0xc7, 0x86, 0x17, 0x0b,
|
||
|
|
0xe4, 0xa1, 0x5c, 0x78, 0x0b, 0xf4, 0xee, 0x31, 0xb5, 0xb3, 0x8e, 0xbd, 0xd3, 0x98, 0x65, 0x1d,
|
||
|
|
0x9a, 0xa4, 0xb1, 0x8c, 0x89, 0xb5, 0xd3, 0xa7, 0x59, 0xa7, 0x75, 0x3e, 0x8f, 0xe3, 0x79, 0x88,
|
||
|
|
0xb6, 0x9a, 0xbb, 0xab, 0x3b, 0x5b, 0x06, 0x4b, 0x14, 0x92, 0x2f, 0x13, 0x4d, 0x69, 0xf7, 0xa0,
|
||
|
|
0x3e, 0xc8, 0xe1, 0x0c, 0xbf, 0xaf, 0x50, 0x48, 0xf2, 0x04, 0x0e, 0x7d, 0xcc, 0x70, 0x15, 0x34,
|
||
|
|
0x8d, 0x0b, 0xe3, 0xf2, 0x88, 0x15, 0x15, 0x39, 0x83, 0xda, 0x12, 0x25, 0xa6, 0xb3, 0xc0, 0x6f,
|
||
|
|
0x9a, 0x6a, 0x52, 0x55, 0xf5, 0xd8, 0x6f, 0xfb, 0x70, 0xa2, 0x24, 0x06, 0x8b, 0x20, 0x4d, 0x84,
|
||
|
|
0xe4, 0xde, 0x3d, 0x79, 0x0d, 0x47, 0x21, 0x17, 0x72, 0x26, 0x10, 0x23, 0x25, 0x74, 0xdc, 0x6d,
|
||
|
|
0x51, 0x6d, 0x85, 0x6e, 0xac, 0xd0, 0xe9, 0xc6, 0x0a, 0xab, 0xe5, 0x60, 0x07, 0x31, 0x22, 0x4d,
|
||
|
|
0xa8, 0x62, 0xc4, 0xdd, 0x10, 0xf5, 0x29, 0x35, 0xb6, 0x29, 0xdb, 0x3f, 0x0d, 0xa8, 0xaa, 0x63,
|
||
|
|
0x86, 0x7d, 0xf2, 0x06, 0x40, 0xc9, 0x67, 0x3c, 0x0c, 0xfc, 0xff, 0xd0, 0x57, 0x66, 0x3e, 0xe7,
|
||
|
|
0x60, 0xf2, 0x16, 0x1a, 0x8a, 0x1a, 0xc5, 0x91, 0x66, 0x9b, 0xff, 0x64, 0xd7, 0x73, 0xc2, 0xa4,
|
||
|
|
0xc0, 0xb7, 0x7f, 0x19, 0xd0, 0x28, 0x36, 0x26, 0x92, 0x38, 0x12, 0x48, 0x7a, 0x00, 0xde, 0x9f,
|
||
|
|
0xab, 0x17, 0x6e, 0x9e, 0xd3, 0xfd, 0x28, 0xe8, 0xde, 0x8e, 0xd8, 0x16, 0x89, 0xbc, 0x04, 0xd3,
|
||
|
|
0x77, 0x0b, 0x2b, 0x67, 0x25, 0xd4, 0x61, 0x9f, 0x99, 0xbe, 0x4b, 0xae, 0xa0, 0x22, 0x24, 0x97,
|
||
|
|
0xd8, 0x3c, 0xb8, 0x30, 0x2e, 0x1f, 0x75, 0x9f, 0xfe, 0x8d, 0x76, 0xf2, 0x31, 0xd3, 0xa8, 0xad,
|
||
|
|
0x3c, 0x1f, 0x96, 0xe6, 0x59, 0xd9, 0xc9, 0xf3, 0xd5, 0x2d, 0x54, 0x94, 0x04, 0x79, 0x0c, 0xa7,
|
||
|
|
0xce, 0xb4, 0x37, 0x1d, 0xcd, 0x3e, 0x4d, 0x9c, 0xdb, 0xd1, 0x60, 0xfc, 0x6e, 0x3c, 0x1a, 0x5a,
|
||
|
|
0x0f, 0x48, 0x1d, 0x6a, 0xba, 0x7d, 0xf3, 0xd1, 0x32, 0xc8, 0x29, 0x34, 0x74, 0xf5, 0xa5, 0xc7,
|
||
|
|
0x26, 0xe3, 0xc9, 0x7b, 0xcb, 0x24, 0x27, 0x70, 0xac, 0x5b, 0x23, 0xc6, 0x6e, 0x98, 0x75, 0xd0,
|
||
|
|
0xfd, 0x5a, 0x3c, 0x32, 0x07, 0xd3, 0x2c, 0xf0, 0x90, 0x7c, 0x80, 0x8a, 0xaa, 0xc9, 0xb3, 0x92,
|
||
|
|
0xbb, 0x16, 0xaf, 0xb1, 0x75, 0x5e, 0x3a, 0xd7, 0xbb, 0xef, 0x5f, 0x7f, 0xeb, 0xcc, 0x63, 0xba,
|
||
|
|
0x16, 0x77, 0x6b, 0xea, 0x63, 0x66, 0xcb, 0x1f, 0x41, 0x9a, 0x5c, 0xe1, 0x9a, 0x2f, 0x93, 0x10,
|
||
|
|
0x6d, 0x9e, 0x04, 0xf6, 0x3c, 0xb6, 0xf7, 0x7f, 0x8f, 0x7b, 0xa8, 0x42, 0xbe, 0xfe, 0x1d, 0x00,
|
||
|
|
0x00, 0xff, 0xff, 0xee, 0xdb, 0xb7, 0x79, 0x58, 0x03, 0x00, 0x00,
|
||
|
|
}
|