mirror of
https://github.com/aquasecurity/trivy.git
synced 2025-12-12 07:40:48 -08:00
18b80e3781
* refactor(docker_conf): rename and remove unnecessary options * feat(rpc): define new API * fix(cli): change default timeout * fix(import): fix package names * refactor(vulnerability): remove old mock * refactor(utils): remove un-needed functions * feat(cache): implement cache communicating with a server * refactor(scan): separate scan function as local scanner * test(scanner): add tests for ScanImage * refactor(scan): remove unused options * test(vulnerability): generate mock * refactor(server): split a file * feat(server): implement new RPC server * feat(client): implement new RPC client * fix(cache): use new cache interface * fix(standalone): use new scanner * fix(client): use new scanner * fix(server): pass cache * test(integration): make sure an error is not nil before calling the method * fix(mod): update dependencies * test(integration): ensure the image load finishes * feat(docker): support DOCKER_HOST and DOCKER_CERT_PATH * chore(mod): update dependencies * refactor(rpc): remove old client * feat(server): support old API for backward compatibility * fix(server): check a schema version of JSON cache * fix(rpc): add a version to packages * feat(rpc): add PutImage * test: rename expectations * refactor(cache): rename LayerCache to ImageCache * refactor: rename ImageInfo to ImageReference * fix(applier): pass image_id to ApplyLayer * feat(cache): handle image cache * chore(mod): update dependencies * refactor(server): pass only config * feat(cli): add -removed-pkgs option * refactor(err): wrap errors
1259 lines
42 KiB
Go
1259 lines
42 KiB
Go
// Code generated by protoc-gen-twirp v5.10.1, DO NOT EDIT.
|
|
// source: rpc/cache/service.proto
|
|
|
|
/*
|
|
Package cache is a generated twirp stub package.
|
|
This code was generated with github.com/twitchtv/twirp/protoc-gen-twirp v5.10.1.
|
|
|
|
It is generated from these files:
|
|
rpc/cache/service.proto
|
|
*/
|
|
package cache
|
|
|
|
import bytes "bytes"
|
|
import strings "strings"
|
|
import context "context"
|
|
import fmt "fmt"
|
|
import ioutil "io/ioutil"
|
|
import http "net/http"
|
|
import strconv "strconv"
|
|
|
|
import jsonpb "github.com/golang/protobuf/jsonpb"
|
|
import proto "github.com/golang/protobuf/proto"
|
|
import twirp "github.com/twitchtv/twirp"
|
|
import ctxsetters "github.com/twitchtv/twirp/ctxsetters"
|
|
|
|
import google_protobuf1 "github.com/golang/protobuf/ptypes/empty"
|
|
|
|
// Imports only used by utility functions:
|
|
import io "io"
|
|
import json "encoding/json"
|
|
import url "net/url"
|
|
|
|
// ===============
|
|
// Cache Interface
|
|
// ===============
|
|
|
|
type Cache interface {
|
|
PutImage(context.Context, *PutImageRequest) (*google_protobuf1.Empty, error)
|
|
|
|
PutLayer(context.Context, *PutLayerRequest) (*google_protobuf1.Empty, error)
|
|
|
|
MissingLayers(context.Context, *MissingLayersRequest) (*MissingLayersResponse, error)
|
|
}
|
|
|
|
// =====================
|
|
// Cache Protobuf Client
|
|
// =====================
|
|
|
|
type cacheProtobufClient struct {
|
|
client HTTPClient
|
|
urls [3]string
|
|
opts twirp.ClientOptions
|
|
}
|
|
|
|
// NewCacheProtobufClient creates a Protobuf client that implements the Cache interface.
|
|
// It communicates using Protobuf and can be configured with a custom HTTPClient.
|
|
func NewCacheProtobufClient(addr string, client HTTPClient, opts ...twirp.ClientOption) Cache {
|
|
if c, ok := client.(*http.Client); ok {
|
|
client = withoutRedirects(c)
|
|
}
|
|
|
|
clientOpts := twirp.ClientOptions{}
|
|
for _, o := range opts {
|
|
o(&clientOpts)
|
|
}
|
|
|
|
prefix := urlBase(addr) + CachePathPrefix
|
|
urls := [3]string{
|
|
prefix + "PutImage",
|
|
prefix + "PutLayer",
|
|
prefix + "MissingLayers",
|
|
}
|
|
|
|
return &cacheProtobufClient{
|
|
client: client,
|
|
urls: urls,
|
|
opts: clientOpts,
|
|
}
|
|
}
|
|
|
|
func (c *cacheProtobufClient) PutImage(ctx context.Context, in *PutImageRequest) (*google_protobuf1.Empty, error) {
|
|
ctx = ctxsetters.WithPackageName(ctx, "trivy.cache.v1")
|
|
ctx = ctxsetters.WithServiceName(ctx, "Cache")
|
|
ctx = ctxsetters.WithMethodName(ctx, "PutImage")
|
|
out := new(google_protobuf1.Empty)
|
|
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
|
|
}
|
|
|
|
func (c *cacheProtobufClient) PutLayer(ctx context.Context, in *PutLayerRequest) (*google_protobuf1.Empty, error) {
|
|
ctx = ctxsetters.WithPackageName(ctx, "trivy.cache.v1")
|
|
ctx = ctxsetters.WithServiceName(ctx, "Cache")
|
|
ctx = ctxsetters.WithMethodName(ctx, "PutLayer")
|
|
out := new(google_protobuf1.Empty)
|
|
err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[1], 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
|
|
}
|
|
|
|
func (c *cacheProtobufClient) MissingLayers(ctx context.Context, in *MissingLayersRequest) (*MissingLayersResponse, error) {
|
|
ctx = ctxsetters.WithPackageName(ctx, "trivy.cache.v1")
|
|
ctx = ctxsetters.WithServiceName(ctx, "Cache")
|
|
ctx = ctxsetters.WithMethodName(ctx, "MissingLayers")
|
|
out := new(MissingLayersResponse)
|
|
err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[2], 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
|
|
}
|
|
|
|
// =================
|
|
// Cache JSON Client
|
|
// =================
|
|
|
|
type cacheJSONClient struct {
|
|
client HTTPClient
|
|
urls [3]string
|
|
opts twirp.ClientOptions
|
|
}
|
|
|
|
// NewCacheJSONClient creates a JSON client that implements the Cache interface.
|
|
// It communicates using JSON and can be configured with a custom HTTPClient.
|
|
func NewCacheJSONClient(addr string, client HTTPClient, opts ...twirp.ClientOption) Cache {
|
|
if c, ok := client.(*http.Client); ok {
|
|
client = withoutRedirects(c)
|
|
}
|
|
|
|
clientOpts := twirp.ClientOptions{}
|
|
for _, o := range opts {
|
|
o(&clientOpts)
|
|
}
|
|
|
|
prefix := urlBase(addr) + CachePathPrefix
|
|
urls := [3]string{
|
|
prefix + "PutImage",
|
|
prefix + "PutLayer",
|
|
prefix + "MissingLayers",
|
|
}
|
|
|
|
return &cacheJSONClient{
|
|
client: client,
|
|
urls: urls,
|
|
opts: clientOpts,
|
|
}
|
|
}
|
|
|
|
func (c *cacheJSONClient) PutImage(ctx context.Context, in *PutImageRequest) (*google_protobuf1.Empty, error) {
|
|
ctx = ctxsetters.WithPackageName(ctx, "trivy.cache.v1")
|
|
ctx = ctxsetters.WithServiceName(ctx, "Cache")
|
|
ctx = ctxsetters.WithMethodName(ctx, "PutImage")
|
|
out := new(google_protobuf1.Empty)
|
|
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
|
|
}
|
|
|
|
func (c *cacheJSONClient) PutLayer(ctx context.Context, in *PutLayerRequest) (*google_protobuf1.Empty, error) {
|
|
ctx = ctxsetters.WithPackageName(ctx, "trivy.cache.v1")
|
|
ctx = ctxsetters.WithServiceName(ctx, "Cache")
|
|
ctx = ctxsetters.WithMethodName(ctx, "PutLayer")
|
|
out := new(google_protobuf1.Empty)
|
|
err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[1], 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
|
|
}
|
|
|
|
func (c *cacheJSONClient) MissingLayers(ctx context.Context, in *MissingLayersRequest) (*MissingLayersResponse, error) {
|
|
ctx = ctxsetters.WithPackageName(ctx, "trivy.cache.v1")
|
|
ctx = ctxsetters.WithServiceName(ctx, "Cache")
|
|
ctx = ctxsetters.WithMethodName(ctx, "MissingLayers")
|
|
out := new(MissingLayersResponse)
|
|
err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[2], 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
|
|
}
|
|
|
|
// ====================
|
|
// Cache Server Handler
|
|
// ====================
|
|
|
|
type cacheServer struct {
|
|
Cache
|
|
hooks *twirp.ServerHooks
|
|
}
|
|
|
|
func NewCacheServer(svc Cache, hooks *twirp.ServerHooks) TwirpServer {
|
|
return &cacheServer{
|
|
Cache: svc,
|
|
hooks: hooks,
|
|
}
|
|
}
|
|
|
|
// 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 *cacheServer) writeError(ctx context.Context, resp http.ResponseWriter, err error) {
|
|
writeError(ctx, resp, err, s.hooks)
|
|
}
|
|
|
|
// CachePathPrefix is used for all URL paths on a twirp Cache server.
|
|
// Requests are always: POST CachePathPrefix/method
|
|
// It can be used in an HTTP mux to route twirp requests along with non-twirp requests on other routes.
|
|
const CachePathPrefix = "/twirp/trivy.cache.v1.Cache/"
|
|
|
|
func (s *cacheServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
|
|
ctx := req.Context()
|
|
ctx = ctxsetters.WithPackageName(ctx, "trivy.cache.v1")
|
|
ctx = ctxsetters.WithServiceName(ctx, "Cache")
|
|
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)
|
|
err = badRouteError(msg, req.Method, req.URL.Path)
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
|
|
switch req.URL.Path {
|
|
case "/twirp/trivy.cache.v1.Cache/PutImage":
|
|
s.servePutImage(ctx, resp, req)
|
|
return
|
|
case "/twirp/trivy.cache.v1.Cache/PutLayer":
|
|
s.servePutLayer(ctx, resp, req)
|
|
return
|
|
case "/twirp/trivy.cache.v1.Cache/MissingLayers":
|
|
s.serveMissingLayers(ctx, resp, req)
|
|
return
|
|
default:
|
|
msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
|
|
err = badRouteError(msg, req.Method, req.URL.Path)
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
}
|
|
|
|
func (s *cacheServer) servePutImage(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.servePutImageJSON(ctx, resp, req)
|
|
case "application/protobuf":
|
|
s.servePutImageProtobuf(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 *cacheServer) servePutImageJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
|
|
var err error
|
|
ctx = ctxsetters.WithMethodName(ctx, "PutImage")
|
|
ctx, err = callRequestRouted(ctx, s.hooks)
|
|
if err != nil {
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
|
|
reqContent := new(PutImageRequest)
|
|
unmarshaler := jsonpb.Unmarshaler{AllowUnknownFields: true}
|
|
if err = unmarshaler.Unmarshal(req.Body, reqContent); err != nil {
|
|
s.writeError(ctx, resp, malformedRequestError("the json request could not be decoded"))
|
|
return
|
|
}
|
|
|
|
// Call service method
|
|
var respContent *google_protobuf1.Empty
|
|
func() {
|
|
defer ensurePanicResponses(ctx, resp, s.hooks)
|
|
respContent, err = s.Cache.PutImage(ctx, reqContent)
|
|
}()
|
|
|
|
if err != nil {
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
if respContent == nil {
|
|
s.writeError(ctx, resp, twirp.InternalError("received a nil *google_protobuf1.Empty and nil error while calling PutImage. nil responses are not supported"))
|
|
return
|
|
}
|
|
|
|
ctx = callResponsePrepared(ctx, s.hooks)
|
|
|
|
var buf bytes.Buffer
|
|
marshaler := &jsonpb.Marshaler{OrigName: true}
|
|
if err = marshaler.Marshal(&buf, respContent); err != nil {
|
|
s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
|
|
return
|
|
}
|
|
|
|
ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
|
|
respBytes := buf.Bytes()
|
|
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)
|
|
callError(ctx, s.hooks, twerr)
|
|
}
|
|
callResponseSent(ctx, s.hooks)
|
|
}
|
|
|
|
func (s *cacheServer) servePutImageProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
|
|
var err error
|
|
ctx = ctxsetters.WithMethodName(ctx, "PutImage")
|
|
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.writeError(ctx, resp, wrapInternal(err, "failed to read request body"))
|
|
return
|
|
}
|
|
reqContent := new(PutImageRequest)
|
|
if err = proto.Unmarshal(buf, reqContent); err != nil {
|
|
s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
|
|
return
|
|
}
|
|
|
|
// Call service method
|
|
var respContent *google_protobuf1.Empty
|
|
func() {
|
|
defer ensurePanicResponses(ctx, resp, s.hooks)
|
|
respContent, err = s.Cache.PutImage(ctx, reqContent)
|
|
}()
|
|
|
|
if err != nil {
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
if respContent == nil {
|
|
s.writeError(ctx, resp, twirp.InternalError("received a nil *google_protobuf1.Empty and nil error while calling PutImage. 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)
|
|
callError(ctx, s.hooks, twerr)
|
|
}
|
|
callResponseSent(ctx, s.hooks)
|
|
}
|
|
|
|
func (s *cacheServer) servePutLayer(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.servePutLayerJSON(ctx, resp, req)
|
|
case "application/protobuf":
|
|
s.servePutLayerProtobuf(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 *cacheServer) servePutLayerJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
|
|
var err error
|
|
ctx = ctxsetters.WithMethodName(ctx, "PutLayer")
|
|
ctx, err = callRequestRouted(ctx, s.hooks)
|
|
if err != nil {
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
|
|
reqContent := new(PutLayerRequest)
|
|
unmarshaler := jsonpb.Unmarshaler{AllowUnknownFields: true}
|
|
if err = unmarshaler.Unmarshal(req.Body, reqContent); err != nil {
|
|
s.writeError(ctx, resp, malformedRequestError("the json request could not be decoded"))
|
|
return
|
|
}
|
|
|
|
// Call service method
|
|
var respContent *google_protobuf1.Empty
|
|
func() {
|
|
defer ensurePanicResponses(ctx, resp, s.hooks)
|
|
respContent, err = s.Cache.PutLayer(ctx, reqContent)
|
|
}()
|
|
|
|
if err != nil {
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
if respContent == nil {
|
|
s.writeError(ctx, resp, twirp.InternalError("received a nil *google_protobuf1.Empty and nil error while calling PutLayer. nil responses are not supported"))
|
|
return
|
|
}
|
|
|
|
ctx = callResponsePrepared(ctx, s.hooks)
|
|
|
|
var buf bytes.Buffer
|
|
marshaler := &jsonpb.Marshaler{OrigName: true}
|
|
if err = marshaler.Marshal(&buf, respContent); err != nil {
|
|
s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
|
|
return
|
|
}
|
|
|
|
ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
|
|
respBytes := buf.Bytes()
|
|
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)
|
|
callError(ctx, s.hooks, twerr)
|
|
}
|
|
callResponseSent(ctx, s.hooks)
|
|
}
|
|
|
|
func (s *cacheServer) servePutLayerProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
|
|
var err error
|
|
ctx = ctxsetters.WithMethodName(ctx, "PutLayer")
|
|
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.writeError(ctx, resp, wrapInternal(err, "failed to read request body"))
|
|
return
|
|
}
|
|
reqContent := new(PutLayerRequest)
|
|
if err = proto.Unmarshal(buf, reqContent); err != nil {
|
|
s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
|
|
return
|
|
}
|
|
|
|
// Call service method
|
|
var respContent *google_protobuf1.Empty
|
|
func() {
|
|
defer ensurePanicResponses(ctx, resp, s.hooks)
|
|
respContent, err = s.Cache.PutLayer(ctx, reqContent)
|
|
}()
|
|
|
|
if err != nil {
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
if respContent == nil {
|
|
s.writeError(ctx, resp, twirp.InternalError("received a nil *google_protobuf1.Empty and nil error while calling PutLayer. 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)
|
|
callError(ctx, s.hooks, twerr)
|
|
}
|
|
callResponseSent(ctx, s.hooks)
|
|
}
|
|
|
|
func (s *cacheServer) serveMissingLayers(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.serveMissingLayersJSON(ctx, resp, req)
|
|
case "application/protobuf":
|
|
s.serveMissingLayersProtobuf(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 *cacheServer) serveMissingLayersJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
|
|
var err error
|
|
ctx = ctxsetters.WithMethodName(ctx, "MissingLayers")
|
|
ctx, err = callRequestRouted(ctx, s.hooks)
|
|
if err != nil {
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
|
|
reqContent := new(MissingLayersRequest)
|
|
unmarshaler := jsonpb.Unmarshaler{AllowUnknownFields: true}
|
|
if err = unmarshaler.Unmarshal(req.Body, reqContent); err != nil {
|
|
s.writeError(ctx, resp, malformedRequestError("the json request could not be decoded"))
|
|
return
|
|
}
|
|
|
|
// Call service method
|
|
var respContent *MissingLayersResponse
|
|
func() {
|
|
defer ensurePanicResponses(ctx, resp, s.hooks)
|
|
respContent, err = s.Cache.MissingLayers(ctx, reqContent)
|
|
}()
|
|
|
|
if err != nil {
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
if respContent == nil {
|
|
s.writeError(ctx, resp, twirp.InternalError("received a nil *MissingLayersResponse and nil error while calling MissingLayers. nil responses are not supported"))
|
|
return
|
|
}
|
|
|
|
ctx = callResponsePrepared(ctx, s.hooks)
|
|
|
|
var buf bytes.Buffer
|
|
marshaler := &jsonpb.Marshaler{OrigName: true}
|
|
if err = marshaler.Marshal(&buf, respContent); err != nil {
|
|
s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
|
|
return
|
|
}
|
|
|
|
ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
|
|
respBytes := buf.Bytes()
|
|
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)
|
|
callError(ctx, s.hooks, twerr)
|
|
}
|
|
callResponseSent(ctx, s.hooks)
|
|
}
|
|
|
|
func (s *cacheServer) serveMissingLayersProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
|
|
var err error
|
|
ctx = ctxsetters.WithMethodName(ctx, "MissingLayers")
|
|
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.writeError(ctx, resp, wrapInternal(err, "failed to read request body"))
|
|
return
|
|
}
|
|
reqContent := new(MissingLayersRequest)
|
|
if err = proto.Unmarshal(buf, reqContent); err != nil {
|
|
s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
|
|
return
|
|
}
|
|
|
|
// Call service method
|
|
var respContent *MissingLayersResponse
|
|
func() {
|
|
defer ensurePanicResponses(ctx, resp, s.hooks)
|
|
respContent, err = s.Cache.MissingLayers(ctx, reqContent)
|
|
}()
|
|
|
|
if err != nil {
|
|
s.writeError(ctx, resp, err)
|
|
return
|
|
}
|
|
if respContent == nil {
|
|
s.writeError(ctx, resp, twirp.InternalError("received a nil *MissingLayersResponse and nil error while calling MissingLayers. 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)
|
|
callError(ctx, s.hooks, twerr)
|
|
}
|
|
callResponseSent(ctx, s.hooks)
|
|
}
|
|
|
|
func (s *cacheServer) ServiceDescriptor() ([]byte, int) {
|
|
return twirpFileDescriptor0, 0
|
|
}
|
|
|
|
func (s *cacheServer) ProtocGenTwirpVersion() string {
|
|
return "v5.10.1"
|
|
}
|
|
|
|
func (s *cacheServer) PathPrefix() string {
|
|
return CachePathPrefix
|
|
}
|
|
|
|
// =====
|
|
// 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
|
|
// github.com/golang/protobuf/protoc-gen-go/descriptor.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
|
|
// alongside non-twirp requests on one HTTP listener.
|
|
PathPrefix() string
|
|
}
|
|
|
|
// 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) {
|
|
// Non-twirp errors are wrapped as Internal (default)
|
|
twerr, ok := err.(twirp.Error)
|
|
if !ok {
|
|
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)
|
|
}
|
|
|
|
// urlBase helps ensure that addr specifies a scheme. If it is unparsable
|
|
// as a URL, it returns addr unchanged.
|
|
func urlBase(addr string) string {
|
|
// If the addr specifies a scheme, use it. If not, default to
|
|
// http. If url.Parse fails on it, return it unchanged.
|
|
url, err := url.Parse(addr)
|
|
if err != nil {
|
|
return addr
|
|
}
|
|
if url.Scheme == "" {
|
|
url.Scheme = "http"
|
|
}
|
|
return url.String()
|
|
}
|
|
|
|
// 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", "v5.10.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)
|
|
}
|
|
|
|
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, 502, 503, 504: // Too Many Requests, 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) Cause() error { return e.cause }
|
|
func (e *wrappedError) Error() string { return e.prefix + ": " + e.cause.Error() }
|
|
|
|
// 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, accessible
|
|
// by github.com/pkg/errors.Cause, but the original error message is not exposed on Msg().
|
|
type internalWithCause struct {
|
|
msg string
|
|
cause error
|
|
}
|
|
|
|
func (e *internalWithCause) Cause() error { return e.cause }
|
|
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) (err error) {
|
|
reqBodyBytes, err := proto.Marshal(in)
|
|
if err != nil {
|
|
return wrapInternal(err, "failed to marshal proto request")
|
|
}
|
|
reqBody := bytes.NewBuffer(reqBodyBytes)
|
|
if err = ctx.Err(); err != nil {
|
|
return wrapInternal(err, "aborted because context was done")
|
|
}
|
|
|
|
req, err := newRequest(ctx, url, reqBody, "application/protobuf")
|
|
if err != nil {
|
|
return wrapInternal(err, "could not build request")
|
|
}
|
|
ctx, err = callClientRequestPrepared(ctx, hooks, req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
req = req.WithContext(ctx)
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return 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 wrapInternal(err, "aborted because context was done")
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
return errorFromResponse(resp)
|
|
}
|
|
|
|
respBodyBytes, err := ioutil.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return wrapInternal(err, "failed to read response body")
|
|
}
|
|
if err = ctx.Err(); err != nil {
|
|
return wrapInternal(err, "aborted because context was done")
|
|
}
|
|
|
|
if err = proto.Unmarshal(respBodyBytes, out); err != nil {
|
|
return wrapInternal(err, "failed to unmarshal proto response")
|
|
}
|
|
return 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) (err error) {
|
|
reqBody := bytes.NewBuffer(nil)
|
|
marshaler := &jsonpb.Marshaler{OrigName: true}
|
|
if err = marshaler.Marshal(reqBody, in); err != nil {
|
|
return wrapInternal(err, "failed to marshal json request")
|
|
}
|
|
if err = ctx.Err(); err != nil {
|
|
return wrapInternal(err, "aborted because context was done")
|
|
}
|
|
|
|
req, err := newRequest(ctx, url, reqBody, "application/json")
|
|
if err != nil {
|
|
return wrapInternal(err, "could not build request")
|
|
}
|
|
ctx, err = callClientRequestPrepared(ctx, hooks, req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
req = req.WithContext(ctx)
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return 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 wrapInternal(err, "aborted because context was done")
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
return errorFromResponse(resp)
|
|
}
|
|
|
|
unmarshaler := jsonpb.Unmarshaler{AllowUnknownFields: true}
|
|
if err = unmarshaler.Unmarshal(resp.Body, out); err != nil {
|
|
return wrapInternal(err, "failed to unmarshal json response")
|
|
}
|
|
if err = ctx.Err(); err != nil {
|
|
return wrapInternal(err, "aborted because context was done")
|
|
}
|
|
return 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{
|
|
// 676 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xdd, 0x6e, 0xd3, 0x4a,
|
|
0x10, 0x56, 0x92, 0xa6, 0x8d, 0x27, 0x49, 0xdb, 0xb3, 0xe7, 0xf4, 0x90, 0xa6, 0x17, 0x8d, 0x0c,
|
|
0x95, 0x22, 0x2e, 0x6c, 0x11, 0x10, 0xea, 0x0d, 0x08, 0x28, 0x20, 0x45, 0x2a, 0x50, 0x2d, 0x88,
|
|
0x0b, 0x84, 0x64, 0x6d, 0xd7, 0x9b, 0x64, 0xd5, 0xd8, 0xeb, 0xee, 0xae, 0x83, 0xf2, 0x00, 0xbc,
|
|
0x04, 0x3c, 0x24, 0xaf, 0x80, 0x3c, 0xb6, 0xd3, 0x24, 0x84, 0xbf, 0x3b, 0xcf, 0x8f, 0xbf, 0x99,
|
|
0xef, 0xfb, 0xc6, 0x86, 0x5b, 0x3a, 0xe1, 0x3e, 0x67, 0x7c, 0x22, 0x7c, 0x23, 0xf4, 0x4c, 0x72,
|
|
0xe1, 0x25, 0x5a, 0x59, 0x45, 0x76, 0xad, 0x96, 0xb3, 0xb9, 0x87, 0x25, 0x6f, 0x76, 0xaf, 0x7b,
|
|
0x3c, 0x56, 0x6a, 0x3c, 0x15, 0x3e, 0x56, 0x2f, 0xd3, 0x91, 0x6f, 0x65, 0x24, 0x8c, 0x65, 0x51,
|
|
0x92, 0xbf, 0xd0, 0x7d, 0x38, 0x96, 0x76, 0x92, 0x5e, 0x7a, 0x5c, 0x45, 0x3e, 0xbb, 0x4e, 0x99,
|
|
0x11, 0x3c, 0xd5, 0xd2, 0xce, 0x7d, 0x04, 0xf2, 0x71, 0x8e, 0x8a, 0x22, 0x15, 0xaf, 0x0e, 0xea,
|
|
0x1e, 0xad, 0x03, 0x8b, 0x28, 0xb1, 0xf3, 0xbc, 0xe8, 0x7e, 0xae, 0x82, 0x33, 0x8c, 0xd8, 0x58,
|
|
0x0c, 0xe3, 0x91, 0x22, 0x27, 0xb0, 0x6b, 0xf8, 0x44, 0x44, 0x2c, 0x98, 0x09, 0x6d, 0xa4, 0x8a,
|
|
0x3b, 0x95, 0x5e, 0xa5, 0x5f, 0xa7, 0xed, 0x3c, 0xfb, 0x3e, 0x4f, 0x12, 0x17, 0x5a, 0x4c, 0xf3,
|
|
0x89, 0xb4, 0x82, 0xdb, 0x54, 0x8b, 0x4e, 0xb5, 0x57, 0xe9, 0x3b, 0x74, 0x25, 0x47, 0x1e, 0xc0,
|
|
0x0e, 0xd7, 0x82, 0x59, 0x11, 0x76, 0x6a, 0xbd, 0x4a, 0xbf, 0x39, 0xe8, 0x7a, 0xf9, 0x1e, 0x5e,
|
|
0xb9, 0x87, 0xf7, 0xae, 0x24, 0x48, 0xcb, 0xd6, 0x6c, 0x81, 0x50, 0xf1, 0x2b, 0xa1, 0x17, 0x0b,
|
|
0x6c, 0x21, 0x76, 0x3b, 0xcf, 0x96, 0x0b, 0xec, 0x42, 0x55, 0x99, 0x4e, 0x1d, 0x4b, 0x55, 0x65,
|
|
0xc8, 0x13, 0xd8, 0x9f, 0x48, 0x63, 0x95, 0x9e, 0x07, 0x09, 0xe3, 0x57, 0x6c, 0x2c, 0x4c, 0x67,
|
|
0xbb, 0x57, 0xeb, 0x37, 0x07, 0x07, 0x5e, 0x21, 0x33, 0x2a, 0xe3, 0x5d, 0xe4, 0x55, 0xba, 0x57,
|
|
0xb4, 0x17, 0xb1, 0x71, 0x47, 0xb0, 0x77, 0x91, 0x5a, 0x54, 0x82, 0x8a, 0xeb, 0x54, 0x18, 0x4b,
|
|
0x0e, 0xa1, 0x21, 0xb3, 0x38, 0x90, 0x21, 0xca, 0xe0, 0xd0, 0x1d, 0x8c, 0x87, 0x21, 0x39, 0x05,
|
|
0x28, 0x4a, 0xf1, 0x48, 0x21, 0xfd, 0xe6, 0xe0, 0xd0, 0x5b, 0x35, 0xd4, 0x5b, 0xc8, 0x4a, 0x1d,
|
|
0x59, 0x3e, 0xba, 0x5f, 0xab, 0xe0, 0x9c, 0xb3, 0xb9, 0xd0, 0x7f, 0xa3, 0x77, 0x0f, 0xe9, 0xe6,
|
|
0x63, 0xf6, 0x57, 0x09, 0xbd, 0x79, 0x8b, 0x02, 0x3c, 0x86, 0x76, 0x41, 0x1c, 0x57, 0x32, 0x9d,
|
|
0x1a, 0xb2, 0x3f, 0xdc, 0xc8, 0x1e, 0x77, 0x6a, 0x25, 0x37, 0x81, 0x21, 0x8f, 0xa0, 0xc5, 0x92,
|
|
0x64, 0x2a, 0x39, 0xb3, 0x52, 0xc5, 0xa6, 0xb3, 0xb5, 0xe9, 0xf5, 0xa7, 0x37, 0x1d, 0x74, 0xa5,
|
|
0x9d, 0x1c, 0x43, 0x53, 0x25, 0xec, 0x3a, 0x15, 0x41, 0x28, 0x75, 0x66, 0x4c, 0xad, 0xef, 0x50,
|
|
0xc8, 0x53, 0xcf, 0xa5, 0x36, 0x19, 0xd1, 0x4f, 0xd9, 0x6d, 0xa8, 0xd4, 0x06, 0x23, 0x39, 0x2d,
|
|
0xec, 0x71, 0x68, 0xbb, 0xcc, 0xbe, 0xcc, 0x92, 0xee, 0x97, 0x0a, 0xda, 0x80, 0x02, 0x2d, 0xd9,
|
|
0x30, 0xcd, 0xe2, 0x25, 0x1b, 0x30, 0x1e, 0x86, 0x64, 0x00, 0x07, 0xa1, 0xe0, 0x2a, 0x4a, 0xb4,
|
|
0x30, 0x46, 0x84, 0xc1, 0xa2, 0x2f, 0x3f, 0xc8, 0x7f, 0x97, 0x8b, 0xe7, 0xc5, 0x3b, 0xa7, 0x00,
|
|
0x45, 0x5b, 0x66, 0x5d, 0x6d, 0xb3, 0x75, 0x0b, 0x87, 0xa8, 0x33, 0x2d, 0x1f, 0xdd, 0x33, 0x68,
|
|
0x5e, 0xa4, 0x96, 0x0a, 0x93, 0xa8, 0xd8, 0x88, 0xc2, 0x94, 0xca, 0x2f, 0x4c, 0x21, 0xb0, 0x25,
|
|
0x94, 0x99, 0xe2, 0x36, 0x0d, 0x8a, 0xcf, 0xee, 0x6b, 0xf8, 0xef, 0x95, 0x34, 0x46, 0xc6, 0x63,
|
|
0x9c, 0x61, 0xfe, 0xe0, 0xd8, 0x8e, 0xc0, 0x29, 0x89, 0x65, 0x47, 0x90, 0xc9, 0xd6, 0x28, 0x14,
|
|
0x30, 0xee, 0x04, 0x0e, 0xd6, 0xf0, 0x8a, 0xf5, 0x6e, 0x43, 0x3b, 0xca, 0x0b, 0x01, 0x02, 0x21,
|
|
0x6a, 0x83, 0xb6, 0x8a, 0x24, 0x1e, 0x27, 0xb9, 0x0b, 0xff, 0x94, 0x4d, 0xeb, 0x23, 0xf6, 0xa2,
|
|
0x25, 0xd8, 0x61, 0x68, 0x06, 0xdf, 0x2a, 0x50, 0x3f, 0xcb, 0x04, 0x22, 0x67, 0xd0, 0x28, 0xbf,
|
|
0x15, 0x72, 0xbc, 0x2e, 0xdd, 0xda, 0x57, 0xd4, 0xfd, 0xff, 0x87, 0xcf, 0xfe, 0x45, 0xf6, 0xfb,
|
|
0x29, 0x40, 0x10, 0x7d, 0x23, 0xc8, 0xf2, 0x0d, 0xfc, 0x14, 0xe4, 0x23, 0xb4, 0x57, 0xd8, 0x93,
|
|
0x3b, 0xeb, 0x48, 0x9b, 0xc4, 0xee, 0x9e, 0xfc, 0xa6, 0x2b, 0x97, 0xf0, 0xd9, 0xce, 0x87, 0x3a,
|
|
0x76, 0x5c, 0x6e, 0xe3, 0xd8, 0xfb, 0xdf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x4d, 0x84, 0x32, 0x2e,
|
|
0xcc, 0x05, 0x00, 0x00,
|
|
}
|