micro/client/rpc_client.go

314 lines
7.5 KiB
Go
Raw Normal View History

2015-01-14 02:31:27 +03:00
package client
import (
"bytes"
2015-01-14 02:31:27 +03:00
"fmt"
"sync"
2016-01-04 00:14:33 +03:00
"time"
2015-01-14 02:31:27 +03:00
2015-11-20 19:17:33 +03:00
"github.com/micro/go-micro/broker"
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"
2015-12-09 22:23:16 +03:00
"github.com/micro/go-micro/selector"
2015-11-20 19:17:33 +03:00
"github.com/micro/go-micro/transport"
2015-05-23 13:53:40 +03:00
"golang.org/x/net/context"
2015-01-14 02:31:27 +03:00
)
2015-05-23 19:40:53 +03:00
type rpcClient struct {
once sync.Once
opts Options
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 {
2015-11-26 23:36:42 +03:00
var once sync.Once
2016-01-03 02:16:15 +03:00
opts := newOptions(opt...)
2015-11-26 23:36:42 +03:00
rc := &rpcClient{
once: once,
2015-05-23 19:40:53 +03:00
opts: opts,
}
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 {
return cf, nil
}
return nil, fmt.Errorf("Unsupported Content-Type: %s", contentType)
}
2016-01-06 00:13:20 +03:00
func (r *rpcClient) call(ctx context.Context, address string, req Request, resp interface{}) error {
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-01-06 00:13:20 +03:00
msg.Header["Content-Type"] = req.ContentType()
2015-05-21 00:57:19 +03:00
2016-01-06 00:13:20 +03:00
cf, err := r.newCodec(req.ContentType())
2015-11-25 22:50:05 +03:00
if err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
2016-01-04 00:25:03 +03:00
c, err := r.opts.Transport.Dial(address, transport.WithTimeout(r.opts.DialTimeout))
2015-01-14 02:31:27 +03:00
if err != nil {
return errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
}
2016-01-06 00:13:20 +03:00
var once sync.Once
stream := &rpcStream{
context: ctx,
request: req,
once: once,
closed: make(chan bool),
codec: newRpcPlusCodec(msg, c, cf),
}
2016-01-04 00:14:33 +03:00
ch := make(chan error, 1)
go func() {
2016-01-06 00:13:20 +03:00
// defer stream close
defer stream.Close()
// send request
if err := stream.Send(req.Request()); err != nil {
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
}()
select {
case err = <-ch:
case <-time.After(r.opts.RequestTimeout):
err = errors.New("go.micro.client", "request timeout", 408)
2015-10-22 17:14:56 +03:00
}
2016-01-04 00:14:33 +03:00
return err
}
2015-01-14 02:31:27 +03:00
2015-12-17 23:37:35 +03:00
func (r *rpcClient) stream(ctx context.Context, address string, req Request) (Streamer, error) {
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
}
2015-12-17 23:37:35 +03:00
msg.Header["Content-Type"] = req.ContentType()
2015-01-14 02:31:27 +03:00
2015-12-17 23:37:35 +03:00
cf, err := r.newCodec(req.ContentType())
2015-11-25 22:50:05 +03:00
if err != nil {
return nil, errors.InternalServerError("go.micro.client", err.Error())
}
2016-01-04 00:25:03 +03:00
c, err := r.opts.Transport.Dial(address, transport.WithStream(), transport.WithTimeout(r.opts.DialTimeout))
2015-01-14 02:31:27 +03:00
if err != nil {
return nil, errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
2015-01-14 02:31:27 +03:00
}
var once sync.Once
2015-12-18 04:21:56 +03:00
stream := &rpcStream{
2015-12-17 23:37:35 +03:00
context: ctx,
request: req,
once: once,
closed: make(chan bool),
2015-12-18 04:21:56 +03:00
codec: newRpcPlusCodec(msg, c, cf),
}
2016-01-04 00:14:33 +03:00
ch := make(chan error, 1)
go func() {
2016-01-06 00:13:20 +03:00
ch <- stream.Send(req.Request())
2016-01-04 00:14:33 +03:00
}()
select {
case err = <-ch:
case <-time.After(r.opts.RequestTimeout):
err = errors.New("go.micro.client", "request timeout", 408)
}
2015-12-18 04:21:56 +03:00
return stream, err
2015-01-14 02:31:27 +03:00
}
2016-01-02 22:12:17 +03:00
func (r *rpcClient) Init(opts ...Option) error {
for _, o := range opts {
o(&r.opts)
}
return nil
}
func (r *rpcClient) Options() Options {
return r.opts
}
2015-12-08 22:25:42 +03:00
func (r *rpcClient) CallRemote(ctx context.Context, address string, request Request, response interface{}, opts ...CallOption) error {
2015-05-23 13:53:40 +03:00
return r.call(ctx, address, request, response)
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 {
var copts CallOptions
2015-12-09 03:02:45 +03:00
for _, opt := range opts {
opt(&copts)
}
next, err := r.opts.Selector.Select(request.Service(), copts.SelectOptions...)
2015-12-09 22:23:16 +03:00
if err != nil && err == selector.ErrNotFound {
2015-12-09 15:44:28 +03:00
return errors.NotFound("go.micro.client", err.Error())
} else if err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
2015-12-09 03:02:45 +03:00
}
2016-01-04 00:14:33 +03:00
var grr error
2016-01-03 02:16:15 +03:00
for i := 0; i < r.opts.Retries; i++ {
node, err := next()
if err != nil && err == selector.ErrNotFound {
return errors.NotFound("go.micro.client", err.Error())
} else if err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
address := node.Address
if node.Port > 0 {
address = fmt.Sprintf("%s:%d", address, node.Port)
}
2016-01-04 00:14:33 +03:00
grr = r.call(ctx, address, request, response)
r.opts.Selector.Mark(request.Service(), node, grr)
2015-01-14 02:31:27 +03:00
2016-01-03 02:16:15 +03:00
// if the call succeeded lets bail early
2016-01-04 00:14:33 +03:00
if grr == nil {
2016-01-03 02:16:15 +03:00
return nil
}
2015-05-21 21:24:57 +03:00
}
2016-01-04 00:14:33 +03:00
return grr
2015-01-14 02:31:27 +03:00
}
2015-12-17 23:37:35 +03:00
func (r *rpcClient) StreamRemote(ctx context.Context, address string, request Request, opts ...CallOption) (Streamer, error) {
return r.stream(ctx, address, request)
}
2015-12-17 23:37:35 +03:00
func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOption) (Streamer, error) {
var copts CallOptions
2015-12-09 03:02:45 +03:00
for _, opt := range opts {
opt(&copts)
}
next, err := r.opts.Selector.Select(request.Service(), copts.SelectOptions...)
2015-12-09 22:23:16 +03:00
if err != nil && err == selector.ErrNotFound {
2015-12-09 15:44:28 +03:00
return nil, errors.NotFound("go.micro.client", err.Error())
} else if err != nil {
return nil, errors.InternalServerError("go.micro.client", err.Error())
2015-12-09 03:02:45 +03:00
}
2016-01-03 02:16:15 +03:00
var stream Streamer
2016-01-04 00:14:33 +03:00
var grr error
2016-01-03 02:16:15 +03:00
for i := 0; i < r.opts.Retries; i++ {
node, err := next()
if err != nil && err == selector.ErrNotFound {
return nil, errors.NotFound("go.micro.client", err.Error())
} else if err != nil {
return nil, errors.InternalServerError("go.micro.client", err.Error())
}
2016-01-03 02:16:15 +03:00
address := node.Address
if node.Port > 0 {
address = fmt.Sprintf("%s:%d", address, node.Port)
}
2016-01-04 00:14:33 +03:00
stream, grr = r.stream(ctx, address, request)
r.opts.Selector.Mark(request.Service(), node, grr)
2016-01-03 02:16:15 +03:00
// bail early if succeeds
2016-01-04 00:14:33 +03:00
if grr == nil {
2016-01-03 02:16:15 +03:00
return stream, nil
}
}
2016-01-04 00:14:33 +03:00
return stream, grr
}
2015-12-08 22:25:42 +03:00
func (r *rpcClient) Publish(ctx context.Context, p Publication, opts ...PublishOption) error {
2016-01-28 20:55:28 +03:00
md, ok := metadata.FromContext(ctx)
if !ok {
md = make(map[string]string)
}
md["Content-Type"] = p.ContentType()
// encode message body
cf, err := r.newCodec(p.ContentType())
if err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
b := &buffer{bytes.NewBuffer(nil)}
if err := cf(b).Write(&codec.Message{Type: codec.Publication}, p.Message()); err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
r.once.Do(func() {
r.opts.Broker.Connect()
})
return r.opts.Broker.Publish(p.Topic(), &broker.Message{
Header: md,
Body: b.Bytes(),
})
}
func (r *rpcClient) NewPublication(topic string, message interface{}) Publication {
return newRpcPublication(topic, message, r.opts.ContentType)
}
func (r *rpcClient) NewProtoPublication(topic string, message interface{}) Publication {
return newRpcPublication(topic, message, "application/octet-stream")
}
2015-12-17 23:37:35 +03:00
func (r *rpcClient) NewRequest(service, method string, request interface{}, reqOpts ...RequestOption) Request {
return newRpcRequest(service, method, request, r.opts.ContentType, reqOpts...)
2015-01-14 02:31:27 +03:00
}
2015-12-17 23:37:35 +03:00
func (r *rpcClient) NewProtoRequest(service, method string, request interface{}, reqOpts ...RequestOption) Request {
return newRpcRequest(service, method, request, "application/octet-stream", reqOpts...)
2015-01-14 02:31:27 +03:00
}
2015-12-17 23:37:35 +03:00
func (r *rpcClient) NewJsonRequest(service, method string, request interface{}, reqOpts ...RequestOption) Request {
return newRpcRequest(service, method, request, "application/json", reqOpts...)
2015-01-14 02:31:27 +03:00
}
2015-12-20 00:56:14 +03:00
func (r *rpcClient) String() string {
return "rpc"
}