micro/client/rpc_client.go

612 lines
13 KiB
Go
Raw Normal View History

2015-01-14 02:31:27 +03:00
package client
import (
2018-03-03 14:53:52 +03:00
"context"
2015-01-14 02:31:27 +03:00
"fmt"
2019-01-30 21:42:11 +03:00
"os"
"sync"
"sync/atomic"
2019-01-18 15:30:39 +03:00
"time"
2019-01-10 23:35:10 +03:00
"github.com/google/uuid"
2015-11-20 19:17:33 +03:00
"github.com/micro/go-micro/broker"
2019-07-28 20:56:18 +03:00
"github.com/micro/go-micro/client/pool"
2019-06-21 19:20:41 +03:00
"github.com/micro/go-micro/client/selector"
2015-11-27 03:17:36 +03:00
"github.com/micro/go-micro/codec"
2015-11-20 19:17:33 +03:00
"github.com/micro/go-micro/errors"
2016-01-28 20:55:28 +03:00
"github.com/micro/go-micro/metadata"
2019-07-07 14:33:54 +03:00
"github.com/micro/go-micro/registry"
2019-07-10 09:47:17 +03:00
"github.com/micro/go-micro/transport"
"github.com/micro/go-micro/util/buf"
2015-01-14 02:31:27 +03:00
)
2015-05-23 19:40:53 +03:00
type rpcClient struct {
once sync.Once
opts Options
2019-07-28 20:56:18 +03:00
pool pool.Pool
2018-03-21 06:17:38 +03:00
seq uint64
2015-05-21 00:57:19 +03:00
}
2015-01-14 02:31:27 +03:00
2015-05-23 19:40:53 +03:00
func newRpcClient(opt ...Option) Client {
2016-01-03 02:16:15 +03:00
opts := newOptions(opt...)
2019-07-28 20:56:18 +03:00
p := pool.NewPool(
pool.Size(opts.PoolSize),
pool.TTL(opts.PoolTTL),
pool.Transport(opts.Transport),
)
2015-11-26 23:36:42 +03:00
rc := &rpcClient{
2016-05-13 17:58:53 +03:00
once: sync.Once{},
2015-05-23 19:40:53 +03:00
opts: opts,
2019-07-28 20:56:18 +03:00
pool: p,
2018-03-21 06:17:38 +03:00
seq: 0,
2015-05-23 19:40:53 +03:00
}
2015-11-26 23:36:42 +03:00
c := Client(rc)
// wrap in reverse
for i := len(opts.Wrappers); i > 0; i-- {
c = opts.Wrappers[i-1](c)
2015-11-26 23:36:42 +03:00
}
return c
2015-05-23 19:40:53 +03:00
}
func (r *rpcClient) newCodec(contentType string) (codec.NewCodec, error) {
if c, ok := r.opts.Codecs[contentType]; ok {
return c, nil
2015-11-25 22:50:05 +03:00
}
if cf, ok := DefaultCodecs[contentType]; ok {
2015-11-25 22:50:05 +03:00
return cf, nil
}
return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
}
2019-01-18 15:30:39 +03:00
func (r *rpcClient) call(ctx context.Context, node *registry.Node, req Request, resp interface{}, opts CallOptions) error {
address := node.Address
2015-05-21 00:57:19 +03:00
msg := &transport.Message{
Header: make(map[string]string),
}
2015-01-14 02:31:27 +03:00
2016-01-28 20:55:28 +03:00
md, ok := metadata.FromContext(ctx)
2015-05-23 13:53:40 +03:00
if ok {
for k, v := range md {
msg.Header[k] = v
2015-05-21 00:57:19 +03:00
}
2015-01-14 02:31:27 +03:00
}
2016-05-13 01:32:58 +03:00
// set timeout in nanoseconds
msg.Header["Timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
// set the content type for the request
2016-01-06 00:13:20 +03:00
msg.Header["Content-Type"] = req.ContentType()
// set the accept header
msg.Header["Accept"] = req.ContentType()
2015-05-21 00:57:19 +03:00
2019-01-18 15:30:39 +03:00
// setup old protocol
cf := setupProtocol(msg, node)
// no codec specified
if cf == nil {
var err error
cf, err = r.newCodec(req.ContentType())
if err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
2015-11-25 22:50:05 +03:00
}
2019-07-28 20:56:18 +03:00
c, err := r.pool.Get(address, transport.WithTimeout(opts.DialTimeout))
2015-01-14 02:31:27 +03:00
if err != nil {
2017-06-11 15:02:08 +03:00
return errors.InternalServerError("go.micro.client", "connection error: %v", err)
2015-01-14 02:31:27 +03:00
}
2018-09-20 05:08:00 +03:00
seq := atomic.LoadUint64(&r.seq)
2018-03-21 06:17:38 +03:00
atomic.AddUint64(&r.seq, 1)
2019-08-15 22:08:49 +03:00
codec := newRpcCodec(msg, c, cf, "")
2019-01-15 00:30:43 +03:00
rsp := &rpcResponse{
socket: c,
codec: codec,
}
2018-03-21 06:17:38 +03:00
2016-01-06 00:13:20 +03:00
stream := &rpcStream{
2019-08-16 18:46:29 +03:00
id: fmt.Sprintf("%v", seq),
2019-01-15 00:30:43 +03:00
context: ctx,
request: req,
response: rsp,
codec: codec,
closed: make(chan bool),
2019-08-16 18:46:29 +03:00
release: func(err error) { r.pool.Release(c, err) },
sendEOS: false,
2016-01-06 00:13:20 +03:00
}
2019-08-16 18:46:29 +03:00
// close the stream on exiting this function
2016-05-13 01:32:58 +03:00
defer stream.Close()
2016-01-04 00:14:33 +03:00
2019-08-16 18:46:29 +03:00
// wait for error response
2016-01-04 00:14:33 +03:00
ch := make(chan error, 1)
go func() {
2016-06-30 18:19:02 +03:00
defer func() {
if r := recover(); r != nil {
2017-06-11 15:02:08 +03:00
ch <- errors.InternalServerError("go.micro.client", "panic recovered: %v", r)
2016-06-30 18:19:02 +03:00
}
}()
2016-01-06 00:13:20 +03:00
// send request
2019-01-10 14:39:39 +03:00
if err := stream.Send(req.Body()); err != nil {
2016-01-06 00:13:20 +03:00
ch <- err
return
2016-01-04 00:14:33 +03:00
}
2016-01-06 00:13:20 +03:00
// recv request
if err := stream.Recv(resp); err != nil {
ch <- err
return
}
// success
ch <- nil
2016-01-04 00:14:33 +03:00
}()
2019-08-16 18:46:29 +03:00
var grr error
2016-01-04 00:14:33 +03:00
select {
2016-05-13 01:32:58 +03:00
case err := <-ch:
2016-05-13 17:58:53 +03:00
grr = err
2016-05-13 01:32:58 +03:00
return err
case <-ctx.Done():
2019-08-16 18:46:29 +03:00
grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
2015-10-22 17:14:56 +03:00
}
2019-08-16 18:46:29 +03:00
// set the stream error
if grr != nil {
stream.Lock()
stream.err = grr
stream.Unlock()
return grr
}
return nil
}
2015-01-14 02:31:27 +03:00
2019-01-18 15:30:39 +03:00
func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request, opts CallOptions) (Stream, error) {
address := node.Address
msg := &transport.Message{
Header: make(map[string]string),
2015-01-14 02:31:27 +03:00
}
2016-01-28 20:55:28 +03:00
md, ok := metadata.FromContext(ctx)
if ok {
for k, v := range md {
msg.Header[k] = v
}
2015-01-14 02:31:27 +03:00
}
2016-05-13 01:32:58 +03:00
// set timeout in nanoseconds
msg.Header["Timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
// set the content type for the request
2015-12-17 23:37:35 +03:00
msg.Header["Content-Type"] = req.ContentType()
// set the accept header
msg.Header["Accept"] = req.ContentType()
2015-01-14 02:31:27 +03:00
2019-01-18 15:30:39 +03:00
// set old codecs
cf := setupProtocol(msg, node)
// no codec specified
if cf == nil {
var err error
cf, err = r.newCodec(req.ContentType())
if err != nil {
return nil, errors.InternalServerError("go.micro.client", err.Error())
}
2015-11-25 22:50:05 +03:00
}
2018-07-18 02:32:35 +03:00
dOpts := []transport.DialOption{
transport.WithStream(),
}
if opts.DialTimeout >= 0 {
dOpts = append(dOpts, transport.WithTimeout(opts.DialTimeout))
}
2019-08-16 18:46:29 +03:00
c, err := r.pool.Get(address, dOpts...)
2015-01-14 02:31:27 +03:00
if err != nil {
2017-06-11 15:02:08 +03:00
return nil, errors.InternalServerError("go.micro.client", "connection error: %v", err)
2015-01-14 02:31:27 +03:00
}
2019-08-15 22:08:49 +03:00
// increment the sequence number
seq := atomic.LoadUint64(&r.seq)
atomic.AddUint64(&r.seq, 1)
id := fmt.Sprintf("%v", seq)
// create codec with stream id
codec := newRpcCodec(msg, c, cf, id)
2019-01-15 00:30:43 +03:00
rsp := &rpcResponse{
socket: c,
codec: codec,
}
2019-01-30 21:42:11 +03:00
// set request codec
if r, ok := req.(*rpcRequest); ok {
r.codec = codec
}
2015-12-18 04:21:56 +03:00
stream := &rpcStream{
2019-08-16 18:46:29 +03:00
id: id,
2019-01-15 00:30:43 +03:00
context: ctx,
request: req,
response: rsp,
2019-01-30 21:42:11 +03:00
codec: codec,
2019-08-16 18:46:29 +03:00
// used to close the stream
closed: make(chan bool),
2019-08-15 22:08:49 +03:00
// signal the end of stream,
sendEOS: true,
2019-08-16 18:46:29 +03:00
// release func
release: func(err error) { r.pool.Release(c, err) },
2015-12-18 04:21:56 +03:00
}
2019-08-16 18:46:29 +03:00
// wait for error response
2016-01-04 00:14:33 +03:00
ch := make(chan error, 1)
go func() {
2019-08-16 18:46:29 +03:00
// send the first message
2019-01-10 14:39:39 +03:00
ch <- stream.Send(req.Body())
2016-01-04 00:14:33 +03:00
}()
2016-05-13 01:32:58 +03:00
var grr error
2016-01-04 00:14:33 +03:00
select {
2016-05-13 01:32:58 +03:00
case err := <-ch:
grr = err
case <-ctx.Done():
2018-11-25 12:41:28 +03:00
grr = errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
2016-01-04 00:14:33 +03:00
}
2016-05-13 01:32:58 +03:00
if grr != nil {
2019-08-16 18:46:29 +03:00
// set the error
stream.Lock()
stream.err = grr
stream.Unlock()
// close the stream
2016-05-13 01:32:58 +03:00
stream.Close()
return nil, grr
}
return stream, nil
2015-01-14 02:31:27 +03:00
}
2016-01-02 22:12:17 +03:00
func (r *rpcClient) Init(opts ...Option) error {
2016-06-07 02:46:14 +03:00
size := r.opts.PoolSize
ttl := r.opts.PoolTTL
2019-07-28 20:56:18 +03:00
tr := r.opts.Transport
2016-06-07 02:46:14 +03:00
2016-01-02 22:12:17 +03:00
for _, o := range opts {
o(&r.opts)
}
2016-06-07 02:46:14 +03:00
// update pool configuration if the options changed
2019-07-28 20:56:18 +03:00
if size != r.opts.PoolSize || ttl != r.opts.PoolTTL || tr != r.opts.Transport {
// close existing pool
r.pool.Close()
// create new pool
r.pool = pool.NewPool(
pool.Size(r.opts.PoolSize),
pool.TTL(r.opts.PoolTTL),
pool.Transport(r.opts.Transport),
)
2016-06-07 02:46:14 +03:00
}
2016-01-02 22:12:17 +03:00
return nil
}
func (r *rpcClient) Options() Options {
return r.opts
}
2018-04-14 18:16:58 +03:00
func (r *rpcClient) next(request Request, opts CallOptions) (selector.Next, error) {
2019-01-30 21:42:11 +03:00
service := request.Service()
// get proxy
if prx := os.Getenv("MICRO_PROXY"); len(prx) > 0 {
service = prx
}
// get proxy address
if prx := os.Getenv("MICRO_PROXY_ADDRESS"); len(prx) > 0 {
2019-06-26 22:51:13 +03:00
opts.Address = []string{prx}
2019-01-30 21:42:11 +03:00
}
2018-04-14 18:16:58 +03:00
// return remote address
if len(opts.Address) > 0 {
nodes := make([]*registry.Node, len(opts.Address))
2019-01-18 15:30:39 +03:00
for i, address := range opts.Address {
nodes[i] = &registry.Node{
2019-01-18 15:30:39 +03:00
Address: address,
// Set the protocol
Metadata: map[string]string{
"protocol": "mucp",
},
}
2019-06-26 22:51:13 +03:00
}
// crude return method
return func() (*registry.Node, error) {
return nodes[time.Now().Unix()%int64(len(nodes))], nil
2018-04-14 18:16:58 +03:00
}, nil
}
// get next nodes from the selector
2019-01-30 21:42:11 +03:00
next, err := r.opts.Selector.Select(service, opts.SelectOptions...)
if err != nil {
if err == selector.ErrNotFound {
return nil, errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
}
return nil, errors.InternalServerError("go.micro.client", "error selecting %s node: %s", service, err.Error())
}
2018-04-14 18:16:58 +03:00
return next, nil
2015-01-14 02:31:27 +03:00
}
2015-12-08 22:25:42 +03:00
func (r *rpcClient) Call(ctx context.Context, request Request, response interface{}, opts ...CallOption) error {
// make a copy of call opts
callOpts := r.opts.CallOptions
2015-12-09 03:02:45 +03:00
for _, opt := range opts {
opt(&callOpts)
2015-12-09 03:02:45 +03:00
}
2018-04-14 18:16:58 +03:00
next, err := r.next(request, callOpts)
if err != nil {
return err
2015-12-09 03:02:45 +03:00
}
2016-05-13 01:32:58 +03:00
// check if we already have a deadline
d, ok := ctx.Deadline()
if !ok {
// no deadline so we create a new one
ctx, _ = context.WithTimeout(ctx, callOpts.RequestTimeout)
} else {
// got a deadline so no need to setup context
// but we need to set the timeout we pass along
opt := WithRequestTimeout(d.Sub(time.Now()))
opt(&callOpts)
}
2016-01-04 00:14:33 +03:00
// should we noop right here?
select {
case <-ctx.Done():
2018-11-25 12:41:28 +03:00
return errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
default:
}
// make copy of call method
rcall := r.call
// wrap the call in reverse
for i := len(callOpts.CallWrappers); i > 0; i-- {
rcall = callOpts.CallWrappers[i-1](rcall)
}
2016-05-13 01:32:58 +03:00
// return errors.New("go.micro.client", "request timeout", 408)
call := func(i int) error {
2016-04-05 22:04:37 +03:00
// call backoff first. Someone may want an initial start delay
t, err := callOpts.Backoff(ctx, request, i)
if err != nil {
2018-07-26 11:33:50 +03:00
return errors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
2016-04-05 22:04:37 +03:00
}
// only sleep if greater than 0
if t.Seconds() > 0 {
time.Sleep(t)
}
2016-05-13 01:32:58 +03:00
// select next node
2016-01-03 02:16:15 +03:00
node, err := next()
service := request.Service()
if err != nil {
if err == selector.ErrNotFound {
return errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
}
return errors.InternalServerError("go.micro.client", "error getting next %s node: %s", service, err.Error())
2016-01-03 02:16:15 +03:00
}
2016-05-13 01:32:58 +03:00
// make the call
2019-01-18 15:30:39 +03:00
err = rcall(ctx, node, request, response, callOpts)
r.opts.Selector.Mark(service, node, err)
2016-05-13 01:32:58 +03:00
return err
}
ch := make(chan error, callOpts.Retries+1)
2016-05-13 01:32:58 +03:00
var gerr error
2015-01-14 02:31:27 +03:00
for i := 0; i <= callOpts.Retries; i++ {
go func(i int) {
2016-05-13 01:32:58 +03:00
ch <- call(i)
}(i)
2016-05-13 01:32:58 +03:00
select {
case <-ctx.Done():
2018-11-25 12:41:28 +03:00
return errors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
2016-05-13 01:32:58 +03:00
case err := <-ch:
// if the call succeeded lets bail early
if err == nil {
return nil
}
retry, rerr := callOpts.Retry(ctx, request, i, err)
if rerr != nil {
return rerr
}
if !retry {
return err
}
2016-05-13 01:32:58 +03:00
gerr = err
2016-01-03 02:16:15 +03:00
}
2015-05-21 21:24:57 +03:00
}
2016-05-13 01:32:58 +03:00
return gerr
2015-01-14 02:31:27 +03:00
}
2018-04-14 20:15:09 +03:00
func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOption) (Stream, error) {
// make a copy of call opts
callOpts := r.opts.CallOptions
2015-12-09 03:02:45 +03:00
for _, opt := range opts {
opt(&callOpts)
2015-12-09 03:02:45 +03:00
}
2018-04-14 18:16:58 +03:00
next, err := r.next(request, callOpts)
if err != nil {
return nil, err
2015-12-09 03:02:45 +03:00
}
// should we noop right here?
select {
case <-ctx.Done():
2018-11-25 12:41:28 +03:00
return nil, errors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
default:
}
2018-04-14 20:15:09 +03:00
call := func(i int) (Stream, error) {
2016-04-05 22:04:37 +03:00
// call backoff first. Someone may want an initial start delay
t, err := callOpts.Backoff(ctx, request, i)
if err != nil {
2018-07-26 11:33:50 +03:00
return nil, errors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
2016-04-05 22:04:37 +03:00
}
// only sleep if greater than 0
if t.Seconds() > 0 {
time.Sleep(t)
}
2016-01-03 02:16:15 +03:00
node, err := next()
service := request.Service()
if err != nil {
if err == selector.ErrNotFound {
return nil, errors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
}
return nil, errors.InternalServerError("go.micro.client", "error getting next %s node: %s", service, err.Error())
2016-01-03 02:16:15 +03:00
}
2019-01-18 15:30:39 +03:00
stream, err := r.stream(ctx, node, request, callOpts)
r.opts.Selector.Mark(service, node, err)
2016-05-13 01:32:58 +03:00
return stream, err
}
type response struct {
2018-04-14 20:15:09 +03:00
stream Stream
2016-05-13 01:32:58 +03:00
err error
}
2016-01-03 02:16:15 +03:00
ch := make(chan response, callOpts.Retries+1)
2016-05-13 01:32:58 +03:00
var grr error
for i := 0; i <= callOpts.Retries; i++ {
go func(i int) {
2016-05-13 01:32:58 +03:00
s, err := call(i)
ch <- response{s, err}
}(i)
2016-05-13 01:32:58 +03:00
select {
case <-ctx.Done():
2018-11-25 12:41:28 +03:00
return nil, errors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
2016-05-13 01:32:58 +03:00
case rsp := <-ch:
// if the call succeeded lets bail early
if rsp.err == nil {
return rsp.stream, nil
}
retry, rerr := callOpts.Retry(ctx, request, i, rsp.err)
if rerr != nil {
return nil, rerr
}
if !retry {
return nil, rsp.err
}
2016-11-07 19:46:12 +03:00
grr = rsp.err
2016-01-03 02:16:15 +03:00
}
}
2016-05-13 01:32:58 +03:00
return nil, grr
}
2018-04-14 20:06:52 +03:00
func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOption) error {
2019-02-23 13:50:53 +03:00
options := PublishOptions{
Context: context.Background(),
}
for _, o := range opts {
o(&options)
}
2016-01-28 20:55:28 +03:00
md, ok := metadata.FromContext(ctx)
if !ok {
md = make(map[string]string)
}
2019-01-10 23:35:10 +03:00
id := uuid.New().String()
2018-04-14 20:06:52 +03:00
md["Content-Type"] = msg.ContentType()
2019-01-24 13:11:02 +03:00
md["Micro-Topic"] = msg.Topic()
md["Micro-Id"] = id
2019-02-23 20:06:17 +03:00
// set the topic
2019-02-23 13:50:53 +03:00
topic := msg.Topic()
2019-02-23 20:06:17 +03:00
// get proxy
if prx := os.Getenv("MICRO_PROXY"); len(prx) > 0 {
options.Exchange = prx
}
// get the exchange
2019-02-23 13:50:53 +03:00
if len(options.Exchange) > 0 {
topic = options.Exchange
}
// encode message body
2018-04-14 20:06:52 +03:00
cf, err := r.newCodec(msg.ContentType())
if err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
// new buffer
b := buf.New(nil)
2019-01-10 23:35:10 +03:00
if err := cf(b).Write(&codec.Message{
2019-02-23 13:50:53 +03:00
Target: topic,
2019-07-07 14:44:09 +03:00
Type: codec.Event,
2019-01-10 23:35:10 +03:00
Header: map[string]string{
2019-01-24 13:11:02 +03:00
"Micro-Id": id,
"Micro-Topic": msg.Topic(),
2019-01-10 23:35:10 +03:00
},
}, msg.Payload()); err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
r.once.Do(func() {
r.opts.Broker.Connect()
})
2019-02-23 13:50:53 +03:00
return r.opts.Broker.Publish(topic, &broker.Message{
Header: md,
Body: b.Bytes(),
})
}
2018-05-10 19:33:54 +03:00
func (r *rpcClient) NewMessage(topic string, message interface{}, opts ...MessageOption) Message {
return newMessage(topic, message, r.opts.ContentType, opts...)
}
2015-12-17 23:37:35 +03:00
func (r *rpcClient) NewRequest(service, method string, request interface{}, reqOpts ...RequestOption) Request {
2018-04-14 20:06:52 +03:00
return newRequest(service, method, request, r.opts.ContentType, reqOpts...)
2015-01-14 02:31:27 +03:00
}
2015-12-20 00:56:14 +03:00
func (r *rpcClient) String() string {
2019-06-08 21:40:44 +03:00
return "mucp"
2015-12-20 00:56:14 +03:00
}