client.go.tmpl

{{define "client"}}
{{- $typeMap := .TypeMap -}}
{{- $typePrefix := .TypePrefix -}}
{{- $services := .Services -}}
{{- $opts := .Opts }}

{{- if $services -}}
//
// Client
//

{{range $services -}}
const {{.Name}}PathPrefix = "/rpc/{{.Name}}/"
{{end}}

{{- range $_, $service := $services -}}

{{- $serviceNameClient := (printf "%sClient" ($service.Name | firstLetterToLower)) }}
{{- $ServiceNameClient := (printf "%sClient" ($service.Name | firstLetterToUpper)) }}
type {{$serviceNameClient}} struct {
	client HTTPClient
	urls	 [{{len $service.Methods}}]string
}

func New{{$ServiceNameClient}}(addr string, client HTTPClient) {{$ServiceNameClient}} {
	prefix := urlBase(addr) + {{$service.Name}}PathPrefix
	urls := [{{len $service.Methods}}]string{
	{{- range $_, $method := $service.Methods}}
		prefix + "{{$method.Name}}",
	{{- end}}
	}
	return &{{$serviceNameClient}}{
		client: client,
		urls:	 urls,
	}
}

{{- range $i, $method := $service.Methods -}}

{{ if eq $method.StreamOutput false }}

func (c *{{$serviceNameClient}}) {{$method.Name}}(ctx context.Context{{range $_, $input := $method.Inputs}}, {{$input.Name}} {{template "field" dict "Name" $input.Name "Type" $input.Type "Optional" $input.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $input.Meta}}{{end}}) {{if len $method.Outputs}}({{end}}{{range $i, $output := $method.Outputs}}{{template "field" dict "Name" $output.Name "Type" $output.Type "Optional" $output.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $output.Meta}}{{if lt $i (len $method.Outputs)}}, {{end}}{{end}}error{{if len $method.Outputs}}){{end}} {
	{{- $inputVar := "nil" -}}
	{{- $outputVar := "nil" -}}
	{{- if $method.Inputs | len}}
	{{- $inputVar = "in"}}
	in := struct {
	{{- range $i, $input := $method.Inputs}}
		Arg{{$i}} {{template "field" dict "Name" $input.Name "Type" $input.Type "Optional" $input.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $input.Meta "JsonTags" true}}
	{{- end}}
	}{ {{- range $i, $input := $method.Inputs}}{{if gt $i 0}}, {{end}}{{$input.Name}}{{end}}}
	{{- end}}
	{{- if $method.Outputs | len}}
	{{- $outputVar = "&out"}}
	out := struct {
	{{- range $i, $output := $method.Outputs}}
		Ret{{$i}} {{template "field" dict "Name" $output.Name "Type" $output.Type "Optional" $output.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $output.Meta "JsonTags" true}}
	{{- end}}
	}{}
	{{- end }}

	resp, err := doHTTPRequest(ctx, c.client, c.urls[{{$i}}], {{$inputVar}}, {{$outputVar}})
	if resp != nil {
		cerr := resp.Body.Close()
		if err == nil && cerr != nil {
			err = ErrWebrpcRequestFailed.WithCausef("failed to close response body: %w", cerr)
		}
	}

	return {{range $i, $output := $method.Outputs}}out.Ret{{$i}}, {{end}}err
}

{{- else }}

func (c *{{$serviceNameClient}}) {{$method.Name}}(ctx context.Context{{range $_, $input := $method.Inputs}}, {{$input.Name}} {{template "field" dict "Name" $input.Name "Type" $input.Type "Optional" $input.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $input.Meta}}{{end}}) ({{$method.Name}}StreamReader, error) {
	{{- $inputVar := "nil" -}}
	{{- if $method.Inputs | len}}
	{{- $inputVar = "in"}}
	in := struct {
	{{- range $i, $input := $method.Inputs}}
		Arg{{$i}} {{template "field" dict "Name" $input.Name "Type" $input.Type "Optional" $input.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $input.Meta "JsonTags" true}}
	{{- end}}
	}{ {{- range $i, $input := $method.Inputs}}{{if gt $i 0}}, {{end}}{{$input.Name}}{{end}}}
	{{- end}}

	resp, err := doHTTPRequest(ctx, c.client, c.urls[{{$i}}], {{$inputVar}}, nil)
	if err != nil {
		if resp != nil {
			resp.Body.Close()
		}
		return nil, err
	}

	buf := bufio.NewReader(resp.Body)
	return &{{$method.Name | firstLetterToLower}}StreamReader{streamReader{ctx: ctx, c: resp.Body, r: buf}}, nil
}

