github.com/vcilabs/webrpc@v0.5.2-0.20201116131534-162e27b1b33b/gen/golang/templates/client.go.tmpl

{{define "client"}}
{{if .Services}}
//
// Client
//

{{range .Services}}
const {{.Name | constPathPrefix}} = "/rpc/{{.Name}}/"
{{end}}

{{range .Services}}
  {{ $serviceName := .Name | clientServiceName}}
  type {{$serviceName}} struct {
    client HTTPClient
    urls   [{{.Methods | countMethods}}]string
  }

  func {{.Name | newClientServiceName }}(addr string, client HTTPClient) {{.Name}} {
    prefix := urlBase(addr) + {{.Name | constPathPrefix}}
    urls := [{{.Methods | countMethods}}]string{
      {{- range .Methods}}
      prefix + "{{.Name}}",
      {{- end}}
    }
    return &{{$serviceName}}{
      client: client,
      urls:   urls,
    }
  }

  {{range $i, $method := .Methods}}
    func (c *{{$serviceName}}) {{.Name}}({{.Inputs | methodInputs}}) ({{.Outputs | methodOutputs }}) {
      {{- $inputVar := "nil" -}}
      {{- $outputVar := "nil" -}}
      {{- if .Inputs | len}}
      {{- $inputVar = "in"}}
      in := struct {
        {{- range $i, $input := .Inputs}}
          Arg{{$i}} {{$input | methodArgType}} `json:"{{$input.Name | downcaseName}}"`
        {{- end}}          
      }{ {{.Inputs | methodArgNames}} }
      {{- end}}
      {{- if .Outputs | len}}
      {{- $outputVar = "&out"}}
      out := struct {
        {{- range $i, $output := .Outputs}}
          Ret{{$i}} {{$output | methodArgType}} `json:"{{$output.Name | downcaseName}}"`
        {{- end}}          
      }{}
    {{- end}}

      err := doJSONRequest(ctx, c.client, c.urls[{{$i}}], {{$inputVar}}, {{$outputVar}})
      return {{argsList .Outputs "out.Ret"}}{{commaIfLen .Outputs}} err
    }
  {{end}}
{{end}}

// 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.
type HTTPClient interface {
  Do(req *http.Request) (*http.Response, error)
}

// 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()
}

// 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.Header.Set("Accept", contentType)
  req.Header.Set("Content-Type", contentType)
	if headers, ok := HTTPRequestHeaders(ctx); ok {
		for k := range headers {
			for _, v := range headers[k] {
				req.Header.Add(k, v)
			}
		}
	}
  return req, nil
}

// doJSONRequest is common code to make a request to the remote service.
func doJSONRequest(ctx context.Context, client HTTPClient, url string, in, out interface{}) error {
	reqBody, err := json.Marshal(in)
	if err != nil {
		return clientError("failed to marshal json request", err)
	}
	if err = ctx.Err(); err != nil {
		return clientError("aborted because context was done", err)
	}

	req, err := newRequest(ctx, url, bytes.NewBuffer(reqBody), "application/json")
	if err != nil {
		return clientError("could not build request", err)
	}
	resp, err := client.Do(req)
	if err != nil {
		return clientError("request failed", err)
	}

	defer func() {
		cerr := resp.Body.Close()
		if err == nil && cerr != nil {
			err = clientError("failed to close response body", cerr)
		}
	}()

	if err = ctx.Err(); err != nil {
		return clientError("aborted because context was done", err)
	}

	if resp.StatusCode != 200 {
		return errorFromResponse(resp)
	}

	if out != nil {
		respBody, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			return clientError("failed to read response body", err)
		}

		err = json.Unmarshal(respBody, &out)
		if err != nil {
			return clientError("failed to unmarshal json response body", err)
		}
		if err = ctx.Err(); err != nil {
			return clientError("aborted because context was done", err)
		}
	}

	return nil
}

// errorFromResponse builds a webrpc Error from a non-200 HTTP response.
func errorFromResponse(resp *http.Response) Error {
	respBody, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return clientError("failed to read server error response body", err)
	}

	var respErr ErrorPayload
	if err := json.Unmarshal(respBody, &respErr); err != nil {
		return clientError("failed unmarshal error response", err)
	}

	errCode := ErrorCode(respErr.Code)

	if HTTPStatusFromErrorCode(errCode) == 0 {
		return ErrorInternal("invalid code returned from server error response: %s", respErr.Code)
	}

	return &rpcErr{
		code:  errCode,
		msg:   respErr.Msg,
		cause: errors.New(respErr.Cause),
	}
}

func clientError(desc string, err error) Error {
	return WrapError(ErrInternal, err, desc)
}

func WithHTTPRequestHeaders(ctx context.Context, h http.Header) (context.Context, error) {
	if _, ok := h["Accept"]; ok {
		return nil, errors.New("provided header cannot set Accept")
	}
	if _, ok := h["Content-Type"]; ok {
		return nil, errors.New("provided header cannot set Content-Type")
	}

	copied := make(http.Header, len(h))
	for k, vv := range h {
		if vv == nil {
			copied[k] = nil
			continue
		}
		copied[k] = make([]string, len(vv))
		copy(copied[k], vv)
	}

	return context.WithValue(ctx, HTTPClientRequestHeadersCtxKey, copied), nil
}

func HTTPRequestHeaders(ctx context.Context) (http.Header, bool) {
	h, ok := ctx.Value(HTTPClientRequestHeadersCtxKey).(http.Header)
	return h, ok
}
{{end}}
{{end}}