Compare commits

..

10 Commits
v3 ... master

Author SHA1 Message Date
b224e80b80 Update workflows (#120)
All checks were successful
test / test (push) Successful in 3m10s
Co-authored-by: Aleksandr Tolstikhin <atolstikhin@mtsbank.ru>
Reviewed-on: #120
Co-authored-by: Александр Толстихин <tolstihin1996@mail.ru>
Co-committed-by: Александр Толстихин <tolstihin1996@mail.ru>
2024-12-11 00:34:13 +03:00
Nurzhan Ilyassov
916d248147 update tests 2024-03-31 20:21:25 +03:00
Nurzhan Ilyassov
bc59fcb886 fix nil nmsg in case of empty request body 2024-03-31 20:21:25 +03:00
7ea55fb466 update for latest micro
Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>
2024-03-25 21:12:26 +03:00
76a0bdd67c Merge pull request 'update for latest micro changes' (#114) from options into master
Reviewed-on: #114
2023-08-12 13:18:05 +03:00
8de525a8f8 update for latest micro changes
Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>
2023-08-12 13:17:47 +03:00
ef36082f2e Merge pull request 'fix request/response md handling' (#112) from request-respone-md into master
Reviewed-on: #112
2023-07-11 00:48:38 +03:00
21c897be47 fix request/response md handling
Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>
2023-07-11 00:47:36 +03:00
0b21dd6660 Merge pull request 'move to micro v4' (#109) from v4 into master
Reviewed-on: #109
2023-04-28 22:29:44 +03:00
18eb0d9e5c move to micro v4
Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>
2023-04-28 22:29:18 +03:00
12 changed files with 193 additions and 554 deletions

39
.gitignore vendored
View File

@ -1,39 +0,0 @@
# Develop tools
/.vscode/
/.idea/
.idea
.vscode
# Binaries for programs and plugins
*.exe
*.exe~
*.dll
*.so
*.dylib
# Folders
_obj
_test
_build
.DS_Store
# Architecture specific extensions/prefixes
*.[568vq]
[568vq].out
*.cgo1.go
*.cgo2.c
_cgo_defun.c
_cgo_gotypes.go
_cgo_export.*
# Test binary, build with `go test -c`
*.test
# Output of the go coverage tool, specifically when used with LiteIDE
*.out
# vim temp files
*~
*.swp
*.swo

View File

@ -5,14 +5,14 @@ This plugin is a http client for micro.
## Overview ## Overview
The http client wraps `net/http` to provide a robust micro client with service discovery, load balancing and streaming. The http client wraps `net/http` to provide a robust micro client with service discovery, load balancing and streaming.
It complies with the [micro.Client](https://godoc.org/go.unistack.org/micro-client-http/v3#Client) interface. It complies with the [micro.Client](https://godoc.org/go.unistack.org/micro-client-http/v4#Client) interface.
## Usage ## Usage
### Use directly ### Use directly
```go ```go
import "go.unistack.org/micro-client-http/v3" import "go.unistack.org/micro-client-http/v4"
service := micro.NewService( service := micro.NewService(
micro.Name("my.service"), micro.Name("my.service"),

16
go.mod
View File

@ -1,15 +1,5 @@
module go.unistack.org/micro-client-http/v3 module go.unistack.org/micro-client-http/v4
go 1.22 go 1.19
toolchain go1.23.1 require go.unistack.org/micro/v4 v4.0.18
require go.unistack.org/micro/v3 v3.10.97
require (
go.unistack.org/micro-proto/v3 v3.4.1 // indirect
golang.org/x/sys v0.26.0 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9 // indirect
google.golang.org/grpc v1.67.1 // indirect
google.golang.org/protobuf v1.35.1 // indirect
)

45
go.sum
View File

@ -1,39 +1,6 @@
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= go.unistack.org/micro/v4 v4.0.1 h1:xo1IxbVfgh8i0eY0VeYa3cbb13u5n/Mxnp3FOgWD4Jo=
go.unistack.org/micro-proto/v3 v3.4.1 h1:UTjLSRz2YZuaHk9iSlVqqsA50JQNAEK2ZFboGqtEa9Q= go.unistack.org/micro/v4 v4.0.1/go.mod h1:p/J5UcSJjfHsWGT31uKoghQ5rUQZzQJBAFy+Z4+ZVMs=
go.unistack.org/micro-proto/v3 v3.4.1/go.mod h1:okx/cnOhzuCX0ggl/vToatbCupi0O44diiiLLsZ93Zo= go.unistack.org/micro/v4 v4.0.6 h1:YFWvTh3VwyOd6NHYTQcf47n2TF5+p/EhpnbuBQX3qhk=
go.unistack.org/micro/v3 v3.10.69 h1:V4g9LqUhzGab73U2aevnjtffCdJqGTuMfWY7fy4qGwI= go.unistack.org/micro/v4 v4.0.6/go.mod h1:bVEYTlPi0EsdgZZt311bIroDg9ict7ky3C87dSCCAGk=
go.unistack.org/micro/v3 v3.10.69/go.mod h1:erMgt3Bl7vQQ0e9UpQyR5NlLiZ9pKeEJ9+1tfYFaqUg= go.unistack.org/micro/v4 v4.0.18 h1:b7WFwem8Nz1xBrRg5FeLnm9CE5gJseHyf9j0BhkiXW0=
go.unistack.org/micro/v3 v3.10.88 h1:MxlzP+77Y6Kphb3lzHxROL4XfE/WdCQMQpnPv4D9Z8U= go.unistack.org/micro/v4 v4.0.18/go.mod h1:5+da5r835gP0WnNZbYUJDCvWpJ9Xc3IEGyp62e8o8R4=
go.unistack.org/micro/v3 v3.10.88/go.mod h1:erMgt3Bl7vQQ0e9UpQyR5NlLiZ9pKeEJ9+1tfYFaqUg=
go.unistack.org/micro/v3 v3.10.91 h1:vuJY4tXwpqimwIkEJ3TozMYNVQQs+C5QMlQWPgSY/YM=
go.unistack.org/micro/v3 v3.10.91/go.mod h1:erMgt3Bl7vQQ0e9UpQyR5NlLiZ9pKeEJ9+1tfYFaqUg=
go.unistack.org/micro/v3 v3.10.97 h1:8l7fv+i06/PjPrBBhRC/ZQkWGIOuHPg3jJN0vktYE78=
go.unistack.org/micro/v3 v3.10.97/go.mod h1:YzMldzHN9Ei+zy5t/Psu7RUWDZwUfrNYiStSQtTz90g=
golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
google.golang.org/genproto/googleapis/rpc v0.0.0-20240415180920-8c6c420018be h1:LG9vZxsWGOmUKieR8wPAUR3u3MpnYFQZROPIMaXh7/A=
google.golang.org/genproto/googleapis/rpc v0.0.0-20240415180920-8c6c420018be/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY=
google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 h1:pPJltXNxVzT4pK9yD8vR9X75DaWYYmLGMsEvBfFQZzQ=
google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU=
google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9 h1:QCqS/PdaHTSWGvupk2F/ehwHtGc0/GYkT+3GAcR1CCc=
google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI=
google.golang.org/grpc v1.63.2 h1:MUeiw1B2maTVZthpU5xvASfTh3LDbxHd6IJ6QQVU+xM=
google.golang.org/grpc v1.63.2/go.mod h1:WAX/8DgncnokcFUldAxq7GeB5DXHDbMF+lLvDomNkRA=
google.golang.org/grpc v1.66.2 h1:3QdXkuq3Bkh7w+ywLdLvM56cmGvQHUMZpiCzt6Rqaoo=
google.golang.org/grpc v1.66.2/go.mod h1:s3/l6xSSCURdVfAnL+TqCNMyTDAGN6+lZeVxnZR128Y=
google.golang.org/grpc v1.67.0 h1:IdH9y6PF5MPSdAntIcpjQ+tXO41pcQsfZV2RxtQgVcw=
google.golang.org/grpc v1.67.0/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA=
google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E=
google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA=
google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=

352
http.go
View File

@ -1,32 +1,27 @@
// Package http provides a http client // Package http provides a http client
package http // import "go.unistack.org/micro-client-http/v3" package http // import "go.unistack.org/micro-client-http/v4"
import ( import (
"bufio" "bufio"
"bytes" "bytes"
"context" "context"
"fmt" "fmt"
"io" "io/ioutil"
"net" "net"
"net/http" "net/http"
"net/url" "net/url"
"os"
"strconv"
"strings" "strings"
"sync" "sync"
"time" "time"
"go.unistack.org/micro/v3/broker" "go.unistack.org/micro/v4/client"
"go.unistack.org/micro/v3/client" "go.unistack.org/micro/v4/codec"
"go.unistack.org/micro/v3/codec" "go.unistack.org/micro/v4/errors"
"go.unistack.org/micro/v3/errors" "go.unistack.org/micro/v4/logger"
"go.unistack.org/micro/v3/logger" "go.unistack.org/micro/v4/metadata"
"go.unistack.org/micro/v3/metadata" "go.unistack.org/micro/v4/options"
"go.unistack.org/micro/v3/options" "go.unistack.org/micro/v4/selector"
"go.unistack.org/micro/v3/selector" rutil "go.unistack.org/micro/v4/util/reflect"
"go.unistack.org/micro/v3/semconv"
"go.unistack.org/micro/v3/tracer"
rutil "go.unistack.org/micro/v3/util/reflect"
) )
var DefaultContentType = "application/json" var DefaultContentType = "application/json"
@ -39,13 +34,10 @@ func filterLabel(r []router.Route) []router.Route {
*/ */
type httpClient struct { type httpClient struct {
funcPublish client.FuncPublish httpcli *http.Client
funcBatchPublish client.FuncBatchPublish opts client.Options
funcCall client.FuncCall
funcStream client.FuncStream
httpcli *http.Client
opts client.Options
sync.RWMutex sync.RWMutex
init bool
} }
func newRequest(ctx context.Context, log logger.Logger, addr string, req client.Request, ct string, cf codec.Codec, msg interface{}, opts client.CallOptions) (*http.Request, error) { func newRequest(ctx context.Context, log logger.Logger, addr string, req client.Request, ct string, cf codec.Codec, msg interface{}, opts client.CallOptions) (*http.Request, error) {
@ -123,7 +115,7 @@ func newRequest(ctx context.Context, log logger.Logger, addr string, req client.
u, err = u.Parse(path) u, err = u.Parse(path)
if err != nil { if err != nil {
return nil, errors.BadRequest("go.micro.client", "%+v", err) return nil, errors.BadRequest("go.micro.client", err.Error())
} }
var nmsg interface{} var nmsg interface{}
@ -134,12 +126,12 @@ func newRequest(ctx context.Context, log logger.Logger, addr string, req client.
} }
if err != nil { if err != nil {
return nil, errors.BadRequest("go.micro.client", "%+v", err) return nil, errors.BadRequest("go.micro.client", err.Error())
} }
u, err = url.Parse(fmt.Sprintf("%s://%s%s", scheme, host, path)) u, err = url.Parse(fmt.Sprintf("%s://%s%s", scheme, host, path))
if err != nil { if err != nil {
return nil, errors.BadRequest("go.micro.client", "%+v", err) return nil, errors.BadRequest("go.micro.client", err.Error())
} }
var cookies []*http.Cookie var cookies []*http.Cookie
@ -147,7 +139,7 @@ func newRequest(ctx context.Context, log logger.Logger, addr string, req client.
if opts.Context != nil { if opts.Context != nil {
if md, ok := opts.Context.Value(metadataKey{}).(metadata.Metadata); ok { if md, ok := opts.Context.Value(metadataKey{}).(metadata.Metadata); ok {
for k, v := range md { for k, v := range md {
header.Set(k, v) header[k] = v
} }
} }
} }
@ -156,13 +148,13 @@ func newRequest(ctx context.Context, log logger.Logger, addr string, req client.
} }
if opts.RequestMetadata != nil { if opts.RequestMetadata != nil {
for k, v := range opts.RequestMetadata { for k, v := range opts.RequestMetadata {
header.Set(k, v) header[k] = v
} }
} }
if md, ok := metadata.FromOutgoingContext(ctx); ok { if md, ok := metadata.FromOutgoingContext(ctx); ok {
for k, v := range md { for k, v := range md {
header.Set(k, v) header[k] = v
} }
} }
@ -182,11 +174,11 @@ func newRequest(ctx context.Context, log logger.Logger, addr string, req client.
for k, required := range vm { for k, required := range vm {
v, err = rutil.StructFieldByPath(msg, k) v, err = rutil.StructFieldByPath(msg, k)
if err != nil { if err != nil {
return nil, errors.BadRequest("go.micro.client", "%+v", err) return nil, errors.BadRequest("go.micro.client", err.Error())
} }
if rutil.IsZero(v) { if rutil.IsZero(v) {
if required == "true" { if required == "true" {
return nil, errors.BadRequest("go.micro.client", "required field %s not set", k) return nil, errors.BadRequest("go.micro.client", fmt.Sprintf("required field %s not set", k))
} }
continue continue
} }
@ -202,12 +194,12 @@ func newRequest(ctx context.Context, log logger.Logger, addr string, req client.
b, err := cf.Marshal(nmsg) b, err := cf.Marshal(nmsg)
if err != nil { if err != nil {
return nil, errors.BadRequest("go.micro.client", "%+v", err) return nil, errors.BadRequest("go.micro.client", err.Error())
} }
var hreq *http.Request var hreq *http.Request
if len(b) > 0 { if len(b) > 0 {
hreq, err = http.NewRequestWithContext(ctx, method, u.String(), io.NopCloser(bytes.NewBuffer(b))) hreq, err = http.NewRequestWithContext(ctx, method, u.String(), ioutil.NopCloser(bytes.NewBuffer(b)))
hreq.ContentLength = int64(len(b)) hreq.ContentLength = int64(len(b))
header.Set("Content-Length", fmt.Sprintf("%d", hreq.ContentLength)) header.Set("Content-Length", fmt.Sprintf("%d", hreq.ContentLength))
} else { } else {
@ -215,7 +207,7 @@ func newRequest(ctx context.Context, log logger.Logger, addr string, req client.
} }
if err != nil { if err != nil {
return nil, errors.BadRequest("go.micro.client", "%+v", err) return nil, errors.BadRequest("go.micro.client", err.Error())
} }
hreq.Header = header hreq.Header = header
@ -230,62 +222,62 @@ func newRequest(ctx context.Context, log logger.Logger, addr string, req client.
return hreq, nil return hreq, nil
} }
func (c *httpClient) call(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error { func (h *httpClient) call(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
ct := req.ContentType() ct := req.ContentType()
if len(opts.ContentType) > 0 { if len(opts.ContentType) > 0 {
ct = opts.ContentType ct = opts.ContentType
} }
cf, err := c.newCodec(ct) cf, err := h.newCodec(ct)
if err != nil { if err != nil {
return errors.BadRequest("go.micro.client", "%+v", err) return errors.BadRequest("go.micro.client", err.Error())
} }
hreq, err := newRequest(ctx, c.opts.Logger, addr, req, ct, cf, req.Body(), opts) hreq, err := newRequest(ctx, h.opts.Logger, addr, req, ct, cf, req.Body(), opts)
if err != nil { if err != nil {
return err return err
} }
// make the request // make the request
hrsp, err := c.httpcli.Do(hreq) hrsp, err := h.httpcli.Do(hreq)
if err != nil { if err != nil {
switch err := err.(type) { switch err := err.(type) {
case *url.Error: case *url.Error:
if err, ok := err.Err.(net.Error); ok && err.Timeout() { if err, ok := err.Err.(net.Error); ok && err.Timeout() {
return errors.Timeout("go.micro.client", "%+v", err) return errors.Timeout("go.micro.client", err.Error())
} }
case net.Error: case net.Error:
if err.Timeout() { if err.Timeout() {
return errors.Timeout("go.micro.client", "%+v", err) return errors.Timeout("go.micro.client", err.Error())
} }
} }
return errors.InternalServerError("go.micro.client", "%+v", err) return errors.InternalServerError("go.micro.client", err.Error())
} }
defer hrsp.Body.Close() defer hrsp.Body.Close()
return c.parseRsp(ctx, hrsp, rsp, opts) return h.parseRsp(ctx, hrsp, rsp, opts)
} }
func (c *httpClient) stream(ctx context.Context, addr string, req client.Request, opts client.CallOptions) (client.Stream, error) { func (h *httpClient) stream(ctx context.Context, addr string, req client.Request, opts client.CallOptions) (client.Stream, error) {
ct := req.ContentType() ct := req.ContentType()
if len(opts.ContentType) > 0 { if len(opts.ContentType) > 0 {
ct = opts.ContentType ct = opts.ContentType
} }
// get codec // get codec
cf, err := c.newCodec(ct) cf, err := h.newCodec(ct)
if err != nil { if err != nil {
return nil, errors.BadRequest("go.micro.client", "%+v", err) return nil, errors.BadRequest("go.micro.client", err.Error())
} }
cc, err := (c.httpcli.Transport).(*http.Transport).DialContext(ctx, "tcp", addr) cc, err := (h.httpcli.Transport).(*http.Transport).DialContext(ctx, "tcp", addr)
if err != nil { if err != nil {
return nil, errors.InternalServerError("go.micro.client", "Error dialing: %v", err) return nil, errors.InternalServerError("go.micro.client", fmt.Sprintf("Error dialing: %v", err))
} }
return &httpStream{ return &httpStream{
address: addr, address: addr,
logger: c.opts.Logger, logger: h.opts.Logger,
context: ctx, context: ctx,
closed: make(chan bool), closed: make(chan bool),
opts: opts, opts: opts,
@ -297,88 +289,56 @@ func (c *httpClient) stream(ctx context.Context, addr string, req client.Request
}, nil }, nil
} }
func (c *httpClient) newCodec(ct string) (codec.Codec, error) { func (h *httpClient) newCodec(ct string) (codec.Codec, error) {
c.RLock() h.RLock()
defer h.RUnlock()
if idx := strings.IndexRune(ct, ';'); idx >= 0 { if idx := strings.IndexRune(ct, ';'); idx >= 0 {
ct = ct[:idx] ct = ct[:idx]
} }
if cf, ok := c.opts.Codecs[ct]; ok { if c, ok := h.opts.Codecs[ct]; ok {
c.RUnlock() return c, nil
return cf, nil
} }
c.RUnlock()
return nil, codec.ErrUnknownContentType return nil, codec.ErrUnknownContentType
} }
func (c *httpClient) Init(opts ...client.Option) error { func (h *httpClient) Init(opts ...options.Option) error {
if len(opts) == 0 && h.init {
return nil
}
for _, o := range opts { for _, o := range opts {
o(&c.opts) o(&h.opts)
} }
c.funcCall = c.fnCall if err := h.opts.Tracer.Init(); err != nil {
c.funcStream = c.fnStream return err
c.funcPublish = c.fnPublish }
c.funcBatchPublish = c.fnBatchPublish if err := h.opts.Router.Init(); err != nil {
return err
c.opts.Hooks.EachPrev(func(hook options.Hook) { }
switch h := hook.(type) { if err := h.opts.Logger.Init(); err != nil {
case client.HookCall: return err
c.funcCall = h(c.funcCall) }
case client.HookStream: if err := h.opts.Meter.Init(); err != nil {
c.funcStream = h(c.funcStream) return err
case client.HookPublish: }
c.funcPublish = h(c.funcPublish)
case client.HookBatchPublish:
c.funcBatchPublish = h(c.funcBatchPublish)
}
})
return nil return nil
} }
func (c *httpClient) Options() client.Options { func (h *httpClient) Options() client.Options {
return c.opts return h.opts
} }
func (c *httpClient) NewMessage(topic string, msg interface{}, opts ...client.MessageOption) client.Message { func (h *httpClient) NewRequest(service, method string, req interface{}, opts ...options.Option) client.Request {
return newHTTPMessage(topic, msg, c.opts.ContentType, opts...) return newHTTPRequest(service, method, req, h.opts.ContentType, opts...)
} }
func (c *httpClient) NewRequest(service, method string, req interface{}, opts ...client.RequestOption) client.Request { func (h *httpClient) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...options.Option) error {
return newHTTPRequest(service, method, req, c.opts.ContentType, opts...)
}
func (c *httpClient) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
ts := time.Now()
c.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Inc()
var sp tracer.Span
ctx, sp = c.opts.Tracer.Start(ctx, req.Endpoint()+" rpc-client",
tracer.WithSpanKind(tracer.SpanKindClient),
tracer.WithSpanLabels("endpoint", req.Endpoint()),
)
err := c.funcCall(ctx, req, rsp, opts...)
c.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Dec()
te := time.Since(ts)
c.opts.Meter.Summary(semconv.ClientRequestLatencyMicroseconds, "endpoint", req.Endpoint()).Update(te.Seconds())
c.opts.Meter.Histogram(semconv.ClientRequestDurationSeconds, "endpoint", req.Endpoint()).Update(te.Seconds())
if me := errors.FromError(err); me == nil {
sp.Finish()
c.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "success", "code", strconv.Itoa(int(200))).Inc()
} else {
sp.SetStatus(tracer.SpanStatusError, err.Error())
c.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "failure", "code", strconv.Itoa(int(me.Code))).Inc()
}
return err
}
func (c *httpClient) fnCall(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
// make a copy of call opts // make a copy of call opts
callOpts := c.opts.CallOptions callOpts := h.opts.CallOptions
for _, opt := range opts { for _, opt := range opts {
opt(&callOpts) opt(&callOpts)
} }
@ -393,8 +353,9 @@ func (c *httpClient) fnCall(ctx context.Context, req client.Request, rsp interfa
} else { } else {
// got a deadline so no need to setup context // got a deadline so no need to setup context
// but we need to set the timeout we pass along // but we need to set the timeout we pass along
opt := client.WithRequestTimeout(time.Until(d)) if err := options.Set(&callOpts, time.Until(d), ".RequestTimeout"); err != nil {
opt(&callOpts) return errors.New("go.micro.client", fmt.Sprintf("%v", err.Error()), 400)
}
} }
// should we noop right here? // should we noop right here?
@ -405,21 +366,26 @@ func (c *httpClient) fnCall(ctx context.Context, req client.Request, rsp interfa
} }
// make copy of call method // make copy of call method
hcall := c.call hcall := h.call
// wrap the call in reverse
//for i := len(callOpts.CallWrappers); i > 0; i-- {
// hcall = callOpts.CallWrappers[i-1](hcall)
//}
// use the router passed as a call option, or fallback to the rpc clients router // use the router passed as a call option, or fallback to the rpc clients router
if callOpts.Router == nil { if callOpts.Router == nil {
callOpts.Router = c.opts.Router callOpts.Router = h.opts.Router
} }
if callOpts.Selector == nil { if callOpts.Selector == nil {
callOpts.Selector = c.opts.Selector callOpts.Selector = h.opts.Selector
} }
// inject proxy address // inject proxy address
// TODO: don't even bother using Lookup/Select in this case // TODO: don't even bother using Lookup/Select in this case
if len(c.opts.Proxy) > 0 { if len(h.opts.Proxy) > 0 {
callOpts.Address = []string{c.opts.Proxy} callOpts.Address = []string{h.opts.Proxy}
} }
var next selector.Next var next selector.Next
@ -429,7 +395,7 @@ func (c *httpClient) fnCall(ctx context.Context, req client.Request, rsp interfa
// call backoff first. Someone may want an initial start delay // call backoff first. Someone may want an initial start delay
t, err := callOpts.Backoff(ctx, req, i) t, err := callOpts.Backoff(ctx, req, i)
if err != nil { if err != nil {
return errors.InternalServerError("go.micro.client", "%+v", err) return errors.InternalServerError("go.micro.client", err.Error())
} }
// only sleep if greater than 0 // only sleep if greater than 0
@ -441,9 +407,9 @@ func (c *httpClient) fnCall(ctx context.Context, req client.Request, rsp interfa
var routes []string var routes []string
// lookup the route to send the reques to // lookup the route to send the reques to
// TODO apply any filtering here // TODO apply any filtering here
routes, err = c.opts.Lookup(ctx, req, callOpts) routes, err = h.opts.Lookup(ctx, req, callOpts)
if err != nil { if err != nil {
return errors.InternalServerError("go.micro.client", "%+v", err) return errors.InternalServerError("go.micro.client", err.Error())
} }
// balance the list of nodes // balance the list of nodes
@ -458,7 +424,7 @@ func (c *httpClient) fnCall(ctx context.Context, req client.Request, rsp interfa
// make the call // make the call
err = hcall(ctx, node, req, rsp, callOpts) err = hcall(ctx, node, req, rsp, callOpts)
// record the result of the call to inform future routing decisions // record the result of the call to inform future routing decisions
if verr := c.opts.Selector.Record(node, err); verr != nil { if verr := h.opts.Selector.Record(node, err); verr != nil {
return verr return verr
} }
@ -503,36 +469,11 @@ func (c *httpClient) fnCall(ctx context.Context, req client.Request, rsp interfa
return gerr return gerr
} }
func (c *httpClient) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) { func (h *httpClient) Stream(ctx context.Context, req client.Request, opts ...options.Option) (client.Stream, error) {
ts := time.Now()
c.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Inc()
var sp tracer.Span
ctx, sp = c.opts.Tracer.Start(ctx, req.Endpoint()+" rpc-client",
tracer.WithSpanKind(tracer.SpanKindClient),
tracer.WithSpanLabels("endpoint", req.Endpoint()),
)
stream, err := c.funcStream(ctx, req, opts...)
c.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Dec()
te := time.Since(ts)
c.opts.Meter.Summary(semconv.ClientRequestLatencyMicroseconds, "endpoint", req.Endpoint()).Update(te.Seconds())
c.opts.Meter.Histogram(semconv.ClientRequestDurationSeconds, "endpoint", req.Endpoint()).Update(te.Seconds())
if me := errors.FromError(err); me == nil {
sp.Finish()
c.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "success", "code", strconv.Itoa(int(200))).Inc()
} else {
sp.SetStatus(tracer.SpanStatusError, err.Error())
c.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "failure", "code", strconv.Itoa(int(me.Code))).Inc()
}
return stream, err
}
func (c *httpClient) fnStream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
var err error var err error
// make a copy of call opts // make a copy of call opts
callOpts := c.opts.CallOptions callOpts := h.opts.CallOptions
for _, o := range opts { for _, o := range opts {
o(&callOpts) o(&callOpts)
} }
@ -547,8 +488,9 @@ func (c *httpClient) fnStream(ctx context.Context, req client.Request, opts ...c
} else { } else {
// got a deadline so no need to setup context // got a deadline so no need to setup context
// but we need to set the timeout we pass along // but we need to set the timeout we pass along
o := client.WithStreamTimeout(time.Until(d)) if err = options.Set(&callOpts, time.Until(d), ".StreamTimeout"); err != nil {
o(&callOpts) return nil, errors.New("go.micro.client", fmt.Sprintf("%v", err.Error()), 400)
}
} }
// should we noop right here? // should we noop right here?
@ -569,17 +511,17 @@ func (c *httpClient) fnStream(ctx context.Context, req client.Request, opts ...c
// use the router passed as a call option, or fallback to the rpc clients router // use the router passed as a call option, or fallback to the rpc clients router
if callOpts.Router == nil { if callOpts.Router == nil {
callOpts.Router = c.opts.Router callOpts.Router = h.opts.Router
} }
if callOpts.Selector == nil { if callOpts.Selector == nil {
callOpts.Selector = c.opts.Selector callOpts.Selector = h.opts.Selector
} }
// inject proxy address // inject proxy address
// TODO: don't even bother using Lookup/Select in this case // TODO: don't even bother using Lookup/Select in this case
if len(c.opts.Proxy) > 0 { if len(h.opts.Proxy) > 0 {
callOpts.Address = []string{c.opts.Proxy} callOpts.Address = []string{h.opts.Proxy}
} }
var next selector.Next var next selector.Next
@ -588,7 +530,7 @@ func (c *httpClient) fnStream(ctx context.Context, req client.Request, opts ...c
// call backoff first. Someone may want an initial start delay // call backoff first. Someone may want an initial start delay
t, cerr := callOpts.Backoff(ctx, req, i) t, cerr := callOpts.Backoff(ctx, req, i)
if cerr != nil { if cerr != nil {
return nil, errors.InternalServerError("go.micro.client", "%+v", cerr) return nil, errors.InternalServerError("go.micro.client", cerr.Error())
} }
// only sleep if greater than 0 // only sleep if greater than 0
@ -600,9 +542,9 @@ func (c *httpClient) fnStream(ctx context.Context, req client.Request, opts ...c
var routes []string var routes []string
// lookup the route to send the reques to // lookup the route to send the reques to
// TODO apply any filtering here // TODO apply any filtering here
routes, err = c.opts.Lookup(ctx, req, callOpts) routes, err = h.opts.Lookup(ctx, req, callOpts)
if err != nil { if err != nil {
return nil, errors.InternalServerError("go.micro.client", "%+v", err) return nil, errors.InternalServerError("go.micro.client", err.Error())
} }
// balance the list of nodes // balance the list of nodes
@ -614,10 +556,10 @@ func (c *httpClient) fnStream(ctx context.Context, req client.Request, opts ...c
node := next() node := next()
stream, cerr := c.stream(ctx, node, req, callOpts) stream, cerr := h.stream(ctx, node, req, callOpts)
// record the result of the call to inform future routing decisions // record the result of the call to inform future routing decisions
if verr := c.opts.Selector.Record(node, cerr); verr != nil { if verr := h.opts.Selector.Record(node, cerr); verr != nil {
return nil, verr return nil, verr
} }
@ -668,100 +610,22 @@ func (c *httpClient) fnStream(ctx context.Context, req client.Request, opts ...c
return nil, grr return nil, grr
} }
func (c *httpClient) BatchPublish(ctx context.Context, p []client.Message, opts ...client.PublishOption) error { func (h *httpClient) String() string {
return c.funcBatchPublish(ctx, p, opts...)
}
func (c *httpClient) fnBatchPublish(ctx context.Context, p []client.Message, opts ...client.PublishOption) error {
return c.publish(ctx, p, opts...)
}
func (c *httpClient) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
return c.funcPublish(ctx, p, opts...)
}
func (c *httpClient) fnPublish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
return c.publish(ctx, []client.Message{p}, opts...)
}
func (c *httpClient) publish(ctx context.Context, ps []client.Message, opts ...client.PublishOption) error {
var body []byte
options := client.NewPublishOptions(opts...)
// get proxy
exchange := ""
if v, ok := os.LookupEnv("MICRO_PROXY"); ok {
exchange = v
}
// get the exchange
if len(options.Exchange) > 0 {
exchange = options.Exchange
}
omd, ok := metadata.FromOutgoingContext(ctx)
if !ok {
omd = metadata.New(2)
}
msgs := make([]*broker.Message, 0, len(ps))
for _, p := range ps {
md := metadata.Copy(omd)
md[metadata.HeaderContentType] = p.ContentType()
topic := p.Topic()
if len(exchange) > 0 {
topic = exchange
}
md.Set(metadata.HeaderTopic, topic)
iter := p.Metadata().Iterator()
var k, v string
for iter.Next(&k, &v) {
md.Set(k, v)
}
// passed in raw data
if d, ok := p.Payload().(*codec.Frame); ok {
body = d.Data
} else {
// use codec for payload
cf, err := c.newCodec(p.ContentType())
if err != nil {
return errors.InternalServerError("go.micro.client", "%+v", err)
}
// set the body
b, err := cf.Marshal(p.Payload())
if err != nil {
return errors.InternalServerError("go.micro.client", "%+v", err)
}
body = b
}
msgs = append(msgs, &broker.Message{Header: md, Body: body})
}
return c.opts.Broker.BatchPublish(ctx, msgs,
broker.PublishContext(ctx),
broker.PublishBodyOnly(options.BodyOnly),
)
}
func (c *httpClient) String() string {
return "http" return "http"
} }
func (c *httpClient) Name() string { func (h *httpClient) Name() string {
return c.opts.Name return h.opts.Name
} }
func NewClient(opts ...client.Option) *httpClient { func NewClient(opts ...options.Option) client.Client {
options := client.NewOptions(opts...) options := client.NewOptions(opts...)
if len(options.ContentType) == 0 { if len(options.ContentType) == 0 {
options.ContentType = DefaultContentType options.ContentType = DefaultContentType
} }
c := &httpClient{ rc := &httpClient{
opts: options, opts: options,
} }
@ -784,7 +648,7 @@ func NewClient(opts ...client.Option) *httpClient {
} }
if httpcli, ok := options.Context.Value(httpClientKey{}).(*http.Client); ok { if httpcli, ok := options.Context.Value(httpClientKey{}).(*http.Client); ok {
c.httpcli = httpcli rc.httpcli = httpcli
} else { } else {
// TODO customTransport := http.DefaultTransport.(*http.Transport).Clone() // TODO customTransport := http.DefaultTransport.(*http.Transport).Clone()
tr := &http.Transport{ tr := &http.Transport{
@ -800,13 +664,9 @@ func NewClient(opts ...client.Option) *httpClient {
ExpectContinueTimeout: 1 * time.Second, ExpectContinueTimeout: 1 * time.Second,
TLSClientConfig: options.TLSConfig, TLSClientConfig: options.TLSConfig,
} }
c.httpcli = &http.Client{Transport: tr} rc.httpcli = &http.Client{Transport: tr}
} }
c := client.Client(rc)
c.funcCall = c.fnCall
c.funcStream = c.fnStream
c.funcPublish = c.fnPublish
c.funcBatchPublish = c.fnBatchPublish
return c return c
} }

View File

@ -1,60 +1,21 @@
package http package http
import ( import (
"encoding/json"
"fmt"
"net/url" "net/url"
"strings" "strings"
"testing" "testing"
) )
func TestNestedPathPost(t *testing.T) { type Request struct {
req := &request{Name: "first", Field1: "fieldval"} Name string `json:"name"`
p, m, err := newPathRequest("/api/v1/xxxx", "POST", "*", req, []string{"json", "protobuf"}, nil) Field1 string `json:"field1"`
if err != nil { ClientID string
t.Fatal(err) Field2 string
} Field3 int64
u, err := url.Parse(p)
if err != nil {
t.Fatal(err)
}
if s := u.String(); s != "/api/v1/xxxx" {
t.Fatalf("nested path error %s", s)
}
_ = m
}
type request struct {
NestedTest *request `json:"nested_test,omitempty"`
Name string `json:"name,omitempty"`
Field1 string `json:"field1,omitempty"`
ClientID string `json:",omitempty"`
Field2 string `json:",omitempty"`
Field3 int64 `json:",omitempty"`
}
func TestNestedPath(t *testing.T) {
req := &request{Name: "first", NestedTest: &request{Name: "second"}, Field1: "fieldval"}
p, m, err := newPathRequest("/api/v1/{name}/{nested_test.name}", "PUT", "*", req, []string{"json", "protobuf"}, nil)
if err != nil {
t.Fatal(err)
}
u, err := url.Parse(p)
if err != nil {
t.Fatal(err)
}
if s := u.String(); s != "/api/v1/first/second" {
t.Fatalf("nested path error %s", s)
}
b, err := json.Marshal(m)
if err != nil {
t.Fatal(err)
}
fmt.Printf("m %#+v %s\n", m, b)
} }
func TestPathWithHeader(t *testing.T) { func TestPathWithHeader(t *testing.T) {
req := &request{Name: "vtolstov", Field1: "field1", ClientID: "1234567890"} req := &Request{Name: "vtolstov", Field1: "field1", ClientID: "1234567890"}
p, m, err := newPathRequest( p, m, err := newPathRequest(
"/api/v1/test?Name={name}&Field1={field1}", "/api/v1/test?Name={name}&Field1={field1}",
"POST", "POST",
@ -79,7 +40,7 @@ func TestPathWithHeader(t *testing.T) {
} }
func TestPathValues(t *testing.T) { func TestPathValues(t *testing.T) {
req := &request{Name: "vtolstov", Field1: "field1"} req := &Request{Name: "vtolstov", Field1: "field1"}
p, m, err := newPathRequest("/api/v1/test?Name={name}&Field1={field1}", "POST", "*", req, nil, nil) p, m, err := newPathRequest("/api/v1/test?Name={name}&Field1={field1}", "POST", "*", req, nil, nil)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -95,7 +56,7 @@ func TestPathValues(t *testing.T) {
} }
func TestValidPath(t *testing.T) { func TestValidPath(t *testing.T) {
req := &request{Name: "vtolstov", Field1: "field1", Field2: "field2", Field3: 10} req := &Request{Name: "vtolstov", Field1: "field1", Field2: "field2", Field3: 10}
p, m, err := newPathRequest("/api/v1/{name}/list", "GET", "", req, nil, nil) p, m, err := newPathRequest("/api/v1/{name}/list", "GET", "", req, nil, nil)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -112,9 +73,9 @@ func TestValidPath(t *testing.T) {
} }
func TestInvalidPath(t *testing.T) { func TestInvalidPath(t *testing.T) {
req := &request{Name: "vtolstov", Field1: "field1", Field2: "field2", Field3: 10} req := &Request{Name: "vtolstov", Field1: "field1", Field2: "field2", Field3: 10}
s, _, err := newPathRequest("/api/v1/{xname}/list", "GET", "", req, nil, nil) _, _, err := newPathRequest("/api/v1/{xname}/list", "GET", "", req, nil, nil)
if err == nil { if err == nil {
t.Fatalf("path param must not be filled: %s", s) t.Fatal("path param must not be filled")
} }
} }

View File

@ -1,44 +0,0 @@
package http
import (
"go.unistack.org/micro/v3/client"
"go.unistack.org/micro/v3/metadata"
)
type httpMessage struct {
payload interface{}
topic string
contentType string
opts client.MessageOptions
}
func newHTTPMessage(topic string, payload interface{}, contentType string, opts ...client.MessageOption) client.Message {
options := client.NewMessageOptions(opts...)
if len(options.ContentType) > 0 {
contentType = options.ContentType
}
return &httpMessage{
payload: payload,
topic: topic,
contentType: contentType,
opts: options,
}
}
func (h *httpMessage) ContentType() string {
return h.contentType
}
func (h *httpMessage) Topic() string {
return h.topic
}
func (h *httpMessage) Payload() interface{} {
return h.payload
}
func (h *httpMessage) Metadata() metadata.Metadata {
return h.opts.Metadata
}

View File

@ -4,8 +4,8 @@ import (
"net" "net"
"net/http" "net/http"
"go.unistack.org/micro/v3/client" "go.unistack.org/micro/v4/metadata"
"go.unistack.org/micro/v3/metadata" "go.unistack.org/micro/v4/options"
) )
var ( var (
@ -29,98 +29,98 @@ var (
type poolMaxStreams struct{} type poolMaxStreams struct{}
// PoolMaxStreams maximum streams on a connectioin // PoolMaxStreams maximum streams on a connectioin
func PoolMaxStreams(n int) client.Option { func PoolMaxStreams(n int) options.Option {
return client.SetOption(poolMaxStreams{}, n) return options.ContextOption(poolMaxStreams{}, n)
} }
type poolMaxIdle struct{} type poolMaxIdle struct{}
// PoolMaxIdle maximum idle conns of a pool // PoolMaxIdle maximum idle conns of a pool
func PoolMaxIdle(d int) client.Option { func PoolMaxIdle(d int) options.Option {
return client.SetOption(poolMaxIdle{}, d) return options.ContextOption(poolMaxIdle{}, d)
} }
type maxRecvMsgSizeKey struct{} type maxRecvMsgSizeKey struct{}
// MaxRecvMsgSize set the maximum size of message that client can receive. // MaxRecvMsgSize set the maximum size of message that client can receive.
func MaxRecvMsgSize(s int) client.Option { func MaxRecvMsgSize(s int) options.Option {
return client.SetOption(maxRecvMsgSizeKey{}, s) return options.ContextOption(maxRecvMsgSizeKey{}, s)
} }
type maxSendMsgSizeKey struct{} type maxSendMsgSizeKey struct{}
// MaxSendMsgSize set the maximum size of message that client can send. // MaxSendMsgSize set the maximum size of message that client can send.
func MaxSendMsgSize(s int) client.Option { func MaxSendMsgSize(s int) options.Option {
return client.SetOption(maxSendMsgSizeKey{}, s) return options.ContextOption(maxSendMsgSizeKey{}, s)
} }
type httpClientKey struct{} type httpClientKey struct{}
// nolint: golint // nolint: golint
// HTTPClient pass http.Client option to client Call // HTTPClient pass http.Client option to client Call
func HTTPClient(c *http.Client) client.Option { func HTTPClient(c *http.Client) options.Option {
return client.SetOption(httpClientKey{}, c) return options.ContextOption(httpClientKey{}, c)
} }
type httpDialerKey struct{} type httpDialerKey struct{}
// nolint: golint // nolint: golint
// HTTPDialer pass net.Dialer option to client // HTTPDialer pass net.Dialer option to client
func HTTPDialer(d *net.Dialer) client.Option { func HTTPDialer(d *net.Dialer) options.Option {
return client.SetOption(httpDialerKey{}, d) return options.ContextOption(httpDialerKey{}, d)
} }
type methodKey struct{} type methodKey struct{}
// Method pass method option to client Call // Method pass method option to client Call
func Method(m string) client.CallOption { func Method(m string) options.Option {
return client.SetCallOption(methodKey{}, m) return options.ContextOption(methodKey{}, m)
} }
type pathKey struct{} type pathKey struct{}
// Path spcecifies path option to client Call // Path spcecifies path option to client Call
func Path(p string) client.CallOption { func Path(p string) options.Option {
return client.SetCallOption(pathKey{}, p) return options.ContextOption(pathKey{}, p)
} }
type bodyKey struct{} type bodyKey struct{}
// Body specifies body option to client Call // Body specifies body option to client Call
func Body(b string) client.CallOption { func Body(b string) options.Option {
return client.SetCallOption(bodyKey{}, b) return options.ContextOption(bodyKey{}, b)
} }
type errorMapKey struct{} type errorMapKey struct{}
func ErrorMap(m map[string]interface{}) client.CallOption { func ErrorMap(m map[string]interface{}) options.Option {
return client.SetCallOption(errorMapKey{}, m) return options.ContextOption(errorMapKey{}, m)
} }
type structTagsKey struct{} type structTagsKey struct{}
// StructTags pass tags slice option to client Call // StructTags pass tags slice option to client Call
func StructTags(tags []string) client.CallOption { func StructTags(tags []string) options.Option {
return client.SetCallOption(structTagsKey{}, tags) return options.ContextOption(structTagsKey{}, tags)
} }
type metadataKey struct{} type metadataKey struct{}
// Metadata pass metadata to client Call // Metadata pass metadata to client Call
func Metadata(md metadata.Metadata) client.CallOption { func Metadata(md metadata.Metadata) options.Option {
return client.SetCallOption(metadataKey{}, md) return options.ContextOption(metadataKey{}, md)
} }
type cookieKey struct{} type cookieKey struct{}
// Cookie pass cookie to client Call // Cookie pass cookie to client Call
func Cookie(cookies ...string) client.CallOption { func Cookie(cookies ...string) options.Option {
return client.SetCallOption(cookieKey{}, cookies) return options.ContextOption(cookieKey{}, cookies)
} }
type headerKey struct{} type headerKey struct{}
// Header pass cookie to client Call // Header pass cookie to client Call
func Header(headers ...string) client.CallOption { func Header(headers ...string) options.Option {
return client.SetCallOption(headerKey{}, headers) return options.ContextOption(headerKey{}, headers)
} }

View File

@ -1,8 +1,9 @@
package http package http
import ( import (
"go.unistack.org/micro/v3/client" "go.unistack.org/micro/v4/client"
"go.unistack.org/micro/v3/codec" "go.unistack.org/micro/v4/codec"
"go.unistack.org/micro/v4/options"
) )
type httpRequest struct { type httpRequest struct {
@ -13,7 +14,7 @@ type httpRequest struct {
opts client.RequestOptions opts client.RequestOptions
} }
func newHTTPRequest(service, method string, request interface{}, contentType string, opts ...client.RequestOption) client.Request { func newHTTPRequest(service, method string, request interface{}, contentType string, opts ...options.Option) client.Request {
options := client.NewRequestOptions(opts...) options := client.NewRequestOptions(opts...)
if len(options.ContentType) == 0 { if len(options.ContentType) == 0 {
options.ContentType = contentType options.ContentType = contentType

View File

@ -9,10 +9,10 @@ import (
"net/http" "net/http"
"sync" "sync"
"go.unistack.org/micro/v3/client" "go.unistack.org/micro/v4/client"
"go.unistack.org/micro/v3/codec" "go.unistack.org/micro/v4/codec"
"go.unistack.org/micro/v3/errors" "go.unistack.org/micro/v4/errors"
"go.unistack.org/micro/v3/logger" "go.unistack.org/micro/v4/logger"
) )
// Implements the streamer interface // Implements the streamer interface
@ -90,7 +90,7 @@ func (h *httpStream) Recv(msg interface{}) error {
hrsp, err := http.ReadResponse(h.reader, new(http.Request)) hrsp, err := http.ReadResponse(h.reader, new(http.Request))
if err != nil { if err != nil {
return errors.InternalServerError("go.micro.client", "%+v", err) return errors.InternalServerError("go.micro.client", err.Error())
} }
defer hrsp.Body.Close() defer hrsp.Body.Close()
@ -136,7 +136,7 @@ func (h *httpStream) parseRsp(ctx context.Context, log logger.Logger, hrsp *http
if log.V(logger.ErrorLevel) { if log.V(logger.ErrorLevel) {
log.Error(ctx, "failed to read body", err) log.Error(ctx, "failed to read body", err)
} }
return errors.InternalServerError("go.micro.client", "%s", buf) return errors.InternalServerError("go.micro.client", string(buf))
} }
} }
@ -146,7 +146,7 @@ func (h *httpStream) parseRsp(ctx context.Context, log logger.Logger, hrsp *http
if hrsp.StatusCode < 400 { if hrsp.StatusCode < 400 {
if err = cf.Unmarshal(buf, rsp); err != nil { if err = cf.Unmarshal(buf, rsp); err != nil {
return errors.InternalServerError("go.micro.client", "%+v", err) return errors.InternalServerError("go.micro.client", err.Error())
} }
return nil return nil
} }
@ -163,7 +163,7 @@ func (h *httpStream) parseRsp(ctx context.Context, log logger.Logger, hrsp *http
} }
if cerr := cf.Unmarshal(buf, rerr); cerr != nil { if cerr := cf.Unmarshal(buf, rerr); cerr != nil {
return errors.InternalServerError("go.micro.client", "%+v", cerr) return errors.InternalServerError("go.micro.client", cerr.Error())
} }
if err, ok = rerr.(error); !ok { if err, ok = rerr.(error); !ok {

86
util.go
View File

@ -10,11 +10,11 @@ import (
"strings" "strings"
"sync" "sync"
"go.unistack.org/micro/v3/client" "go.unistack.org/micro/v4/client"
"go.unistack.org/micro/v3/errors" "go.unistack.org/micro/v4/errors"
"go.unistack.org/micro/v3/logger" "go.unistack.org/micro/v4/logger"
"go.unistack.org/micro/v3/metadata" "go.unistack.org/micro/v4/metadata"
rutil "go.unistack.org/micro/v3/util/reflect" rutil "go.unistack.org/micro/v4/util/reflect"
) )
var ( var (
@ -87,8 +87,6 @@ func newPathRequest(path string, method string, body string, msg interface{}, ta
values := url.Values{} values := url.Values{}
// copy cycle // copy cycle
cleanPath := make(map[string]bool)
for i := 0; i < tmsg.NumField(); i++ { for i := 0; i < tmsg.NumField(); i++ {
val := tmsg.Field(i) val := tmsg.Field(i)
if val.IsZero() { if val.IsZero() {
@ -123,7 +121,6 @@ func newPathRequest(path string, method string, body string, msg interface{}, ta
default: default:
t = &tag{key: tn, name: tp[0]} t = &tag{key: tn, name: tp[0]}
} }
if t.name != "" { if t.name != "" {
break break
} }
@ -157,63 +154,18 @@ func newPathRequest(path string, method string, body string, msg interface{}, ta
default: default:
fieldsmap[t.name] = getParam(val) fieldsmap[t.name] = getParam(val)
} }
} else if (body == "*" || body == t.name) && method != http.MethodGet {
if tnmsg.Field(i).CanSet() {
tnmsg.Field(i).Set(val)
}
} else { } else {
for k, v := range fieldsmap { if val.Type().Kind() == reflect.Slice {
isSet := false for idx := 0; idx < val.Len(); idx++ {
if v != "" { values.Add(t.name, getParam(val.Index(idx)))
continue
}
var clean []string
fld := msg
parts := strings.Split(k, ".")
for idx := 0; idx < len(parts); idx++ {
var nfld interface{}
var name string
if tags == nil {
tags = []string{"json"}
}
tagsloop:
for ti := 0; ti < len(tags); ti++ {
name, nfld, err = rutil.StructFieldNameByTag(fld, tags[ti], parts[idx])
if err == nil {
clean = append(clean, name)
break tagsloop
}
}
if err == nil {
fld = nfld
if len(parts)-1 == idx {
isSet = true
fieldsmap[k] = fmt.Sprintf("%v", fld)
}
}
}
if isSet {
cleanPath[strings.Join(clean, ".")] = true
} }
} else {
values.Add(t.name, getParam(val))
} }
for k := range cleanPath {
if err = rutil.ZeroFieldByPath(nmsg, k); err != nil {
return "", nil, err
}
}
if (body == "*" || body == t.name) && method != http.MethodGet {
if tnmsg.Field(i).CanSet() {
tnmsg.Field(i).Set(val)
}
} else if method == http.MethodGet {
if val.Type().Kind() == reflect.Slice {
for idx := 0; idx < val.Len(); idx++ {
values.Add(t.name, getParam(val.Index(idx)))
}
} else if !rutil.IsEmpty(val) {
values.Add(t.name, getParam(val))
}
}
} }
} }
@ -265,8 +217,6 @@ func newPathRequest(path string, method string, body string, msg interface{}, ta
_, _ = b.WriteString(values.Encode()) _, _ = b.WriteString(values.Encode())
} }
// rutil.ZeroEmpty(tnmsg.Interface())
if rutil.IsZero(nmsg) && !isEmptyStruct(nmsg) { if rutil.IsZero(nmsg) && !isEmptyStruct(nmsg) {
return b.String(), nil, nil return b.String(), nil, nil
} }
@ -334,7 +284,7 @@ func (h *httpClient) parseRsp(ctx context.Context, hrsp *http.Response, rsp inte
if h.opts.Logger.V(logger.ErrorLevel) { if h.opts.Logger.V(logger.ErrorLevel) {
h.opts.Logger.Error(ctx, "failed to read body", err) h.opts.Logger.Error(ctx, "failed to read body", err)
} }
return errors.InternalServerError("go.micro.client", "%s", buf) return errors.InternalServerError("go.micro.client", string(buf))
} }
} }
@ -343,7 +293,7 @@ func (h *httpClient) parseRsp(ctx context.Context, hrsp *http.Response, rsp inte
if h.opts.Logger.V(logger.DebugLevel) { if h.opts.Logger.V(logger.DebugLevel) {
h.opts.Logger.Debug(ctx, fmt.Sprintf("response with %v unknown content-type %s %s", hrsp.Header, ct, buf)) h.opts.Logger.Debug(ctx, fmt.Sprintf("response with %v unknown content-type %s %s", hrsp.Header, ct, buf))
} }
return errors.InternalServerError("go.micro.client", "%+v", cerr) return errors.InternalServerError("go.micro.client", cerr.Error())
} }
if h.opts.Logger.V(logger.DebugLevel) { if h.opts.Logger.V(logger.DebugLevel) {
@ -353,7 +303,7 @@ func (h *httpClient) parseRsp(ctx context.Context, hrsp *http.Response, rsp inte
// succeseful response // succeseful response
if hrsp.StatusCode < 400 { if hrsp.StatusCode < 400 {
if err = cf.Unmarshal(buf, rsp); err != nil { if err = cf.Unmarshal(buf, rsp); err != nil {
return errors.InternalServerError("go.micro.client", "%+v", err) return errors.InternalServerError("go.micro.client", err.Error())
} }
return nil return nil
} }
@ -373,7 +323,7 @@ func (h *httpClient) parseRsp(ctx context.Context, hrsp *http.Response, rsp inte
} }
if cerr := cf.Unmarshal(buf, rerr); cerr != nil { if cerr := cf.Unmarshal(buf, rerr); cerr != nil {
return errors.InternalServerError("go.micro.client", "%+v", cerr) return errors.InternalServerError("go.micro.client", cerr.Error())
} }
if err, ok = rerr.(error); !ok { if err, ok = rerr.(error); !ok {

View File

@ -1,7 +1,6 @@
package http package http
import ( import (
"net/http"
"net/url" "net/url"
"testing" "testing"
) )
@ -53,16 +52,10 @@ func TestNewPathRequest(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
switch m { vals := u.Query()
case http.MethodPost, http.MethodPut, http.MethodPatch, http.MethodDelete: if v, ok := vals["name"]; !ok || v[0] != "test_name" {
break t.Fatalf("invalid path: %v nmsg: %v", path, nmsg)
case http.MethodGet:
vals := u.Query()
if v, ok := vals["name"]; !ok || v[0] != "test_name" {
t.Fatalf("%s invalid path: %v nmsg: %v", m, path, nmsg)
}
} }
} }
} }
@ -126,7 +119,7 @@ func TestNewPathVarRequest(t *testing.T) {
t.Fatalf("invalid nmsg: %#+v\n", nmsg) t.Fatalf("invalid nmsg: %#+v\n", nmsg)
} }
if nmsg.(*Message).Name != "test_name" { if nmsg.(*Message).Name != "test_name" {
t.Fatalf("invalid path: %v nmsg: %#+v", path, nmsg) t.Fatalf("invalid nmsg: %v nmsg: %v", path, nmsg)
} }
} else { } else {
vals := u.Query() vals := u.Query()