type {{firstLetterToLower $method.Name}}StreamReader struct {
	streamReader
}

func (r *{{firstLetterToLower $method.Name}}StreamReader) Read() ({{range $i, $output := $method.Outputs}}{{template "field" dict "Name" $output.Name "Type" $output.Type "Optional" $output.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $output.Meta}}{{if lt $i (len $method.Outputs)}}{{end}}, {{end}}error) {
	{{- $outputVar := "nil" -}}
	{{- if $method.Outputs | len}}
	{{- $outputVar = "&out"}}
	out := struct {
	{{- range $i, $output := $method.Outputs}}
		Ret{{$i}} {{template "field" dict "Name" $output.Name "Type" $output.Type "Optional" $output.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $output.Meta "JsonTags" true}}
	{{- end}}
		WebRPCError *WebRPCError `json:"webrpcError"`
	}{}

	err := r.streamReader.read(&out)
	if err != nil {
		return {{range $i, $output := $method.Outputs}}out.Ret{{$i}}, {{end}}err
	}

	if out.WebRPCError != nil {
		return {{range $i, $output := $method.Outputs}}out.Ret{{$i}}, {{end}}out.WebRPCError
	}

	return {{range $i, $output := $method.Outputs}}out.Ret{{$i}}, {{end}}nil
}

{{- end -}}
{{- end -}}

{{- end }}
{{- end }}

{{- if $opts.streaming }}

type streamReader struct {
	ctx context.Context
	c   io.Closer
	r   *bufio.Reader
}

func (r *streamReader) read(v interface {}) error {
	for {
		select {
		case <-r.ctx.Done():
			r.c.Close()
			return ErrWebrpcClientDisconnected.WithCause(r.ctx.Err())
		default:
		}

		line, err := r.r.ReadBytes('\n')
		if err != nil {
			return r.handleReadError(err)
		}

		// Eat newlines (keep-alive pings).
		if len(line) == 1 && line[0] == '\n' {
			continue
		}

		if err := json.Unmarshal(line, &v); err != nil {
			return r.handleReadError(err)
		}
		return nil
	}
}

func (r *streamReader) handleReadError(err error) error {
	defer r.c.Close()
	if errors.Is(err, io.EOF) {
		return ErrWebrpcStreamFinished.WithCause(err)
	}
	if errors.Is(err, io.ErrUnexpectedEOF) {
		return ErrWebrpcStreamLost.WithCause(err)
	}
	if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded){
		return ErrWebrpcClientDisconnected.WithCause(err)
	}
	return ErrWebrpcBadResponse.WithCausef("reading stream: %w", err)
}

{{- 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.NewRequestWithContext(ctx, "POST", url, reqBody)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Accept", contentType)
	req.Header.Set("Content-Type", contentType)
	{{- if eq $opts.webrpcHeader true }}
		req.Header.Set(WebrpcHeader, WebrpcHeaderValue)
	{{- end }}
	if headers, ok := HTTPRequestHeaders(ctx); ok {
		for k := range headers {
			for _, v := range headers[k] {
				req.Header.Add(k, v)
			}
		}
	}
	return req, nil
}

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

	req, err := newRequest(ctx, url, bytes.NewBuffer(reqBody), "application/json")
	if err != nil {
		return nil, ErrWebrpcRequestFailed.WithCausef("could not build request: %w", err)
	}

	resp, err := client.Do(req)
	if err != nil {
		return nil, ErrWebrpcRequestFailed.WithCause(err)
	}

	if resp.StatusCode != 200 {
		respBody, err := io.ReadAll(resp.Body)
		if err != nil {
			return nil, ErrWebrpcBadResponse.WithCausef("failed to read server error response body: %w", err)
		}

		var rpcErr WebRPCError
		if err := json.Unmarshal(respBody, &rpcErr); err != nil {
			return nil, ErrWebrpcBadResponse.WithCausef("failed to unmarshal server error: %w", err)
		}
		if rpcErr.Cause != "" {
			rpcErr.cause = errors.New(rpcErr.Cause)
		}
		return nil, rpcErr
	}

	if out != nil {
		respBody, err := io.ReadAll(resp.Body)
		if err != nil {
			return nil, ErrWebrpcBadResponse.WithCausef("failed to read response body: %w", err)
		}

		err = json.Unmarshal(respBody, &out)
		if err != nil {
			return nil, ErrWebrpcBadResponse.WithCausef("failed to unmarshal JSON response body: %w", err)
		}
	}

	return resp, nil
}

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 -}}