chore: import upstream snapshot with attribution

client/backoff.go

@@ -0,0 +1,14 @@
+package client
+
+import (
+	"context"
+	"time"
+
+	"go-micro.dev/v6/internal/util/backoff"
+)
+
+type BackoffFunc func(ctx context.Context, req Request, attempts int) (time.Duration, error)
+
+func exponentialBackoff(ctx context.Context, req Request, attempts int) (time.Duration, error) {
+	return backoff.Do(attempts), nil
+}

client/backoff_test.go

@@ -0,0 +1,31 @@
+package client
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestBackoff(t *testing.T) {
+	results := []time.Duration{
+		0 * time.Second,
+		100 * time.Millisecond,
+		600 * time.Millisecond,
+		1900 * time.Millisecond,
+		4300 * time.Millisecond,
+		7900 * time.Millisecond,
+	}
+
+	c := NewClient()
+
+	for i := 0; i < 5; i++ {
+		d, err := exponentialBackoff(context.TODO(), c.NewRequest("test", "test", nil), i)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if d != results[i] {
+			t.Fatalf("Expected equal than %v, got %v", results[i], d)
+		}
+	}
+}

client/cache.go

@@ -0,0 +1,70 @@
+package client
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"hash/fnv"
+	"time"
+
+	cache "github.com/patrickmn/go-cache"
+
+	"go-micro.dev/v6/metadata"
+	"go-micro.dev/v6/transport/headers"
+)
+
+// NewCache returns an initialized cache.
+func NewCache() *Cache {
+	return &Cache{
+		cache: cache.New(cache.NoExpiration, 30*time.Second),
+	}
+}
+
+// Cache for responses.
+type Cache struct {
+	cache *cache.Cache
+}
+
+// Get a response from the cache.
+func (c *Cache) Get(ctx context.Context, req *Request) (interface{}, bool) {
+	return c.cache.Get(key(ctx, req))
+}
+
+// Set a response in the cache.
+func (c *Cache) Set(ctx context.Context, req *Request, rsp interface{}, expiry time.Duration) {
+	c.cache.Set(key(ctx, req), rsp, expiry)
+}
+
+// List the key value pairs in the cache.
+func (c *Cache) List() map[string]string {
+	items := c.cache.Items()
+
+	rsp := make(map[string]string, len(items))
+
+	for k, v := range items {
+		bytes, _ := json.Marshal(v.Object)
+		rsp[k] = string(bytes)
+	}
+
+	return rsp
+}
+
+// key returns a hash for the context and request.
+func key(ctx context.Context, req *Request) string {
+	ns, _ := metadata.Get(ctx, headers.Namespace)
+
+	bytes, _ := json.Marshal(map[string]interface{}{
+		"namespace": ns,
+		"request": map[string]interface{}{
+			"service":  (*req).Service(),
+			"endpoint": (*req).Endpoint(),
+			"method":   (*req).Method(),
+			"body":     (*req).Body(),
+		},
+	})
+
+	h := fnv.New64()
+	h.Write(bytes)
+
+	return fmt.Sprintf("%x", h.Sum(nil))
+}

client/cache_test.go

@@ -0,0 +1,77 @@
+package client
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"go-micro.dev/v6/metadata"
+	"go-micro.dev/v6/transport/headers"
+)
+
+func TestCache(t *testing.T) {
+	ctx := context.TODO()
+	req := NewRequest("go.micro.service.foo", "Foo.Bar", nil)
+
+	t.Run("CacheMiss", func(t *testing.T) {
+		if _, ok := NewCache().Get(ctx, &req); ok {
+			t.Errorf("Expected to get no result from Get")
+		}
+	})
+
+	t.Run("CacheHit", func(t *testing.T) {
+		c := NewCache()
+
+		rsp := "theresponse"
+		c.Set(ctx, &req, rsp, time.Minute)
+
+		if res, ok := c.Get(ctx, &req); !ok {
+			t.Errorf("Expected a result, got nothing")
+		} else if res != rsp {
+			t.Errorf("Expected '%v' result, got '%v'", rsp, res)
+		}
+	})
+}
+
+func TestCacheKey(t *testing.T) {
+	ctx := context.TODO()
+	req1 := NewRequest("go.micro.service.foo", "Foo.Bar", nil)
+	req2 := NewRequest("go.micro.service.foo", "Foo.Baz", nil)
+	req3 := NewRequest("go.micro.service.foo", "Foo.Baz", "customquery")
+
+	t.Run("IdenticalRequests", func(t *testing.T) {
+		key1 := key(ctx, &req1)
+		key2 := key(ctx, &req1)
+		if key1 != key2 {
+			t.Errorf("Expected the keys to match for identical requests and context")
+		}
+	})
+
+	t.Run("DifferentRequestEndpoints", func(t *testing.T) {
+		key1 := key(ctx, &req1)
+		key2 := key(ctx, &req2)
+
+		if key1 == key2 {
+			t.Errorf("Expected the keys to differ for different request endpoints")
+		}
+	})
+
+	t.Run("DifferentRequestBody", func(t *testing.T) {
+		key1 := key(ctx, &req2)
+		key2 := key(ctx, &req3)
+
+		if key1 == key2 {
+			t.Errorf("Expected the keys to differ for different request bodies")
+		}
+	})
+
+	t.Run("DifferentMetadata", func(t *testing.T) {
+		mdCtx := metadata.Set(context.TODO(), headers.Namespace, "bar")
+		key1 := key(mdCtx, &req1)
+		key2 := key(ctx, &req1)
+
+		if key1 == key2 {
+			t.Errorf("Expected the keys to differ for different metadata")
+		}
+	})
+}

client/client.go

@@ -0,0 +1,141 @@
+// Package client is an interface for an RPC client
+package client
+
+import (
+	"context"
+
+	"go-micro.dev/v6/codec"
+)
+
+var (
+	// NewClient returns a new client.
+	NewClient func(...Option) Client = newRPCClient
+	// DefaultClient is a default client to use out of the box.
+	DefaultClient Client = newRPCClient()
+)
+
+// Client is the interface used to make requests to services.
+// It supports Request/Response via Transport and Publishing via the Broker.
+// It also supports bidirectional streaming of requests.
+type Client interface {
+	Init(...Option) error
+	Options() Options
+	NewMessage(topic string, msg interface{}, opts ...MessageOption) Message
+	NewRequest(service, endpoint string, req interface{}, reqOpts ...RequestOption) Request
+	Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
+	Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
+	Publish(ctx context.Context, msg Message, opts ...PublishOption) error
+	String() string
+}
+
+// Router manages request routing.
+type Router interface {
+	SendRequest(context.Context, Request) (Response, error)
+}
+
+// Message is the interface for publishing asynchronously.
+type Message interface {
+	Topic() string
+	Payload() interface{}
+	ContentType() string
+}
+
+// Request is the interface for a synchronous request used by Call or Stream.
+type Request interface {
+	// The service to call
+	Service() string
+	// The action to take
+	Method() string
+	// The endpoint to invoke
+	Endpoint() string
+	// The content type
+	ContentType() string
+	// The unencoded request body
+	Body() interface{}
+	// Write to the encoded request writer. This is nil before a call is made
+	Codec() codec.Writer
+	// indicates whether the request will be a streaming one rather than unary
+	Stream() bool
+}
+
+// Response is the response received from a service.
+type Response interface {
+	// Read the response
+	Codec() codec.Reader
+	// read the header
+	Header() map[string]string
+	// Read the undecoded response
+	Read() ([]byte, error)
+}
+
+// Stream is the inteface for a bidirectional synchronous stream.
+type Stream interface {
+	Closer
+	// Context for the stream
+	Context() context.Context
+	// The request made
+	Request() Request
+	// The response read
+	Response() Response
+	// Send will encode and send a request
+	Send(interface{}) error
+	// Recv will decode and read a response
+	Recv(interface{}) error
+	// Error returns the stream error
+	Error() error
+	// Close closes the stream
+	Close() error
+}
+
+// Closer handle client close.
+type Closer interface {
+	// CloseSend closes the send direction of the stream.
+	CloseSend() error
+}
+
+// Option used by the Client.
+type Option func(*Options)
+
+// CallOption used by Call or Stream.
+type CallOption func(*CallOptions)
+
+// PublishOption used by Publish.
+type PublishOption func(*PublishOptions)
+
+// MessageOption used by NewMessage.
+type MessageOption func(*MessageOptions)
+
+// RequestOption used by NewRequest.
+type RequestOption func(*RequestOptions)
+
+// Makes a synchronous call to a service using the default client.
+func Call(ctx context.Context, request Request, response interface{}, opts ...CallOption) error {
+	return DefaultClient.Call(ctx, request, response, opts...)
+}
+
+// Publishes a publication using the default client. Using the underlying broker
+// set within the options.
+func Publish(ctx context.Context, msg Message, opts ...PublishOption) error {
+	return DefaultClient.Publish(ctx, msg, opts...)
+}
+
+// Creates a new message using the default client.
+func NewMessage(topic string, payload interface{}, opts ...MessageOption) Message {
+	return DefaultClient.NewMessage(topic, payload, opts...)
+}
+
+// Creates a new request using the default client. Content Type will
+// be set to the default within options and use the appropriate codec.
+func NewRequest(service, endpoint string, request interface{}, reqOpts ...RequestOption) Request {
+	return DefaultClient.NewRequest(service, endpoint, request, reqOpts...)
+}
+
+// Creates a streaming connection with a service and returns responses on the
+// channel passed in. It's up to the user to close the streamer.
+func NewStream(ctx context.Context, request Request, opts ...CallOption) (Stream, error) {
+	return DefaultClient.Stream(ctx, request, opts...)
+}
+
+func String() string {
+	return DefaultClient.String()
+}

client/common_test.go

@@ -0,0 +1,59 @@
+package client
+
+import (
+	"go-micro.dev/v6/registry"
+)
+
+var (
+	// mock data.
+	testData = map[string][]*registry.Service{
+		"foo": {
+			{
+				Name:    "foo",
+				Version: "1.0.0",
+				Nodes: []*registry.Node{
+					{
+						Id:      "foo-1.0.0-123",
+						Address: "localhost:9999",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
+					},
+					{
+						Id:      "foo-1.0.0-321",
+						Address: "localhost:9999",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
+					},
+				},
+			},
+			{
+				Name:    "foo",
+				Version: "1.0.1",
+				Nodes: []*registry.Node{
+					{
+						Id:      "foo-1.0.1-321",
+						Address: "localhost:6666",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
+					},
+				},
+			},
+			{
+				Name:    "foo",
+				Version: "1.0.3",
+				Nodes: []*registry.Node{
+					{
+						Id:      "foo-1.0.3-345",
+						Address: "localhost:8888",
+						Metadata: map[string]string{
+							"protocol": "mucp",
+						},
+					},
+				},
+			},
+		},
+	}
+)

client/context.go

@@ -0,0 +1,16 @@
+package client
+
+import (
+	"context"
+)
+
+type clientKey struct{}
+
+func FromContext(ctx context.Context) (Client, bool) {
+	c, ok := ctx.Value(clientKey{}).(Client)
+	return c, ok
+}
+
+func NewContext(ctx context.Context, c Client) context.Context {
+	return context.WithValue(ctx, clientKey{}, c)
+}

client/grpc/codec.go

@@ -0,0 +1,209 @@
+package grpc
+
+import (
+	b "bytes"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"go-micro.dev/v6/codec"
+	"go-micro.dev/v6/codec/bytes"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/encoding"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/runtime/protoiface"
+	"google.golang.org/protobuf/runtime/protoimpl"
+)
+
+type jsonCodec struct{}
+type protoCodec struct{}
+type bytesCodec struct{}
+type wrapCodec struct{ encoding.Codec }
+
+var useNumber bool
+
+var (
+	defaultGRPCCodecs = map[string]encoding.Codec{
+		"application/json":         jsonCodec{},
+		"application/proto":        protoCodec{},
+		"application/protobuf":     protoCodec{},
+		"application/octet-stream": protoCodec{},
+		"application/grpc":         protoCodec{},
+		"application/grpc+json":    jsonCodec{},
+		"application/grpc+proto":   protoCodec{},
+		"application/grpc+bytes":   bytesCodec{},
+	}
+)
+
+// UseNumber fix unmarshal Number(8234567890123456789) to interface(8.234567890123457e+18).
+func UseNumber() {
+	useNumber = true
+}
+
+func (w wrapCodec) String() string {
+	return w.Name()
+}
+
+func (w wrapCodec) Marshal(v interface{}) ([]byte, error) {
+	b, ok := v.(*bytes.Frame)
+	if ok {
+		return b.Data, nil
+	}
+	return w.Codec.Marshal(v)
+}
+
+func (w wrapCodec) Unmarshal(data []byte, v interface{}) error {
+	b, ok := v.(*bytes.Frame)
+	if ok {
+		b.Data = data
+		return nil
+	}
+	return w.Codec.Unmarshal(data, v)
+}
+
+func (protoCodec) Marshal(v interface{}) ([]byte, error) {
+	switch m := v.(type) {
+	case *bytes.Frame:
+		return m.Data, nil
+	case proto.Message:
+		return proto.Marshal(m)
+	case protoiface.MessageV1:
+		// #2333 compatible with etcd legacy proto.Message
+		m2 := protoimpl.X.ProtoMessageV2Of(m)
+		return proto.Marshal(m2)
+	}
+	return nil, fmt.Errorf("failed to marshal: %v is not type of *bytes.Frame or proto.Message", v)
+}
+
+func (protoCodec) Unmarshal(data []byte, v interface{}) error {
+	switch m := v.(type) {
+	case proto.Message:
+		return proto.Unmarshal(data, m)
+	case protoiface.MessageV1:
+		// #2333 compatible with etcd legacy proto.Message
+		m2 := protoimpl.X.ProtoMessageV2Of(m)
+		return proto.Unmarshal(data, m2)
+	}
+	return fmt.Errorf("failed to unmarshal: %v is not type of proto.Message", v)
+}
+
+func (protoCodec) Name() string {
+	return "proto"
+}
+
+func (bytesCodec) Marshal(v interface{}) ([]byte, error) {
+	b, ok := v.(*[]byte)
+	if !ok {
+		return nil, fmt.Errorf("failed to marshal: %v is not type of *[]byte", v)
+	}
+	return *b, nil
+}
+
+func (bytesCodec) Unmarshal(data []byte, v interface{}) error {
+	b, ok := v.(*[]byte)
+	if !ok {
+		return fmt.Errorf("failed to unmarshal: %v is not type of *[]byte", v)
+	}
+	*b = data
+	return nil
+}
+
+func (bytesCodec) Name() string {
+	return "bytes"
+}
+
+func (jsonCodec) Marshal(v interface{}) ([]byte, error) {
+	if b, ok := v.(*bytes.Frame); ok {
+		return b.Data, nil
+	}
+
+	if pb, ok := v.(proto.Message); ok {
+		bytes, err := protojson.Marshal(pb)
+		if err != nil {
+			return nil, err
+		}
+		return bytes, nil
+	}
+
+	return json.Marshal(v)
+}
+
+func (jsonCodec) Unmarshal(data []byte, v interface{}) error {
+	if len(data) == 0 {
+		return nil
+	}
+	if b, ok := v.(*bytes.Frame); ok {
+		b.Data = data
+		return nil
+	}
+	if pb, ok := v.(proto.Message); ok {
+		return protojson.Unmarshal(data, pb)
+	}
+
+	dec := json.NewDecoder(b.NewReader(data))
+	if useNumber {
+		dec.UseNumber()
+	}
+	return dec.Decode(v)
+}
+
+func (jsonCodec) Name() string {
+	return "json"
+}
+
+type grpcCodec struct {
+	// headers
+	id       string
+	target   string
+	method   string
+	endpoint string
+
+	s grpc.ClientStream
+	c encoding.Codec
+}
+
+func (g *grpcCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
+	md, err := g.s.Header()
+	if err != nil {
+		return err
+	}
+	if m == nil {
+		m = new(codec.Message)
+	}
+	if m.Header == nil {
+		m.Header = make(map[string]string, len(md))
+	}
+	for k, v := range md {
+		m.Header[k] = strings.Join(v, ",")
+	}
+	m.Id = g.id
+	m.Target = g.target
+	m.Method = g.method
+	m.Endpoint = g.endpoint
+	return nil
+}
+
+func (g *grpcCodec) ReadBody(v interface{}) error {
+	if f, ok := v.(*bytes.Frame); ok {
+		return g.s.RecvMsg(f)
+	}
+	return g.s.RecvMsg(v)
+}
+
+func (g *grpcCodec) Write(m *codec.Message, v interface{}) error {
+	// if we don't have a body
+	if v != nil {
+		return g.s.SendMsg(v)
+	}
+	// write the body using the framing codec
+	return g.s.SendMsg(&bytes.Frame{Data: m.Body})
+}
+
+func (g *grpcCodec) Close() error {
+	return g.s.CloseSend()
+}
+
+func (g *grpcCodec) String() string {
+	return g.c.Name()
+}

client/grpc/error.go

@@ -0,0 +1,69 @@
+package grpc
+
+import (
+	"net/http"
+
+	"go-micro.dev/v6/errors"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func microError(err error) error {
+	// no error
+	switch err {
+	case nil:
+		return nil
+	}
+
+	if verr, ok := err.(*errors.Error); ok {
+		return verr
+	}
+
+	// grpc error
+	s, ok := status.FromError(err)
+	if !ok {
+		return err
+	}
+
+	// return first error from details
+	if details := s.Details(); len(details) > 0 {
+		return microError(details[0].(error))
+	}
+
+	// try to decode micro *errors.Error
+	if e := errors.Parse(s.Message()); e.Code > 0 {
+		return e // actually a micro error
+	}
+
+	// fallback
+	return errors.New("go.micro.client", s.Message(), microStatusFromGrpcCode(s.Code()))
+}
+
+func microStatusFromGrpcCode(code codes.Code) int32 {
+	switch code {
+	case codes.OK:
+		return http.StatusOK
+	case codes.InvalidArgument:
+		return http.StatusBadRequest
+	case codes.DeadlineExceeded:
+		return http.StatusRequestTimeout
+	case codes.NotFound:
+		return http.StatusNotFound
+	case codes.AlreadyExists:
+		return http.StatusConflict
+	case codes.PermissionDenied:
+		return http.StatusForbidden
+	case codes.Unauthenticated:
+		return http.StatusUnauthorized
+	case codes.FailedPrecondition:
+		return http.StatusPreconditionFailed
+	case codes.Unimplemented:
+		return http.StatusNotImplemented
+	case codes.Internal:
+		return http.StatusInternalServerError
+	case codes.Unavailable:
+		return http.StatusServiceUnavailable
+	}
+
+	return http.StatusInternalServerError
+}

client/grpc/grpc.go

@@ -0,0 +1,709 @@
+// Package grpc provides a gRPC client
+package grpc
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"net"
+	"reflect"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"go-micro.dev/v6/broker"
+	"go-micro.dev/v6/client"
+	"go-micro.dev/v6/cmd"
+	raw "go-micro.dev/v6/codec/bytes"
+	"go-micro.dev/v6/errors"
+	pnet "go-micro.dev/v6/internal/util/net"
+	"go-micro.dev/v6/metadata"
+	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/selector"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/encoding"
+	gmetadata "google.golang.org/grpc/metadata"
+)
+
+type grpcClient struct {
+	opts client.Options
+	pool *pool
+	once atomic.Value
+}
+
+func init() {
+	cmd.DefaultClients["grpc"] = NewClient
+
+	encoding.RegisterCodec(wrapCodec{jsonCodec{}})
+	encoding.RegisterCodec(wrapCodec{protoCodec{}})
+	encoding.RegisterCodec(wrapCodec{bytesCodec{}})
+}
+
+// secure returns the dial option for whether its a secure or insecure connection.
+func (g *grpcClient) secure(addr string) grpc.DialOption {
+	// first we check if theres'a  tls config
+	if g.opts.Context != nil {
+		if v := g.opts.Context.Value(tlsAuth{}); v != nil {
+			tls := v.(*tls.Config)
+			creds := credentials.NewTLS(tls)
+			// return tls config if it exists
+			return grpc.WithTransportCredentials(creds)
+		}
+	}
+
+	// default config
+	tlsConfig := &tls.Config{}
+	defaultCreds := grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig))
+
+	// check if the address is prepended with https
+	if strings.HasPrefix(addr, "https://") {
+		return defaultCreds
+	}
+
+	// if no port is specified or port is 443 default to tls
+	_, port, err := net.SplitHostPort(addr)
+	// assuming with no port its going to be secured
+	if port == "443" {
+		return defaultCreds
+	} else if err != nil && strings.Contains(err.Error(), "missing port in address") {
+		return defaultCreds
+	}
+
+	// other fallback to insecure
+	return grpc.WithInsecure()
+}
+
+func (g *grpcClient) next(request client.Request, opts client.CallOptions) (selector.Next, error) {
+	service, address, _ := pnet.Proxy(request.Service(), opts.Address)
+
+	// return remote address
+	if len(address) > 0 {
+		return func() (*registry.Node, error) {
+			return &registry.Node{
+				Address: address[0],
+			}, nil
+		}, nil
+	}
+
+	// get next nodes from the selector
+	next, err := g.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())
+	}
+
+	return next, nil
+}
+
+func (g *grpcClient) call(ctx context.Context, node *registry.Node, req client.Request, rsp interface{}, opts client.CallOptions) error {
+	var header map[string]string
+
+	address := node.Address
+
+	if md, ok := metadata.FromContext(ctx); ok {
+		header = make(map[string]string, len(md))
+		for k, v := range md {
+			header[strings.ToLower(k)] = v
+		}
+	} else {
+		header = make(map[string]string)
+	}
+
+	// set timeout in nanoseconds
+	header["timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
+	// set the content type for the request
+	header["x-content-type"] = req.ContentType()
+
+	md := gmetadata.New(header)
+	ctx = gmetadata.NewOutgoingContext(ctx, md)
+
+	cf, err := g.newGRPCCodec(req.ContentType())
+	if err != nil {
+		return errors.InternalServerError("go.micro.client", err.Error())
+	}
+
+	maxRecvMsgSize := g.maxRecvMsgSizeValue()
+	maxSendMsgSize := g.maxSendMsgSizeValue()
+
+	var grr error
+
+	var dialCtx context.Context
+	var cancel context.CancelFunc
+	if opts.DialTimeout > 0 {
+		dialCtx, cancel = context.WithTimeout(ctx, opts.DialTimeout)
+	} else {
+		dialCtx, cancel = context.WithCancel(ctx)
+	}
+	defer cancel()
+
+	grpcDialOptions := []grpc.DialOption{
+		g.secure(address),
+		grpc.WithDefaultCallOptions(
+			grpc.MaxCallRecvMsgSize(maxRecvMsgSize),
+			grpc.MaxCallSendMsgSize(maxSendMsgSize),
+		),
+	}
+
+	if opts := g.getGrpcDialOptions(); opts != nil {
+		grpcDialOptions = append(grpcDialOptions, opts...)
+	}
+
+	cc, err := g.pool.getConn(dialCtx, address, grpcDialOptions...)
+	if err != nil {
+		return errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
+	}
+	defer func() {
+		// defer execution of release
+		g.pool.release(address, cc, grr)
+	}()
+
+	ch := make(chan error, 1)
+
+	go func() {
+		grpcCallOptions := []grpc.CallOption{
+			grpc.ForceCodec(cf),
+			grpc.CallContentSubtype(cf.Name())}
+		if opts := callOpts(opts); opts != nil {
+			grpcCallOptions = append(grpcCallOptions, opts...)
+		}
+		err := cc.Invoke(ctx, methodToGRPC(req.Service(), req.Endpoint()), req.Body(), rsp, grpcCallOptions...)
+		ch <- microError(err)
+	}()
+
+	select {
+	case err := <-ch:
+		grr = err
+	case <-ctx.Done():
+		grr = errors.Timeout("go.micro.client", "%v", ctx.Err())
+	}
+
+	return grr
+}
+
+func (g *grpcClient) stream(ctx context.Context, node *registry.Node, req client.Request, rsp interface{}, opts client.CallOptions) error {
+	var header map[string]string
+
+	address := node.Address
+
+	if md, ok := metadata.FromContext(ctx); ok {
+		header = make(map[string]string, len(md))
+		for k, v := range md {
+			header[k] = v
+		}
+	} else {
+		header = make(map[string]string)
+	}
+
+	// set timeout in nanoseconds
+	if opts.StreamTimeout > time.Duration(0) {
+		header["timeout"] = fmt.Sprintf("%d", opts.StreamTimeout)
+	}
+	// set the content type for the request
+	header["x-content-type"] = req.ContentType()
+
+	md := gmetadata.New(header)
+
+	// WebSocket connection adds the `Connection: Upgrade` header.
+	// But as per the HTTP/2 spec, the `Connection` header makes the request malformed
+	delete(md, "connection")
+
+	ctx = gmetadata.NewOutgoingContext(ctx, md)
+
+	cf, err := g.newGRPCCodec(req.ContentType())
+	if err != nil {
+		return errors.InternalServerError("go.micro.client", err.Error())
+	}
+
+	var dialCtx context.Context
+	var cancel context.CancelFunc
+	if opts.DialTimeout > 0 {
+		dialCtx, cancel = context.WithTimeout(ctx, opts.DialTimeout)
+	} else {
+		dialCtx, cancel = context.WithCancel(ctx)
+	}
+	defer cancel()
+
+	wc := wrapCodec{cf}
+
+	grpcDialOptions := []grpc.DialOption{
+		g.secure(address),
+	}
+
+	if opts := g.getGrpcDialOptions(); opts != nil {
+		grpcDialOptions = append(grpcDialOptions, opts...)
+	}
+
+	cc, err := g.pool.getConn(dialCtx, address, grpcDialOptions...)
+	if err != nil {
+		return errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
+	}
+
+	desc := &grpc.StreamDesc{
+		StreamName:    req.Service() + req.Endpoint(),
+		ClientStreams: true,
+		ServerStreams: true,
+	}
+
+	grpcCallOptions := []grpc.CallOption{
+		grpc.ForceCodec(wc),
+		grpc.CallContentSubtype(cf.Name()),
+	}
+	if opts := callOpts(opts); opts != nil {
+		grpcCallOptions = append(grpcCallOptions, opts...)
+	}
+
+	// create a new canceling context
+	newCtx, cancel := context.WithCancel(ctx)
+
+	st, err := cc.NewStream(newCtx, desc, methodToGRPC(req.Service(), req.Endpoint()), grpcCallOptions...)
+	if err != nil {
+		// we need to cleanup as we dialed and created a context
+		// cancel the context
+		cancel()
+		// close the connection
+		cc.Close()
+		// now return the error
+		return errors.InternalServerError("go.micro.client", fmt.Sprintf("Error creating stream: %v", err))
+	}
+
+	codec := &grpcCodec{
+		s: st,
+		c: wc,
+	}
+
+	// set request codec
+	if r, ok := req.(*grpcRequest); ok {
+		r.codec = codec
+	}
+
+	// setup the stream response
+	stream := &grpcStream{
+		context: ctx,
+		request: req,
+		response: &response{
+			conn:   cc.ClientConn,
+			stream: st,
+			codec:  cf,
+			gcodec: codec,
+		},
+		stream: st,
+		cancel: cancel,
+		release: func(err error) {
+			g.pool.release(address, cc, err)
+		},
+	}
+
+	// set the stream as the response
+	val := reflect.ValueOf(rsp).Elem()
+	val.Set(reflect.ValueOf(stream).Elem())
+	return nil
+}
+
+func (g *grpcClient) poolMaxStreams() int {
+	if g.opts.Context == nil {
+		return DefaultPoolMaxStreams
+	}
+	v := g.opts.Context.Value(poolMaxStreams{})
+	if v == nil {
+		return DefaultPoolMaxStreams
+	}
+	return v.(int)
+}
+
+func (g *grpcClient) poolMaxIdle() int {
+	if g.opts.Context == nil {
+		return DefaultPoolMaxIdle
+	}
+	v := g.opts.Context.Value(poolMaxIdle{})
+	if v == nil {
+		return DefaultPoolMaxIdle
+	}
+	return v.(int)
+}
+
+func (g *grpcClient) maxRecvMsgSizeValue() int {
+	if g.opts.Context == nil {
+		return DefaultMaxRecvMsgSize
+	}
+	v := g.opts.Context.Value(maxRecvMsgSizeKey{})
+	if v == nil {
+		return DefaultMaxRecvMsgSize
+	}
+	return v.(int)
+}
+
+func (g *grpcClient) maxSendMsgSizeValue() int {
+	if g.opts.Context == nil {
+		return DefaultMaxSendMsgSize
+	}
+	v := g.opts.Context.Value(maxSendMsgSizeKey{})
+	if v == nil {
+		return DefaultMaxSendMsgSize
+	}
+	return v.(int)
+}
+
+func (g *grpcClient) newGRPCCodec(contentType string) (encoding.Codec, error) {
+	codecs := make(map[string]encoding.Codec)
+	if g.opts.Context != nil {
+		if v := g.opts.Context.Value(codecsKey{}); v != nil {
+			codecs = v.(map[string]encoding.Codec)
+		}
+	}
+	if c, ok := codecs[contentType]; ok {
+		return wrapCodec{c}, nil
+	}
+	if c, ok := defaultGRPCCodecs[contentType]; ok {
+		return wrapCodec{c}, nil
+	}
+	return nil, fmt.Errorf("unsupported Content-Type: %s", contentType)
+}
+
+func (g *grpcClient) Init(opts ...client.Option) error {
+	size := g.opts.PoolSize
+	ttl := g.opts.PoolTTL
+
+	for _, o := range opts {
+		o(&g.opts)
+	}
+
+	// update pool configuration if the options changed
+	if size != g.opts.PoolSize || ttl != g.opts.PoolTTL {
+		g.pool.Lock()
+		g.pool.size = g.opts.PoolSize
+		g.pool.ttl = int64(g.opts.PoolTTL.Seconds())
+		g.pool.Unlock()
+	}
+
+	return nil
+}
+
+func (g *grpcClient) Options() client.Options {
+	return g.opts
+}
+
+func (g *grpcClient) NewMessage(topic string, msg interface{}, opts ...client.MessageOption) client.Message {
+	return newGRPCEvent(topic, msg, g.opts.ContentType, opts...)
+}
+
+func (g *grpcClient) NewRequest(service, method string, req interface{}, reqOpts ...client.RequestOption) client.Request {
+	return newGRPCRequest(service, method, req, g.opts.ContentType, reqOpts...)
+}
+
+func (g *grpcClient) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
+	if req == nil {
+		return errors.InternalServerError("go.micro.client", "req is nil")
+	} else if rsp == nil {
+		return errors.InternalServerError("go.micro.client", "rsp is nil")
+	}
+	// make a copy of call opts
+	callOpts := g.opts.CallOptions
+	for _, opt := range opts {
+		opt(&callOpts)
+	}
+
+	next, err := g.next(req, callOpts)
+	if err != nil {
+		return err
+	}
+
+	// check if we already have a deadline
+	d, ok := ctx.Deadline()
+	if !ok {
+		// no deadline so we create a new one
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, callOpts.RequestTimeout)
+		defer cancel()
+	} else {
+		// got a deadline so no need to setup context
+		// but we need to set the timeout we pass along
+		opt := client.WithRequestTimeout(time.Until(d))
+		opt(&callOpts)
+	}
+
+	// should we noop right here?
+	select {
+	case <-ctx.Done():
+		return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+	default:
+	}
+
+	// make copy of call method
+	gcall := g.call
+
+	// wrap the call in reverse
+	for i := len(callOpts.CallWrappers); i > 0; i-- {
+		gcall = callOpts.CallWrappers[i-1](gcall)
+	}
+
+	// return errors.New("go.micro.client", "request timeout", 408)
+	call := func(i int) error {
+		// call backoff first. Someone may want an initial start delay
+		t, err := callOpts.Backoff(ctx, req, i)
+		if err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
+		}
+
+		// only sleep if greater than 0
+		if t.Seconds() > 0 {
+			time.Sleep(t)
+		}
+
+		// select next node
+		node, err := next()
+		service := req.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 selecting %s node: %s", service, err.Error())
+		}
+
+		// make the call
+		err = gcall(ctx, node, req, rsp, callOpts)
+		g.opts.Selector.Mark(service, node, err)
+		if verr, ok := err.(*errors.Error); ok {
+			return verr
+		}
+
+		return err
+	}
+
+	ch := make(chan error, callOpts.Retries+1)
+	var gerr error
+
+	for i := 0; i <= callOpts.Retries; i++ {
+		go func(i int) {
+			ch <- call(i)
+		}(i)
+
+		select {
+		case <-ctx.Done():
+			return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+		case err := <-ch:
+			// if the call succeeded lets bail early
+			if err == nil {
+				return nil
+			}
+
+			retry, rerr := callOpts.Retry(ctx, req, i, err)
+			if rerr != nil {
+				return rerr
+			}
+
+			if !retry {
+				return err
+			}
+
+			gerr = err
+		}
+	}
+
+	return gerr
+}
+
+func (g *grpcClient) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
+	// make a copy of call opts
+	callOpts := g.opts.CallOptions
+	for _, opt := range opts {
+		opt(&callOpts)
+	}
+
+	next, err := g.next(req, callOpts)
+	if err != nil {
+		return nil, err
+	}
+
+	// #200 - streams shouldn't have a request timeout set on the context
+
+	// should we noop right here?
+	select {
+	case <-ctx.Done():
+		return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+	default:
+	}
+
+	// make a copy of stream
+	gstream := g.stream
+
+	// wrap the call in reverse
+	for i := len(callOpts.CallWrappers); i > 0; i-- {
+		gstream = callOpts.CallWrappers[i-1](gstream)
+	}
+
+	call := func(i int) (client.Stream, error) {
+		// call backoff first. Someone may want an initial start delay
+		t, err := callOpts.Backoff(ctx, req, i)
+		if err != nil {
+			return nil, errors.InternalServerError("go.micro.client", err.Error())
+		}
+
+		// only sleep if greater than 0
+		if t.Seconds() > 0 {
+			time.Sleep(t)
+		}
+
+		node, err := next()
+		service := req.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 selecting %s node: %s", service, err.Error())
+		}
+
+		// make the call
+		stream := &grpcStream{}
+		err = g.stream(ctx, node, req, stream, callOpts)
+
+		g.opts.Selector.Mark(service, node, err)
+		return stream, err
+	}
+
+	type response struct {
+		stream client.Stream
+		err    error
+	}
+
+	ch := make(chan response, callOpts.Retries+1)
+	var grr error
+
+	for i := 0; i <= callOpts.Retries; i++ {
+		go func(i int) {
+			s, err := call(i)
+			ch <- response{s, err}
+		}(i)
+
+		select {
+		case <-ctx.Done():
+			return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
+		case rsp := <-ch:
+			// if the call succeeded lets bail early
+			if rsp.err == nil {
+				return rsp.stream, nil
+			}
+
+			retry, rerr := callOpts.Retry(ctx, req, i, err)
+			if rerr != nil {
+				return nil, rerr
+			}
+
+			if !retry {
+				return nil, rsp.err
+			}
+
+			grr = rsp.err
+		}
+	}
+
+	return nil, grr
+}
+
+func (g *grpcClient) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
+	var options client.PublishOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	md, ok := metadata.FromContext(ctx)
+	if !ok {
+		md = make(map[string]string)
+	}
+	md["Content-Type"] = p.ContentType()
+	md["Micro-Topic"] = p.Topic()
+
+	cf, err := g.newGRPCCodec(p.ContentType())
+	if err != nil {
+		return errors.InternalServerError("go.micro.client", err.Error())
+	}
+
+	var body []byte
+
+	// passed in raw data
+	if d, ok := p.Payload().(*raw.Frame); ok {
+		body = d.Data
+	} else {
+		// set the body
+		b, err := cf.Marshal(p.Payload())
+		if err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
+		}
+		body = b
+	}
+
+	if !g.once.Load().(bool) {
+		if err = g.opts.Broker.Connect(); err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
+		}
+		g.once.Store(true)
+	}
+
+	topic := p.Topic()
+
+	// get the exchange
+	if len(options.Exchange) > 0 {
+		topic = options.Exchange
+	}
+
+	return g.opts.Broker.Publish(topic, &broker.Message{
+		Header: md,
+		Body:   body,
+	}, broker.PublishContext(options.Context))
+}
+
+func (g *grpcClient) String() string {
+	return "grpc"
+}
+
+func (g *grpcClient) getGrpcDialOptions() []grpc.DialOption {
+	if g.opts.CallOptions.Context == nil {
+		return nil
+	}
+
+	v := g.opts.CallOptions.Context.Value(grpcDialOptions{})
+
+	if v == nil {
+		return nil
+	}
+
+	opts, ok := v.([]grpc.DialOption)
+
+	if !ok {
+		return nil
+	}
+
+	return opts
+}
+
+func newClient(opts ...client.Option) client.Client {
+	options := client.NewOptions()
+	// default content type for grpc
+	options.ContentType = "application/grpc+proto"
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	rc := &grpcClient{
+		opts: options,
+	}
+	rc.once.Store(false)
+
+	rc.pool = newPool(options.PoolSize, options.PoolTTL, rc.poolMaxIdle(), rc.poolMaxStreams())
+
+	c := client.Client(rc)
+
+	// wrap in reverse
+	for i := len(options.Wrappers); i > 0; i-- {
+		c = options.Wrappers[i-1](c)
+	}
+
+	return c
+}
+
+func NewClient(opts ...client.Option) client.Client {
+	return newClient(opts...)
+}

client/grpc/grpc_pool.go

@@ -0,0 +1,216 @@
+package grpc
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/connectivity"
+)
+
+type pool struct {
+	size int
+	ttl  int64
+
+	//  max streams on a *poolConn
+	maxStreams int
+	//  max idle conns
+	maxIdle int
+
+	sync.Mutex
+	conns map[string]*streamsPool
+}
+
+type streamsPool struct {
+	//  head of list
+	head *poolConn
+	//  busy conns list
+	busy *poolConn
+	//  the size of list
+	count int
+	//  idle conn
+	idle int
+}
+
+type poolConn struct {
+	//  grpc conn
+	*grpc.ClientConn
+	err  error
+	addr string
+
+	//  pool and streams pool
+	pool    *pool
+	sp      *streamsPool
+	streams int
+	created int64
+
+	//  list
+	pre  *poolConn
+	next *poolConn
+	in   bool
+}
+
+func newPool(size int, ttl time.Duration, idle int, ms int) *pool {
+	if ms <= 0 {
+		ms = 1
+	}
+	if idle < 0 {
+		idle = 0
+	}
+	return &pool{
+		size:       size,
+		ttl:        int64(ttl.Seconds()),
+		maxStreams: ms,
+		maxIdle:    idle,
+		conns:      make(map[string]*streamsPool),
+	}
+}
+
+func (p *pool) getConn(dialCtx context.Context, addr string, opts ...grpc.DialOption) (*poolConn, error) {
+	now := time.Now().Unix()
+	p.Lock()
+	sp, ok := p.conns[addr]
+	if !ok {
+		sp = &streamsPool{head: &poolConn{}, busy: &poolConn{}, count: 0, idle: 0}
+		p.conns[addr] = sp
+	}
+	//  while we have conns check streams and then return one
+	//  otherwise we'll create a new conn
+	conn := sp.head.next
+	for conn != nil {
+		//  check conn state
+		// https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md
+		switch conn.GetState() {
+		case connectivity.Connecting:
+			conn = conn.next
+			continue
+		case connectivity.Shutdown:
+			next := conn.next
+			if conn.streams == 0 {
+				removeConn(conn)
+				sp.idle--
+			}
+			conn = next
+			continue
+		case connectivity.TransientFailure:
+			next := conn.next
+			if conn.streams == 0 {
+				removeConn(conn)
+				conn.ClientConn.Close()
+				sp.idle--
+			}
+			conn = next
+			continue
+		case connectivity.Ready:
+		case connectivity.Idle:
+		}
+		//  a old conn
+		if now-conn.created > p.ttl {
+			next := conn.next
+			if conn.streams == 0 {
+				removeConn(conn)
+				conn.ClientConn.Close()
+				sp.idle--
+			}
+			conn = next
+			continue
+		}
+		//  a busy conn
+		if conn.streams >= p.maxStreams {
+			next := conn.next
+			removeConn(conn)
+			addConnAfter(conn, sp.busy)
+			conn = next
+			continue
+		}
+		//  a idle conn
+		if conn.streams == 0 {
+			sp.idle--
+		}
+		//  a good conn
+		conn.streams++
+		p.Unlock()
+		return conn, nil
+	}
+	p.Unlock()
+
+	//  create new conn
+	cc, err := grpc.DialContext(dialCtx, addr, opts...)
+	if err != nil {
+		return nil, err
+	}
+	conn = &poolConn{cc, nil, addr, p, sp, 1, time.Now().Unix(), nil, nil, false}
+
+	//  add conn to streams pool
+	p.Lock()
+	if sp.count < p.size {
+		addConnAfter(conn, sp.head)
+	}
+	p.Unlock()
+
+	return conn, nil
+}
+
+func (p *pool) release(addr string, conn *poolConn, err error) {
+	p.Lock()
+	p, sp, created := conn.pool, conn.sp, conn.created
+	//  try to add conn
+	if !conn.in && sp.count < p.size {
+		addConnAfter(conn, sp.head)
+	}
+	if !conn.in {
+		p.Unlock()
+		conn.ClientConn.Close()
+		return
+	}
+	//  a busy conn
+	if conn.streams >= p.maxStreams {
+		removeConn(conn)
+		addConnAfter(conn, sp.head)
+	}
+	conn.streams--
+	//  if streams == 0, we can do something
+	if conn.streams == 0 {
+		//  1. it has errored
+		//  2. too many idle conn or
+		//  3. conn is too old
+		now := time.Now().Unix()
+		if err != nil || sp.idle >= p.maxIdle || now-created > p.ttl {
+			removeConn(conn)
+			p.Unlock()
+			conn.ClientConn.Close()
+			return
+		}
+		sp.idle++
+	}
+	p.Unlock()
+}
+
+func (conn *poolConn) Close() {
+	conn.pool.release(conn.addr, conn, conn.err)
+}
+
+func removeConn(conn *poolConn) {
+	if conn.pre != nil {
+		conn.pre.next = conn.next
+	}
+	if conn.next != nil {
+		conn.next.pre = conn.pre
+	}
+	conn.pre = nil
+	conn.next = nil
+	conn.in = false
+	conn.sp.count--
+}
+
+func addConnAfter(conn *poolConn, after *poolConn) {
+	conn.next = after.next
+	conn.pre = after
+	if after.next != nil {
+		after.next.pre = conn
+	}
+	after.next = conn
+	conn.in = true
+	conn.sp.count++
+}

client/grpc/grpc_pool_test.go

@@ -0,0 +1,63 @@
+package grpc
+
+import (
+	"context"
+	"net"
+	"testing"
+	"time"
+
+	"google.golang.org/grpc"
+	pb "google.golang.org/grpc/examples/helloworld/helloworld"
+)
+
+func testPool(t *testing.T, size int, ttl time.Duration, idle int, ms int) {
+	// setup server
+	l, err := net.Listen("tcp", ":0")
+	if err != nil {
+		t.Errorf("failed to listen: %v", err)
+	}
+	defer l.Close()
+
+	s := grpc.NewServer()
+	pb.RegisterGreeterServer(s, &greeterServer{})
+
+	go s.Serve(l)
+	defer s.Stop()
+
+	// zero pool
+	p := newPool(size, ttl, idle, ms)
+
+	for i := 0; i < 10; i++ {
+		// get a conn
+		cc, err := p.getConn(context.TODO(), l.Addr().String(), grpc.WithInsecure())
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		rsp := pb.HelloReply{}
+
+		err = cc.Invoke(context.TODO(), "/helloworld.Greeter/SayHello", &pb.HelloRequest{Name: "John"}, &rsp)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if rsp.Message != "Hello John" {
+			t.Errorf("Got unexpected response %v", rsp.Message)
+		}
+
+		// release the conn
+		p.release(l.Addr().String(), cc, nil)
+
+		p.Lock()
+		if i := p.conns[l.Addr().String()].count; i > size {
+			p.Unlock()
+			t.Errorf("pool size %d is greater than expected %d", i, size)
+		}
+		p.Unlock()
+	}
+}
+
+func TestGRPCPool(t *testing.T) {
+	testPool(t, 0, time.Minute, 10, 2)
+	testPool(t, 2, time.Minute, 10, 1)
+}

client/grpc/grpc_test.go

@@ -0,0 +1,112 @@
+package grpc
+
+import (
+	"context"
+	"net"
+	"testing"
+
+	"go-micro.dev/v6/client"
+	"go-micro.dev/v6/errors"
+	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/selector"
+	pgrpc "google.golang.org/grpc"
+	pb "google.golang.org/grpc/examples/helloworld/helloworld"
+)
+
+// server is used to implement helloworld.GreeterServer.
+type greeterServer struct {
+	pb.UnimplementedGreeterServer
+}
+
+// SayHello implements helloworld.GreeterServer.
+func (g *greeterServer) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
+	if in.Name == "Error" {
+		return nil, &errors.Error{Id: "1", Code: 99, Detail: "detail"}
+	}
+	return &pb.HelloReply{Message: "Hello " + in.Name}, nil
+}
+
+func TestGRPCClient(t *testing.T) {
+	l, err := net.Listen("tcp", ":0")
+	if err != nil {
+		t.Fatalf("failed to listen: %v", err)
+	}
+	defer l.Close()
+
+	s := pgrpc.NewServer()
+	pb.RegisterGreeterServer(s, &greeterServer{})
+
+	go s.Serve(l)
+	defer s.Stop()
+
+	// create mock registry
+	r := registry.NewMemoryRegistry()
+
+	// register service
+	r.Register(&registry.Service{
+		Name:    "helloworld",
+		Version: "test",
+		Nodes: []*registry.Node{
+			{
+				Id:      "test-1",
+				Address: l.Addr().String(),
+				Metadata: map[string]string{
+					"protocol": "grpc",
+				},
+			},
+		},
+	})
+
+	// create selector
+	se := selector.NewSelector(
+		selector.Registry(r),
+	)
+
+	// create client
+	c := NewClient(
+		client.Registry(r),
+		client.Selector(se),
+	)
+
+	testMethods := []string{
+		"/helloworld.Greeter/SayHello",
+		"Greeter.SayHello",
+	}
+
+	for _, method := range testMethods {
+		req := c.NewRequest("helloworld", method, &pb.HelloRequest{
+			Name: "John",
+		})
+
+		rsp := pb.HelloReply{}
+
+		err = c.Call(context.TODO(), req, &rsp)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if rsp.Message != "Hello John" {
+			t.Fatalf("Got unexpected response %v", rsp.Message)
+		}
+	}
+
+	req := c.NewRequest("helloworld", "/helloworld.Greeter/SayHello", &pb.HelloRequest{
+		Name: "Error",
+	})
+
+	rsp := pb.HelloReply{}
+
+	err = c.Call(context.TODO(), req, &rsp)
+	if err == nil {
+		t.Fatal("nil error received")
+	}
+
+	verr, ok := err.(*errors.Error)
+	if !ok {
+		t.Fatalf("invalid error received %#+v\n", err)
+	}
+
+	if verr.Code != 99 && verr.Id != "1" && verr.Detail != "detail" {
+		t.Fatalf("invalid error received %#+v\n", verr)
+	}
+}

client/grpc/message.go

@@ -0,0 +1,40 @@
+package grpc
+
+import (
+	"go-micro.dev/v6/client"
+)
+
+type grpcEvent struct {
+	topic       string
+	contentType string
+	payload     interface{}
+}
+
+func newGRPCEvent(topic string, payload interface{}, contentType string, opts ...client.MessageOption) client.Message {
+	var options client.MessageOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if len(options.ContentType) > 0 {
+		contentType = options.ContentType
+	}
+
+	return &grpcEvent{
+		payload:     payload,
+		topic:       topic,
+		contentType: contentType,
+	}
+}
+
+func (g *grpcEvent) ContentType() string {
+	return g.contentType
+}
+
+func (g *grpcEvent) Topic() string {
+	return g.topic
+}
+
+func (g *grpcEvent) Payload() interface{} {
+	return g.payload
+}

client/grpc/options.go

@@ -0,0 +1,143 @@
+// Package grpc provides a gRPC options
+package grpc
+
+import (
+	"context"
+	"crypto/tls"
+
+	"go-micro.dev/v6/client"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/encoding"
+)
+
+var (
+	// DefaultPoolMaxStreams maximum streams on a connectioin
+	// (20).
+	DefaultPoolMaxStreams = 20
+
+	// DefaultPoolMaxIdle maximum idle conns of a pool
+	// (50).
+	DefaultPoolMaxIdle = 50
+
+	// DefaultMaxRecvMsgSize maximum message that client can receive
+	// (4 MB).
+	DefaultMaxRecvMsgSize = 1024 * 1024 * 4
+
+	// DefaultMaxSendMsgSize maximum message that client can send
+	// (4 MB).
+	DefaultMaxSendMsgSize = 1024 * 1024 * 4
+)
+
+type poolMaxStreams struct{}
+type poolMaxIdle struct{}
+type codecsKey struct{}
+type tlsAuth struct{}
+type maxRecvMsgSizeKey struct{}
+type maxSendMsgSizeKey struct{}
+type grpcDialOptions struct{}
+type grpcCallOptions struct{}
+
+// maximum streams on a connectioin.
+func PoolMaxStreams(n int) client.Option {
+	return func(o *client.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, poolMaxStreams{}, n)
+	}
+}
+
+// maximum idle conns of a pool.
+func PoolMaxIdle(d int) client.Option {
+	return func(o *client.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, poolMaxIdle{}, d)
+	}
+}
+
+// gRPC Codec to be used to encode/decode requests for a given content type.
+func Codec(contentType string, c encoding.Codec) client.Option {
+	return func(o *client.Options) {
+		codecs := make(map[string]encoding.Codec)
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		if v := o.Context.Value(codecsKey{}); v != nil {
+			codecs = v.(map[string]encoding.Codec)
+		}
+		codecs[contentType] = c
+		o.Context = context.WithValue(o.Context, codecsKey{}, codecs)
+	}
+}
+
+// AuthTLS should be used to setup a secure authentication using TLS.
+func AuthTLS(t *tls.Config) client.Option {
+	return func(o *client.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, tlsAuth{}, t)
+	}
+}
+
+// MaxRecvMsgSize set the maximum size of message that client can receive.
+func MaxRecvMsgSize(s int) client.Option {
+	return func(o *client.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, maxRecvMsgSizeKey{}, s)
+	}
+}
+
+// MaxSendMsgSize set the maximum size of message that client can send.
+func MaxSendMsgSize(s int) client.Option {
+	return func(o *client.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, maxSendMsgSizeKey{}, s)
+	}
+}
+
+// DialOptions to be used to configure gRPC dial options.
+func DialOptions(opts ...grpc.DialOption) client.CallOption {
+	return func(o *client.CallOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, grpcDialOptions{}, opts)
+	}
+}
+
+// CallOptions to be used to configure gRPC call options.
+func CallOptions(opts ...grpc.CallOption) client.CallOption {
+	return func(o *client.CallOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, grpcCallOptions{}, opts)
+	}
+}
+
+func callOpts(opts client.CallOptions) []grpc.CallOption {
+	if opts.Context == nil {
+		return nil
+	}
+
+	v := opts.Context.Value(grpcCallOptions{})
+
+	if v == nil {
+		return nil
+	}
+
+	options, ok := v.([]grpc.CallOption)
+
+	if !ok {
+		return nil
+	}
+
+	return options
+}

client/grpc/request.go

@@ -0,0 +1,87 @@
+package grpc
+
+import (
+	"fmt"
+	"strings"
+
+	"go-micro.dev/v6/client"
+	"go-micro.dev/v6/codec"
+)
+
+type grpcRequest struct {
+	service     string
+	method      string
+	contentType string
+	request     interface{}
+	opts        client.RequestOptions
+	codec       codec.Codec
+}
+
+// service Struct.Method /service.Struct/Method.
+func methodToGRPC(service, method string) string {
+	// no method or already grpc method
+	if len(method) == 0 || method[0] == '/' {
+		return method
+	}
+
+	// assume method is Foo.Bar
+	mParts := strings.Split(method, ".")
+	if len(mParts) != 2 {
+		return method
+	}
+
+	if len(service) == 0 {
+		return fmt.Sprintf("/%s/%s", mParts[0], mParts[1])
+	}
+
+	// return /pkg.Foo/Bar
+	return fmt.Sprintf("/%s.%s/%s", service, mParts[0], mParts[1])
+}
+
+func newGRPCRequest(service, method string, request interface{}, contentType string, reqOpts ...client.RequestOption) client.Request {
+	var opts client.RequestOptions
+	for _, o := range reqOpts {
+		o(&opts)
+	}
+
+	// set the content-type specified
+	if len(opts.ContentType) > 0 {
+		contentType = opts.ContentType
+	}
+
+	return &grpcRequest{
+		service:     service,
+		method:      method,
+		request:     request,
+		contentType: contentType,
+		opts:        opts,
+	}
+}
+
+func (g *grpcRequest) ContentType() string {
+	return g.contentType
+}
+
+func (g *grpcRequest) Service() string {
+	return g.service
+}
+
+func (g *grpcRequest) Method() string {
+	return g.method
+}
+
+func (g *grpcRequest) Endpoint() string {
+	return g.method
+}
+
+func (g *grpcRequest) Codec() codec.Writer {
+	return g.codec
+}
+
+func (g *grpcRequest) Body() interface{} {
+	return g.request
+}
+
+func (g *grpcRequest) Stream() bool {
+	return g.opts.Stream
+}

client/grpc/request_test.go

@@ -0,0 +1,41 @@
+package grpc
+
+import (
+	"testing"
+)
+
+func TestMethodToGRPC(t *testing.T) {
+	testData := []struct {
+		service string
+		method  string
+		expect  string
+	}{
+		{
+			"helloworld",
+			"Greeter.SayHello",
+			"/helloworld.Greeter/SayHello",
+		},
+		{
+			"helloworld",
+			"/helloworld.Greeter/SayHello",
+			"/helloworld.Greeter/SayHello",
+		},
+		{
+			"",
+			"/helloworld.Greeter/SayHello",
+			"/helloworld.Greeter/SayHello",
+		},
+		{
+			"",
+			"Greeter.SayHello",
+			"/Greeter/SayHello",
+		},
+	}
+
+	for _, d := range testData {
+		method := methodToGRPC(d.service, d.method)
+		if method != d.expect {
+			t.Fatalf("expected %s got %s", d.expect, method)
+		}
+	}
+}

client/grpc/response.go

@@ -0,0 +1,44 @@
+package grpc
+
+import (
+	"strings"
+
+	"go-micro.dev/v6/codec"
+	"go-micro.dev/v6/codec/bytes"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/encoding"
+)
+
+type response struct {
+	conn   *grpc.ClientConn
+	stream grpc.ClientStream
+	codec  encoding.Codec
+	gcodec codec.Codec
+}
+
+// Read the response.
+func (r *response) Codec() codec.Reader {
+	return r.gcodec
+}
+
+// read the header.
+func (r *response) Header() map[string]string {
+	md, err := r.stream.Header()
+	if err != nil {
+		return map[string]string{}
+	}
+	hdr := make(map[string]string, len(md))
+	for k, v := range md {
+		hdr[k] = strings.Join(v, ",")
+	}
+	return hdr
+}
+
+// Read the undecoded response.
+func (r *response) Read() ([]byte, error) {
+	f := &bytes.Frame{}
+	if err := r.gcodec.ReadBody(f); err != nil {
+		return nil, err
+	}
+	return f.Data, nil
+}

client/grpc/stream.go

@@ -0,0 +1,84 @@
+package grpc
+
+import (
+	"context"
+	"io"
+	"sync"
+
+	"go-micro.dev/v6/client"
+	"google.golang.org/grpc"
+)
+
+// Implements the streamer interface.
+type grpcStream struct {
+	sync.RWMutex
+	closed   bool
+	err      error
+	stream   grpc.ClientStream
+	request  client.Request
+	response client.Response
+	context  context.Context
+	cancel   func()
+	release  func(error)
+}
+
+func (g *grpcStream) Context() context.Context {
+	return g.context
+}
+
+func (g *grpcStream) Request() client.Request {
+	return g.request
+}
+
+func (g *grpcStream) Response() client.Response {
+	return g.response
+}
+
+func (g *grpcStream) Send(msg interface{}) error {
+	if err := g.stream.SendMsg(msg); err != nil {
+		g.setError(err)
+		return err
+	}
+	return nil
+}
+
+func (g *grpcStream) Recv(msg interface{}) (err error) {
+	if err = g.stream.RecvMsg(msg); err != nil {
+		if err != io.EOF {
+			g.setError(err)
+		}
+		return err
+	}
+	return
+}
+
+func (g *grpcStream) Error() error {
+	g.RLock()
+	defer g.RUnlock()
+	return g.err
+}
+
+func (g *grpcStream) setError(e error) {
+	g.Lock()
+	g.err = e
+	g.Unlock()
+}
+
+func (g *grpcStream) CloseSend() error {
+	return g.stream.CloseSend()
+}
+
+func (g *grpcStream) Close() error {
+	g.Lock()
+	defer g.Unlock()
+
+	if g.closed {
+		return nil
+	}
+	// cancel the context
+	g.cancel()
+	g.closed = true
+	// release back to pool
+	g.release(g.err)
+	return nil
+}

client/options.go

@@ -0,0 +1,436 @@
+package client
+
+import (
+	"context"
+	"time"
+
+	"go-micro.dev/v6/broker"
+	"go-micro.dev/v6/codec"
+	"go-micro.dev/v6/logger"
+	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/selector"
+	"go-micro.dev/v6/transport"
+)
+
+var (
+	// DefaultBackoff is the default backoff function for retries.
+	DefaultBackoff = exponentialBackoff
+	// DefaultRetry is the default check-for-retry function for retries.
+	DefaultRetry = RetryOnError
+	// DefaultRetries is the default number of times a request is tried.
+	DefaultRetries = 5
+	// DefaultRequestTimeout is the default request timeout.
+	DefaultRequestTimeout = time.Second * 30
+	// DefaultConnectionTimeout is the default connection timeout.
+	DefaultConnectionTimeout = time.Second * 5
+	// DefaultPoolSize sets the connection pool size.
+	DefaultPoolSize = 100
+	// DefaultPoolTTL sets the connection pool ttl.
+	DefaultPoolTTL = time.Minute
+	// DefaultPoolCloseTimeout sets the connection pool colse timeout.
+	DefaultPoolCloseTimeout = time.Second
+)
+
+// Options are the Client options.
+type Options struct {
+
+	// Default Call Options
+	CallOptions CallOptions
+
+	// Router sets the router
+	Router Router
+
+	Registry  registry.Registry
+	Selector  selector.Selector
+	Transport transport.Transport
+
+	// Plugged interfaces
+	Broker broker.Broker
+
+	// Logger is the underline logger
+	Logger logger.Logger
+
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
+	Codecs  map[string]codec.NewCodec
+
+	// Response cache
+	Cache *Cache
+
+	// Used to select codec
+	ContentType string
+
+	// Middleware for client
+	Wrappers []Wrapper
+
+	// Connection Pool
+	PoolSize         int
+	PoolTTL          time.Duration
+	PoolCloseTimeout time.Duration
+}
+
+// CallOptions are options used to make calls to a server.
+type CallOptions struct {
+
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
+	// Backoff func
+	Backoff BackoffFunc
+	// Check if retriable func
+	Retry         RetryFunc
+	SelectOptions []selector.SelectOption
+
+	// Address of remote hosts
+	Address []string
+
+	// Middleware for low level call func
+	CallWrappers []CallWrapper
+
+	// ConnectionTimeout of one request to the server.
+	// Set this lower than the RequestTimeout to enable retries on connection timeout.
+	ConnectionTimeout time.Duration
+	// Request/Response timeout of entire srv.Call, for single request timeout set ConnectionTimeout.
+	RequestTimeout time.Duration
+	// Stream timeout for the stream
+	StreamTimeout time.Duration
+	// Duration to cache the response for
+	CacheExpiry time.Duration
+	// Transport Dial Timeout. Used for initial dial to establish a connection.
+	DialTimeout time.Duration
+	// Number of Call attempts
+	Retries int
+	// Use the services own auth token
+	ServiceToken bool
+	// ConnClose sets the Connection: close header.
+	ConnClose bool
+}
+
+type PublishOptions struct {
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context context.Context
+	// Exchange is the routing exchange for the message
+	Exchange string
+}
+
+type MessageOptions struct {
+	ContentType string
+}
+
+type RequestOptions struct {
+
+	// Other options for implementations of the interface
+	// can be stored in a context
+	Context     context.Context
+	ContentType string
+	Stream      bool
+}
+
+// NewOptions creates new Client options.
+func NewOptions(options ...Option) Options {
+	opts := Options{
+		Cache:       NewCache(),
+		Context:     context.Background(),
+		ContentType: DefaultContentType,
+		Codecs:      make(map[string]codec.NewCodec),
+		CallOptions: CallOptions{
+			Backoff:           DefaultBackoff,
+			Retry:             DefaultRetry,
+			Retries:           DefaultRetries,
+			RequestTimeout:    DefaultRequestTimeout,
+			ConnectionTimeout: DefaultConnectionTimeout,
+			DialTimeout:       transport.DefaultDialTimeout,
+		},
+		PoolSize:         DefaultPoolSize,
+		PoolTTL:          DefaultPoolTTL,
+		PoolCloseTimeout: DefaultPoolCloseTimeout,
+		Broker:           broker.DefaultBroker,
+		Selector:         selector.DefaultSelector,
+		Registry:         registry.DefaultRegistry,
+		Transport:        transport.DefaultTransport,
+		Logger:           logger.DefaultLogger,
+	}
+
+	for _, o := range options {
+		o(&opts)
+	}
+
+	return opts
+}
+
+// Broker to be used for pub/sub.
+func Broker(b broker.Broker) Option {
+	return func(o *Options) {
+		o.Broker = b
+	}
+}
+
+// Codec to be used to encode/decode requests for a given content type.
+func Codec(contentType string, c codec.NewCodec) Option {
+	return func(o *Options) {
+		o.Codecs[contentType] = c
+	}
+}
+
+// ContentType sets the default content type of the client.
+func ContentType(ct string) Option {
+	return func(o *Options) {
+		o.ContentType = ct
+	}
+}
+
+// PoolSize sets the connection pool size.
+func PoolSize(d int) Option {
+	return func(o *Options) {
+		o.PoolSize = d
+	}
+}
+
+// PoolTTL sets the connection pool ttl.
+func PoolTTL(d time.Duration) Option {
+	return func(o *Options) {
+		o.PoolTTL = d
+	}
+}
+
+// PoolCloseTimeout sets the connection pool close timeout.
+func PoolCloseTimeout(d time.Duration) Option {
+	return func(o *Options) {
+		o.PoolCloseTimeout = d
+	}
+}
+
+// Registry to find nodes for a given service.
+func Registry(r registry.Registry) Option {
+	return func(o *Options) {
+		o.Registry = r
+		// set in the selector
+		_ = o.Selector.Init(selector.Registry(r))
+	}
+}
+
+// Transport to use for communication e.g http, rabbitmq, etc.
+func Transport(t transport.Transport) Option {
+	return func(o *Options) {
+		o.Transport = t
+	}
+}
+
+// Select is used to select a node to route a request to.
+func Selector(s selector.Selector) Option {
+	return func(o *Options) {
+		o.Selector = s
+	}
+}
+
+// Adds a Wrapper to a list of options passed into the client.
+func Wrap(w Wrapper) Option {
+	return func(o *Options) {
+		o.Wrappers = append(o.Wrappers, w)
+	}
+}
+
+// Adds a Wrapper to the list of CallFunc wrappers.
+func WrapCall(cw ...CallWrapper) Option {
+	return func(o *Options) {
+		o.CallOptions.CallWrappers = append(o.CallOptions.CallWrappers, cw...)
+	}
+}
+
+// Backoff is used to set the backoff function used
+// when retrying Calls.
+func Backoff(fn BackoffFunc) Option {
+	return func(o *Options) {
+		o.CallOptions.Backoff = fn
+	}
+}
+
+// Retries set the number of retries when making the request.
+func Retries(i int) Option {
+	return func(o *Options) {
+		o.CallOptions.Retries = i
+	}
+}
+
+// Retry sets the retry function to be used when re-trying.
+func Retry(fn RetryFunc) Option {
+	return func(o *Options) {
+		o.CallOptions.Retry = fn
+	}
+}
+
+// ConnectionTimeout sets the connection timeout
+func ConnectionTimeout(t time.Duration) Option {
+	return func(o *Options) {
+		o.CallOptions.ConnectionTimeout = t
+	}
+}
+
+// RequestTimeout set the request timeout.
+func RequestTimeout(d time.Duration) Option {
+	return func(o *Options) {
+		o.CallOptions.RequestTimeout = d
+	}
+}
+
+// StreamTimeout sets the stream timeout.
+func StreamTimeout(d time.Duration) Option {
+	return func(o *Options) {
+		o.CallOptions.StreamTimeout = d
+	}
+}
+
+// DialTimeout sets the transport dial timeout.
+func DialTimeout(d time.Duration) Option {
+	return func(o *Options) {
+		o.CallOptions.DialTimeout = d
+	}
+}
+
+// Call Options
+
+// WithExchange sets the exchange to route a message through.
+func WithExchange(e string) PublishOption {
+	return func(o *PublishOptions) {
+		o.Exchange = e
+	}
+}
+
+// PublishContext sets the context in publish options.
+func PublishContext(ctx context.Context) PublishOption {
+	return func(o *PublishOptions) {
+		o.Context = ctx
+	}
+}
+
+// WithAddress sets the remote addresses to use rather than using service discovery.
+func WithAddress(a ...string) CallOption {
+	return func(o *CallOptions) {
+		o.Address = a
+	}
+}
+
+func WithSelectOption(so ...selector.SelectOption) CallOption {
+	return func(o *CallOptions) {
+		o.SelectOptions = append(o.SelectOptions, so...)
+	}
+}
+
+// WithCallWrapper is a CallOption which adds to the existing CallFunc wrappers.
+func WithCallWrapper(cw ...CallWrapper) CallOption {
+	return func(o *CallOptions) {
+		o.CallWrappers = append(o.CallWrappers, cw...)
+	}
+}
+
+// WithBackoff is a CallOption which overrides that which
+// set in Options.CallOptions.
+func WithBackoff(fn BackoffFunc) CallOption {
+	return func(o *CallOptions) {
+		o.Backoff = fn
+	}
+}
+
+// WithRetry is a CallOption which overrides that which
+// set in Options.CallOptions.
+func WithRetry(fn RetryFunc) CallOption {
+	return func(o *CallOptions) {
+		o.Retry = fn
+	}
+}
+
+// WithRetries sets the number of tries for a call.
+// This CallOption overrides Options.CallOptions.
+func WithRetries(i int) CallOption {
+	return func(o *CallOptions) {
+		o.Retries = i
+	}
+}
+
+// WithRequestTimeout is a CallOption which overrides that which
+// set in Options.CallOptions.
+func WithRequestTimeout(d time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.RequestTimeout = d
+	}
+}
+
+// WithConnClose sets the Connection header to close.
+func WithConnClose() CallOption {
+	return func(o *CallOptions) {
+		o.ConnClose = true
+	}
+}
+
+// WithStreamTimeout sets the stream timeout.
+func WithStreamTimeout(d time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.StreamTimeout = d
+	}
+}
+
+// WithDialTimeout is a CallOption which overrides that which
+// set in Options.CallOptions.
+func WithDialTimeout(d time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.DialTimeout = d
+	}
+}
+
+// WithServiceToken is a CallOption which overrides the
+// authorization header with the services own auth token.
+func WithServiceToken() CallOption {
+	return func(o *CallOptions) {
+		o.ServiceToken = true
+	}
+}
+
+// WithCache is a CallOption which sets the duration the response
+// shoull be cached for.
+func WithCache(c time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.CacheExpiry = c
+	}
+}
+
+func WithMessageContentType(ct string) MessageOption {
+	return func(o *MessageOptions) {
+		o.ContentType = ct
+	}
+}
+
+func WithConnectionTimeout(d time.Duration) CallOption {
+	return func(o *CallOptions) {
+		o.ConnectionTimeout = d
+	}
+}
+
+// Request Options
+
+func WithContentType(ct string) RequestOption {
+	return func(o *RequestOptions) {
+		o.ContentType = ct
+	}
+}
+
+func StreamingRequest() RequestOption {
+	return func(o *RequestOptions) {
+		o.Stream = true
+	}
+}
+
+// WithRouter sets the client router.
+func WithRouter(r Router) Option {
+	return func(o *Options) {
+		o.Router = r
+	}
+}
+
+// WithLogger sets the underline logger.
+func WithLogger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}

client/options_test.go

@@ -0,0 +1,83 @@
+package client
+
+import (
+	"testing"
+	"time"
+
+	"go-micro.dev/v6/transport"
+)
+
+func TestCallOptions(t *testing.T) {
+	testData := []struct {
+		set      bool
+		retries  int
+		rtimeout time.Duration
+		dtimeout time.Duration
+	}{
+		{false, DefaultRetries, DefaultRequestTimeout, transport.DefaultDialTimeout},
+		{true, 10, time.Second, time.Second * 2},
+	}
+
+	for _, d := range testData {
+		var opts Options
+		var cl Client
+
+		if d.set {
+			opts = NewOptions(
+				Retries(d.retries),
+				RequestTimeout(d.rtimeout),
+				DialTimeout(d.dtimeout),
+			)
+
+			cl = NewClient(
+				Retries(d.retries),
+				RequestTimeout(d.rtimeout),
+				DialTimeout(d.dtimeout),
+			)
+		} else {
+			opts = NewOptions()
+			cl = NewClient()
+		}
+
+		// test options and those set in client
+		for _, o := range []Options{opts, cl.Options()} {
+			if o.CallOptions.Retries != d.retries {
+				t.Fatalf("Expected retries %v got %v", d.retries, o.CallOptions.Retries)
+			}
+
+			if o.CallOptions.RequestTimeout != d.rtimeout {
+				t.Fatalf("Expected request timeout %v got %v", d.rtimeout, o.CallOptions.RequestTimeout)
+			}
+
+			if o.CallOptions.DialTimeout != d.dtimeout {
+				t.Fatalf("Expected %v got %v", d.dtimeout, o.CallOptions.DialTimeout)
+			}
+
+			// copy CallOptions
+			callOpts := o.CallOptions
+
+			// create new opts
+			cretries := WithRetries(o.CallOptions.Retries * 10)
+			crtimeout := WithRequestTimeout(o.CallOptions.RequestTimeout * (time.Second * 10))
+			cdtimeout := WithDialTimeout(o.CallOptions.DialTimeout * (time.Second * 10))
+
+			// set call options
+			for _, opt := range []CallOption{cretries, crtimeout, cdtimeout} {
+				opt(&callOpts)
+			}
+
+			// check call options
+			if e := o.CallOptions.Retries * 10; callOpts.Retries != e {
+				t.Fatalf("Expected retries %v got %v", e, callOpts.Retries)
+			}
+
+			if e := o.CallOptions.RequestTimeout * (time.Second * 10); callOpts.RequestTimeout != e {
+				t.Fatalf("Expected request timeout %v got %v", e, callOpts.RequestTimeout)
+			}
+
+			if e := o.CallOptions.DialTimeout * (time.Second * 10); callOpts.DialTimeout != e {
+				t.Fatalf("Expected %v got %v", e, callOpts.DialTimeout)
+			}
+		}
+	}
+}

client/retry.go

@@ -0,0 +1,36 @@
+package client
+
+import (
+	"context"
+
+	"go-micro.dev/v6/errors"
+)
+
+// note that returning either false or a non-nil error will result in the call not being retried.
+type RetryFunc func(ctx context.Context, req Request, retryCount int, err error) (bool, error)
+
+// RetryAlways always retry on error.
+func RetryAlways(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
+	return true, nil
+}
+
+// RetryOnError retries a request on a 500 or timeout error.
+func RetryOnError(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
+	if err == nil {
+		return false, nil
+	}
+
+	e := errors.Parse(err.Error())
+	if e == nil {
+		return false, nil
+	}
+
+	switch e.Code {
+	// Retry on timeout, not on 500 internal server error, as that is a business
+	// logic error that should be handled by the user.
+	case 408:
+		return true, nil
+	default:
+		return false, nil
+	}
+}

client/rpc_client.go

@@ -0,0 +1,739 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/pkg/errors"
+
+	"go-micro.dev/v6/broker"
+	"go-micro.dev/v6/codec"
+	raw "go-micro.dev/v6/codec/bytes"
+	merrors "go-micro.dev/v6/errors"
+	"go-micro.dev/v6/internal/util/buf"
+	"go-micro.dev/v6/internal/util/net"
+	"go-micro.dev/v6/internal/util/pool"
+	log "go-micro.dev/v6/logger"
+	"go-micro.dev/v6/metadata"
+	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/selector"
+	"go-micro.dev/v6/transport"
+	"go-micro.dev/v6/transport/headers"
+)
+
+const (
+	packageID = "go.micro.client"
+)
+
+type rpcClient struct {
+	seq  uint64
+	opts Options
+	once atomic.Value
+	pool pool.Pool
+	mu   sync.RWMutex
+}
+
+func newRPCClient(opt ...Option) Client {
+	opts := NewOptions(opt...)
+
+	p := pool.NewPool(
+		pool.Size(opts.PoolSize),
+		pool.TTL(opts.PoolTTL),
+		pool.Transport(opts.Transport),
+		pool.CloseTimeout(opts.PoolCloseTimeout),
+	)
+
+	rc := &rpcClient{
+		opts: opts,
+		pool: p,
+		seq:  0,
+	}
+	rc.once.Store(false)
+
+	c := Client(rc)
+
+	// wrap in reverse
+	for i := len(opts.Wrappers); i > 0; i-- {
+		c = opts.Wrappers[i-1](c)
+	}
+
+	return c
+}
+
+func (r *rpcClient) newCodec(contentType string) (codec.NewCodec, error) {
+	if c, ok := r.opts.Codecs[contentType]; ok {
+		return c, nil
+	}
+
+	if cf, ok := DefaultCodecs[contentType]; ok {
+		return cf, nil
+	}
+
+	return nil, fmt.Errorf("unsupported Content-Type: %s", contentType)
+}
+
+func (r *rpcClient) call(
+	ctx context.Context,
+	node *registry.Node,
+	req Request,
+	resp interface{},
+	opts CallOptions,
+) error {
+	address := node.Address
+	logger := r.Options().Logger
+
+	msg := &transport.Message{
+		Header: make(map[string]string),
+	}
+
+	md, ok := metadata.FromContext(ctx)
+	if ok {
+		for k, v := range md {
+			// Don't copy Micro-Topic header, that is used for pub/sub
+			// this is fixes the case when the client uses the same context that
+			// is received in the subscriber.
+			if k == headers.Message {
+				continue
+			}
+
+			msg.Header[k] = v
+		}
+	}
+
+	// Set connection timeout for single requests to the server. Should be > 0
+	// as otherwise requests can't be made.
+	cTimeout := opts.ConnectionTimeout
+	if cTimeout == 0 {
+		logger.Log(log.DebugLevel, "connection timeout was set to 0, overridng to default connection timeout")
+
+		cTimeout = DefaultConnectionTimeout
+	}
+
+	// set timeout in nanoseconds
+	msg.Header["Timeout"] = fmt.Sprintf("%d", cTimeout)
+	// set the content type for the request
+	msg.Header["Content-Type"] = req.ContentType()
+	// set the accept header
+	msg.Header["Accept"] = req.ContentType()
+
+	// setup old protocol
+	reqCodec := setupProtocol(msg, node)
+
+	// no codec specified
+	if reqCodec == nil {
+		var err error
+		reqCodec, err = r.newCodec(req.ContentType())
+
+		if err != nil {
+			return merrors.InternalServerError("go.micro.client", err.Error())
+		}
+	}
+
+	dOpts := []transport.DialOption{
+		transport.WithStream(),
+	}
+
+	if opts.DialTimeout >= 0 {
+		dOpts = append(dOpts, transport.WithTimeout(opts.DialTimeout))
+	}
+
+	if opts.ConnClose {
+		dOpts = append(dOpts, transport.WithConnClose())
+	}
+
+	c, err := r.pool.Get(address, dOpts...)
+	if err != nil {
+		if c == nil {
+			return merrors.InternalServerError("go.micro.client", "connection error: %v", err)
+		}
+		logger.Log(log.ErrorLevel, "failed to close pool", err)
+	}
+
+	seq := atomic.AddUint64(&r.seq, 1) - 1
+	codec := newRPCCodec(msg, c, reqCodec, "")
+
+	rsp := &rpcResponse{
+		socket: c,
+		codec:  codec,
+	}
+
+	releaseFunc := func(err error) {
+		if err = r.pool.Release(c, err); err != nil {
+			logger.Log(log.ErrorLevel, "failed to release pool", err)
+		}
+	}
+
+	stream := &rpcStream{
+		id:       fmt.Sprintf("%v", seq),
+		context:  ctx,
+		request:  req,
+		response: rsp,
+		codec:    codec,
+		closed:   make(chan bool),
+		close:    opts.ConnClose,
+		release:  releaseFunc,
+		sendEOS:  false,
+	}
+
+	// close the stream on exiting this function
+	defer func() {
+		if err := stream.Close(); err != nil {
+			logger.Log(log.ErrorLevel, "failed to close stream", err)
+		}
+	}()
+
+	// wait for error response
+	ch := make(chan error, 1)
+
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				ch <- merrors.InternalServerError("go.micro.client", "panic recovered: %v", r)
+			}
+		}()
+
+		// send request
+		if err := stream.Send(req.Body()); err != nil {
+			ch <- err
+			return
+		}
+
+		// recv response
+		if err := stream.Recv(resp); err != nil {
+			ch <- err
+			return
+		}
+
+		// success
+		ch <- nil
+	}()
+
+	var grr error
+
+	select {
+	case err := <-ch:
+		return err
+	case <-time.After(cTimeout):
+		grr = merrors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
+	}
+
+	// set the stream error
+	if grr != nil {
+		stream.Lock()
+		stream.err = grr
+		stream.Unlock()
+
+		return grr
+	}
+
+	return nil
+}
+
+func (r *rpcClient) stream(ctx context.Context, node *registry.Node, req Request, opts CallOptions) (Stream, error) {
+	address := node.Address
+	logger := r.Options().Logger
+
+	msg := &transport.Message{
+		Header: make(map[string]string),
+	}
+
+	md, ok := metadata.FromContext(ctx)
+	if ok {
+		for k, v := range md {
+			msg.Header[k] = v
+		}
+	}
+
+	// set timeout in nanoseconds
+	if opts.StreamTimeout > time.Duration(0) {
+		msg.Header["Timeout"] = fmt.Sprintf("%d", opts.StreamTimeout)
+	}
+	// set the content type for the request
+	msg.Header["Content-Type"] = req.ContentType()
+	// set the accept header
+	msg.Header["Accept"] = req.ContentType()
+
+	// set old codecs
+	nCodec := setupProtocol(msg, node)
+
+	// no codec specified
+	if nCodec == nil {
+		var err error
+
+		nCodec, err = r.newCodec(req.ContentType())
+		if err != nil {
+			return nil, merrors.InternalServerError("go.micro.client", err.Error())
+		}
+	}
+
+	dOpts := []transport.DialOption{
+		transport.WithStream(),
+	}
+
+	if opts.DialTimeout >= 0 {
+		dOpts = append(dOpts, transport.WithTimeout(opts.DialTimeout))
+	}
+
+	c, err := r.opts.Transport.Dial(address, dOpts...)
+	if err != nil {
+		return nil, merrors.InternalServerError("go.micro.client", "connection error: %v", err)
+	}
+
+	// increment the sequence number
+	seq := atomic.AddUint64(&r.seq, 1) - 1
+	id := fmt.Sprintf("%v", seq)
+
+	// create codec with stream id
+	codec := newRPCCodec(msg, c, nCodec, id)
+
+	rsp := &rpcResponse{
+		socket: c,
+		codec:  codec,
+	}
+
+	// set request codec
+	if r, ok := req.(*rpcRequest); ok {
+		r.codec = codec
+	}
+
+	stream := &rpcStream{
+		id:       id,
+		context:  ctx,
+		request:  req,
+		response: rsp,
+		codec:    codec,
+		// used to close the stream
+		closed: make(chan bool),
+		// signal the end of stream,
+		sendEOS: true,
+		release: func(_ error) {},
+	}
+
+	// wait for error response
+	ch := make(chan error, 1)
+
+	go func() {
+		// send the first message
+		ch <- stream.Send(req.Body())
+	}()
+
+	var grr error
+
+	select {
+	case err := <-ch:
+		grr = err
+	case <-ctx.Done():
+		grr = merrors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
+	}
+
+	if grr != nil {
+		// set the error
+		stream.Lock()
+		stream.err = grr
+		stream.Unlock()
+
+		// close the stream
+		if err := stream.Close(); err != nil {
+			logger.Logf(log.ErrorLevel, "failed to close stream: %v", err)
+		}
+
+		return nil, grr
+	}
+
+	return stream, nil
+}
+
+func (r *rpcClient) Init(opts ...Option) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	size := r.opts.PoolSize
+	ttl := r.opts.PoolTTL
+	tr := r.opts.Transport
+
+	for _, o := range opts {
+		o(&r.opts)
+	}
+
+	// update pool configuration if the options changed
+	if size != r.opts.PoolSize || ttl != r.opts.PoolTTL || tr != r.opts.Transport {
+		// close existing pool
+		if err := r.pool.Close(); err != nil {
+			return errors.Wrap(err, "failed to close pool")
+		}
+
+		// create new pool
+		r.pool = pool.NewPool(
+			pool.Size(r.opts.PoolSize),
+			pool.TTL(r.opts.PoolTTL),
+			pool.Transport(r.opts.Transport),
+			pool.CloseTimeout(r.opts.PoolCloseTimeout),
+		)
+	}
+
+	return nil
+}
+
+// Options retrives the options.
+func (r *rpcClient) Options() Options {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	return r.opts
+}
+
+// next returns an iterator for the next nodes to call.
+func (r *rpcClient) next(request Request, opts CallOptions) (selector.Next, error) {
+	// try get the proxy
+	service, address, _ := net.Proxy(request.Service(), opts.Address)
+
+	// return remote address
+	if len(address) > 0 {
+		nodes := make([]*registry.Node, len(address))
+
+		for i, addr := range address {
+			nodes[i] = &registry.Node{
+				Address: addr,
+				// Set the protocol
+				Metadata: map[string]string{
+					"protocol": "mucp",
+				},
+			}
+		}
+
+		// crude return method
+		return func() (*registry.Node, error) {
+			return nodes[time.Now().Unix()%int64(len(nodes))], nil
+		}, nil
+	}
+
+	// get next nodes from the selector
+	next, err := r.opts.Selector.Select(service, opts.SelectOptions...)
+	if err != nil {
+		if errors.Is(err, selector.ErrNotFound) {
+			return nil, merrors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+		}
+
+		return nil, merrors.InternalServerError("go.micro.client", "error selecting %s node: %s", service, err.Error())
+	}
+
+	return next, nil
+}
+
+func (r *rpcClient) Call(ctx context.Context, request Request, response interface{}, opts ...CallOption) error {
+	// TODO: further validate these mutex locks. full lock would prevent
+	// parallel calls. Maybe we can set individual locks for secctions.
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	// make a copy of call opts
+	callOpts := r.opts.CallOptions
+	for _, opt := range opts {
+		opt(&callOpts)
+	}
+
+	next, err := r.next(request, callOpts)
+	if err != nil {
+		return err
+	}
+
+	// check if we already have a deadline
+	d, ok := ctx.Deadline()
+	if !ok {
+		// no deadline so we create a new one
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, callOpts.RequestTimeout)
+
+		defer cancel()
+	} else {
+		// got a deadline so no need to setup context
+		// but we need to set the timeout we pass along
+		opt := WithRequestTimeout(time.Until(d))
+		opt(&callOpts)
+	}
+
+	// should we noop right here?
+	select {
+	case <-ctx.Done():
+		return merrors.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)
+	}
+
+	// return errors.New("go.micro.client", "request timeout", 408)
+	call := func(i int) error {
+		// call backoff first. Someone may want an initial start delay
+		t, err := callOpts.Backoff(ctx, request, i)
+		if err != nil {
+			return merrors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
+		}
+
+		// only sleep if greater than 0
+		if t.Seconds() > 0 {
+			time.Sleep(t)
+		}
+
+		// select next node
+		node, err := next()
+		service := request.Service()
+
+		if err != nil {
+			if errors.Is(err, selector.ErrNotFound) {
+				return merrors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+			}
+
+			return merrors.InternalServerError("go.micro.client",
+				"error getting next %s node: %s",
+				service,
+				err.Error())
+		}
+
+		// make the call
+		err = rcall(ctx, node, request, response, callOpts)
+		r.opts.Selector.Mark(service, node, err)
+
+		return err
+	}
+
+	// get the retries
+	retries := callOpts.Retries
+
+	// disable retries when using a proxy
+	// Note: I don't see why we should disable retries for proxies, so commenting out.
+	// if _, _, ok := net.Proxy(request.Service(), callOpts.Address); ok {
+	// 	retries = 0
+	// }
+
+	ch := make(chan error, retries+1)
+
+	var gerr error
+
+	for i := 0; i <= retries; i++ {
+		go func(i int) {
+			ch <- call(i)
+		}(i)
+
+		select {
+		case <-ctx.Done():
+			return merrors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
+		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
+			}
+
+			r.opts.Logger.Logf(log.DebugLevel, "Retrying request. Previous attempt failed with: %v", err)
+
+			gerr = err
+		}
+	}
+
+	return gerr
+}
+
+func (r *rpcClient) Stream(ctx context.Context, request Request, opts ...CallOption) (Stream, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	// make a copy of call opts
+	callOpts := r.opts.CallOptions
+	for _, opt := range opts {
+		opt(&callOpts)
+	}
+
+	next, err := r.next(request, callOpts)
+	if err != nil {
+		return nil, err
+	}
+
+	select {
+	case <-ctx.Done():
+		return nil, merrors.Timeout("go.micro.client", fmt.Sprintf("%v", ctx.Err()))
+	default:
+	}
+
+	call := func(i int) (Stream, error) {
+		// call backoff first. Someone may want an initial start delay
+		t, err := callOpts.Backoff(ctx, request, i)
+		if err != nil {
+			return nil, merrors.InternalServerError("go.micro.client", "backoff error: %v", err.Error())
+		}
+
+		// only sleep if greater than 0
+		if t.Seconds() > 0 {
+			time.Sleep(t)
+		}
+
+		node, err := next()
+		service := request.Service()
+
+		if err != nil {
+			if errors.Is(err, selector.ErrNotFound) {
+				return nil, merrors.InternalServerError("go.micro.client", "service %s: %s", service, err.Error())
+			}
+
+			return nil, merrors.InternalServerError("go.micro.client",
+				"error getting next %s node: %s",
+				service,
+				err.Error())
+		}
+
+		stream, err := r.stream(ctx, node, request, callOpts)
+		r.opts.Selector.Mark(service, node, err)
+
+		return stream, err
+	}
+
+	type response struct {
+		stream Stream
+		err    error
+	}
+
+	// get the retries
+	retries := callOpts.Retries
+
+	// disable retries when using a proxy
+	if _, _, ok := net.Proxy(request.Service(), callOpts.Address); ok {
+		retries = 0
+	}
+
+	ch := make(chan response, retries+1)
+
+	var grr error
+
+	for i := 0; i <= retries; i++ {
+		go func(i int) {
+			s, err := call(i)
+			ch <- response{s, err}
+		}(i)
+
+		select {
+		case <-ctx.Done():
+			return nil, merrors.Timeout("go.micro.client", fmt.Sprintf("call timeout: %v", ctx.Err()))
+		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
+			}
+
+			grr = rsp.err
+		}
+	}
+
+	return nil, grr
+}
+
+func (r *rpcClient) Publish(ctx context.Context, msg Message, opts ...PublishOption) error {
+	options := PublishOptions{
+		Context: context.Background(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	metadata, ok := metadata.FromContext(ctx)
+	if !ok {
+		metadata = make(map[string]string)
+	}
+
+	id := uuid.New().String()
+	metadata["Content-Type"] = msg.ContentType()
+	metadata[headers.Message] = msg.Topic()
+	metadata[headers.ID] = id
+
+	// set the topic
+	topic := msg.Topic()
+
+	// get the exchange
+	if len(options.Exchange) > 0 {
+		topic = options.Exchange
+	}
+
+	// encode message body
+	cf, err := r.newCodec(msg.ContentType())
+	if err != nil {
+		return merrors.InternalServerError(packageID, err.Error())
+	}
+
+	var body []byte
+
+	// passed in raw data
+	if d, ok := msg.Payload().(*raw.Frame); ok {
+		body = d.Data
+	} else {
+		b := buf.New(nil)
+
+		if err = cf(b).Write(&codec.Message{
+			Target: topic,
+			Type:   codec.Event,
+			Header: map[string]string{
+				headers.ID:      id,
+				headers.Message: msg.Topic(),
+			},
+		}, msg.Payload()); err != nil {
+			return merrors.InternalServerError(packageID, err.Error())
+		}
+
+		// set the body
+		body = b.Bytes()
+	}
+
+	l, ok := r.once.Load().(bool)
+	if !ok {
+		return fmt.Errorf("failed to cast to bool")
+	}
+
+	if !l {
+		if err = r.opts.Broker.Connect(); err != nil {
+			return merrors.InternalServerError(packageID, err.Error())
+		}
+
+		r.once.Store(true)
+	}
+
+	return r.opts.Broker.Publish(topic, &broker.Message{
+		Header: metadata,
+		Body:   body,
+	}, broker.PublishContext(options.Context))
+}
+
+func (r *rpcClient) NewMessage(topic string, message interface{}, opts ...MessageOption) Message {
+	return newMessage(topic, message, r.opts.ContentType, opts...)
+}
+
+func (r *rpcClient) NewRequest(service, method string, request interface{}, reqOpts ...RequestOption) Request {
+	return newRequest(service, method, request, r.opts.ContentType, reqOpts...)
+}
+
+func (r *rpcClient) String() string {
+	return "mucp"
+}

client/rpc_client_test.go

@@ -0,0 +1,177 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"go-micro.dev/v6/errors"
+	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/selector"
+)
+
+const (
+	serviceName     = "test.service"
+	serviceEndpoint = "Test.Endpoint"
+)
+
+func newTestRegistry() registry.Registry {
+	return registry.NewMemoryRegistry(registry.Services(testData))
+}
+
+func TestCallAddress(t *testing.T) {
+	var called bool
+	service := serviceName
+	endpoint := serviceEndpoint
+	address := "10.1.10.1:8080"
+
+	wrap := func(cf CallFunc) CallFunc {
+		return func(_ context.Context, node *registry.Node, req Request, _ interface{}, _ CallOptions) error {
+			called = true
+
+			if req.Service() != service {
+				return fmt.Errorf("expected service: %s got %s", service, req.Service())
+			}
+
+			if req.Endpoint() != endpoint {
+				return fmt.Errorf("expected service: %s got %s", endpoint, req.Endpoint())
+			}
+
+			if node.Address != address {
+				return fmt.Errorf("expected address: %s got %s", address, node.Address)
+			}
+
+			// don't do the call
+			return nil
+		}
+	}
+
+	r := newTestRegistry()
+	c := NewClient(
+		Registry(r),
+		WrapCall(wrap),
+	)
+
+	if err := c.Options().Selector.Init(selector.Registry(r)); err != nil {
+		t.Fatal("failed to initialize selector", err)
+	}
+
+	req := c.NewRequest(service, endpoint, nil)
+
+	// test calling remote address
+	if err := c.Call(context.Background(), req, nil, WithAddress(address)); err != nil {
+		t.Fatal("call with address error", err)
+	}
+
+	if !called {
+		t.Fatal("wrapper not called")
+	}
+}
+
+func TestCallRetry(t *testing.T) {
+	service := "test.service"
+	endpoint := "Test.Endpoint"
+	address := "10.1.10.1"
+
+	var called int
+
+	wrap := func(cf CallFunc) CallFunc {
+		return func(_ context.Context, _ *registry.Node, _ Request, _ interface{}, _ CallOptions) error {
+			called++
+			if called == 1 {
+				return errors.InternalServerError("test.error", "retry request")
+			}
+			// don't do the call
+			return nil
+		}
+	}
+
+	r := newTestRegistry()
+	c := NewClient(
+		Registry(r),
+		WrapCall(wrap),
+		Retry(RetryAlways),
+		Retries(1),
+	)
+
+	if err := c.Options().Selector.Init(selector.Registry(r)); err != nil {
+		t.Fatal("failed to initialize selector", err)
+	}
+
+	req := c.NewRequest(service, endpoint, nil)
+
+	// test calling remote address
+	if err := c.Call(context.Background(), req, nil, WithAddress(address)); err != nil {
+		t.Fatal("call with address error", err)
+	}
+
+	// num calls
+	if called < c.Options().CallOptions.Retries+1 {
+		t.Fatal("request not retried")
+	}
+}
+
+func TestCallWrapper(t *testing.T) {
+	var called bool
+	id := "test.1"
+	service := "test.service"
+	endpoint := "Test.Endpoint"
+	address := "10.1.10.1:8080"
+
+	wrap := func(cf CallFunc) CallFunc {
+		return func(_ context.Context, node *registry.Node, req Request, _ interface{}, _ CallOptions) error {
+			called = true
+
+			if req.Service() != service {
+				return fmt.Errorf("expected service: %s got %s", service, req.Service())
+			}
+
+			if req.Endpoint() != endpoint {
+				return fmt.Errorf("expected service: %s got %s", endpoint, req.Endpoint())
+			}
+
+			if node.Address != address {
+				return fmt.Errorf("expected address: %s got %s", address, node.Address)
+			}
+
+			// don't do the call
+			return nil
+		}
+	}
+
+	r := newTestRegistry()
+	c := NewClient(
+		Registry(r),
+		WrapCall(wrap),
+	)
+
+	if err := c.Options().Selector.Init(selector.Registry(r)); err != nil {
+		t.Fatal("failed to initialize selector", err)
+	}
+
+	err := r.Register(&registry.Service{
+		Name:    service,
+		Version: "latest",
+		Nodes: []*registry.Node{
+			{
+				Id:      id,
+				Address: address,
+				Metadata: map[string]string{
+					"protocol": "mucp",
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal("failed to register service", err)
+	}
+
+	req := c.NewRequest(service, endpoint, nil)
+	if err := c.Call(context.Background(), req, nil); err != nil {
+		t.Fatal("call wrapper error", err)
+	}
+
+	if !called {
+		t.Fatal("wrapper not called")
+	}
+}

client/rpc_codec.go

@@ -0,0 +1,282 @@
+package client
+
+import (
+	"bytes"
+	errs "errors"
+
+	"go-micro.dev/v6/codec"
+	raw "go-micro.dev/v6/codec/bytes"
+	"go-micro.dev/v6/codec/grpc"
+	"go-micro.dev/v6/codec/json"
+	"go-micro.dev/v6/codec/jsonrpc"
+	"go-micro.dev/v6/codec/proto"
+	"go-micro.dev/v6/codec/protorpc"
+	"go-micro.dev/v6/errors"
+	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/transport"
+	"go-micro.dev/v6/transport/headers"
+)
+
+const (
+	lastStreamResponseError = "EOS"
+)
+
+// serverError represents an error that has been returned from
+// the remote side of the RPC connection.
+type serverError string
+
+func (e serverError) Error() string {
+	return string(e)
+}
+
+// errShutdown holds the specific error for closing/closed connections.
+var (
+	errShutdown = errs.New("connection is shut down")
+)
+
+type rpcCodec struct {
+	client transport.Client
+	codec  codec.Codec
+
+	req *transport.Message
+	buf *readWriteCloser
+
+	// signify if its a stream
+	stream string
+}
+
+type readWriteCloser struct {
+	wbuf *bytes.Buffer
+	rbuf *bytes.Buffer
+}
+
+var (
+	// DefaultContentType header.
+	DefaultContentType = "application/json"
+
+	// DefaultCodecs map.
+	DefaultCodecs = map[string]codec.NewCodec{
+		"application/grpc":         grpc.NewCodec,
+		"application/grpc+json":    grpc.NewCodec,
+		"application/grpc+proto":   grpc.NewCodec,
+		"application/protobuf":     proto.NewCodec,
+		"application/json":         json.NewCodec,
+		"application/json-rpc":     jsonrpc.NewCodec,
+		"application/proto-rpc":    protorpc.NewCodec,
+		"application/octet-stream": raw.NewCodec,
+	}
+
+	// TODO: remove legacy codec list.
+	defaultCodecs = map[string]codec.NewCodec{
+		"application/json":         jsonrpc.NewCodec,
+		"application/json-rpc":     jsonrpc.NewCodec,
+		"application/protobuf":     protorpc.NewCodec,
+		"application/proto-rpc":    protorpc.NewCodec,
+		"application/octet-stream": protorpc.NewCodec,
+	}
+)
+
+func (rwc *readWriteCloser) Read(p []byte) (n int, err error) {
+	return rwc.rbuf.Read(p)
+}
+
+func (rwc *readWriteCloser) Write(p []byte) (n int, err error) {
+	return rwc.wbuf.Write(p)
+}
+
+func (rwc *readWriteCloser) Close() error {
+	rwc.rbuf.Reset()
+	rwc.wbuf.Reset()
+
+	return nil
+}
+
+func getHeaders(m *codec.Message) {
+	set := func(v, hdr string) string {
+		if len(v) > 0 {
+			return v
+		}
+
+		return m.Header[hdr]
+	}
+
+	// check error in header
+	m.Error = set(m.Error, headers.Error)
+
+	// check endpoint in header
+	m.Endpoint = set(m.Endpoint, headers.Endpoint)
+
+	// check method in header
+	m.Method = set(m.Method, headers.Method)
+
+	// set the request id
+	m.Id = set(m.Id, headers.ID)
+}
+
+func setHeaders(m *codec.Message, stream string) {
+	set := func(hdr, v string) {
+		if len(v) == 0 {
+			return
+		}
+
+		m.Header[hdr] = v
+	}
+
+	set(headers.ID, m.Id)
+	set(headers.Request, m.Target)
+	set(headers.Method, m.Method)
+	set(headers.Endpoint, m.Endpoint)
+	set(headers.Error, m.Error)
+
+	if len(stream) > 0 {
+		set(headers.Stream, stream)
+	}
+}
+
+// setupProtocol sets up the old protocol.
+func setupProtocol(msg *transport.Message, node *registry.Node) codec.NewCodec {
+	protocol := node.Metadata["protocol"]
+
+	// got protocol
+	if len(protocol) > 0 {
+		return nil
+	}
+
+	// processing topic publishing
+	if len(msg.Header[headers.Message]) > 0 {
+		return nil
+	}
+
+	// no protocol use old codecs
+	switch msg.Header["Content-Type"] {
+	case "application/json":
+		msg.Header["Content-Type"] = "application/json-rpc"
+	case "application/protobuf":
+		msg.Header["Content-Type"] = "application/proto-rpc"
+	}
+
+	return defaultCodecs[msg.Header["Content-Type"]]
+}
+
+func newRPCCodec(req *transport.Message, client transport.Client, c codec.NewCodec, stream string) codec.Codec {
+	rwc := &readWriteCloser{
+		wbuf: bytes.NewBuffer(nil),
+		rbuf: bytes.NewBuffer(nil),
+	}
+
+	return &rpcCodec{
+		buf:    rwc,
+		client: client,
+		codec:  c(rwc),
+		req:    req,
+		stream: stream,
+	}
+}
+
+func (c *rpcCodec) Write(message *codec.Message, body interface{}) error {
+	c.buf.wbuf.Reset()
+
+	// create header
+	if message.Header == nil {
+		message.Header = map[string]string{}
+	}
+
+	// copy original header
+	for k, v := range c.req.Header {
+		message.Header[k] = v
+	}
+
+	// set the mucp headers
+	setHeaders(message, c.stream)
+
+	// if body is bytes Frame don't encode
+	if body != nil {
+		if b, ok := body.(*raw.Frame); ok {
+			// set body
+			message.Body = b.Data
+		} else {
+			// write to codec
+			if err := c.codec.Write(message, body); err != nil {
+				return errors.InternalServerError("go.micro.client.codec", err.Error())
+			}
+			// set body
+			message.Body = c.buf.wbuf.Bytes()
+		}
+	}
+
+	// create new transport message
+	msg := transport.Message{
+		Header: message.Header,
+		Body:   message.Body,
+	}
+
+	// send the request
+	if err := c.client.Send(&msg); err != nil {
+		return errors.InternalServerError("go.micro.client.transport", err.Error())
+	}
+
+	return nil
+}
+
+func (c *rpcCodec) ReadHeader(msg *codec.Message, r codec.MessageType) error {
+	var tm transport.Message
+
+	// read message from transport
+	if err := c.client.Recv(&tm); err != nil {
+		return errors.InternalServerError("go.micro.client.transport", err.Error())
+	}
+
+	c.buf.rbuf.Reset()
+	c.buf.rbuf.Write(tm.Body)
+
+	// set headers from transport
+	msg.Header = tm.Header
+
+	// read header
+	err := c.codec.ReadHeader(msg, r)
+
+	// get headers
+	getHeaders(msg)
+
+	// return header error
+	if err != nil {
+		return errors.InternalServerError("go.micro.client.codec", err.Error())
+	}
+
+	return nil
+}
+
+func (c *rpcCodec) ReadBody(b interface{}) error {
+	// read body
+	// read raw data
+	if v, ok := b.(*raw.Frame); ok {
+		v.Data = c.buf.rbuf.Bytes()
+		return nil
+	}
+
+	if err := c.codec.ReadBody(b); err != nil {
+		return errors.InternalServerError("go.micro.client.codec", err.Error())
+	}
+
+	return nil
+}
+
+func (c *rpcCodec) Close() error {
+	if err := c.buf.Close(); err != nil {
+		return err
+	}
+
+	if err := c.codec.Close(); err != nil {
+		return err
+	}
+
+	if err := c.client.Close(); err != nil {
+		return errors.InternalServerError("go.micro.client.transport", err.Error())
+	}
+
+	return nil
+}
+
+func (c *rpcCodec) String() string {
+	return "rpc"
+}

client/rpc_message.go

@@ -0,0 +1,36 @@
+package client
+
+type message struct {
+	payload     interface{}
+	topic       string
+	contentType string
+}
+
+func newMessage(topic string, payload interface{}, contentType string, opts ...MessageOption) Message {
+	var options MessageOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if len(options.ContentType) > 0 {
+		contentType = options.ContentType
+	}
+
+	return &message{
+		payload:     payload,
+		topic:       topic,
+		contentType: contentType,
+	}
+}
+
+func (m *message) ContentType() string {
+	return m.contentType
+}
+
+func (m *message) Topic() string {
+	return m.topic
+}
+
+func (m *message) Payload() interface{} {
+	return m.payload
+}

client/rpc_request.go

@@ -0,0 +1,65 @@
+package client
+
+import (
+	"go-micro.dev/v6/codec"
+)
+
+type rpcRequest struct {
+	opts        RequestOptions
+	codec       codec.Codec
+	body        interface{}
+	service     string
+	method      string
+	endpoint    string
+	contentType string
+}
+
+func newRequest(service, endpoint string, request interface{}, contentType string, reqOpts ...RequestOption) Request {
+	var opts RequestOptions
+
+	for _, o := range reqOpts {
+		o(&opts)
+	}
+
+	// set the content-type specified
+	if len(opts.ContentType) > 0 {
+		contentType = opts.ContentType
+	}
+
+	return &rpcRequest{
+		service:     service,
+		method:      endpoint,
+		endpoint:    endpoint,
+		body:        request,
+		contentType: contentType,
+		opts:        opts,
+	}
+}
+
+func (r *rpcRequest) ContentType() string {
+	return r.contentType
+}
+
+func (r *rpcRequest) Service() string {
+	return r.service
+}
+
+func (r *rpcRequest) Method() string {
+	return r.method
+}
+
+func (r *rpcRequest) Endpoint() string {
+	return r.endpoint
+}
+
+func (r *rpcRequest) Body() interface{} {
+	return r.body
+}
+
+func (r *rpcRequest) Codec() codec.Writer {
+	return r.codec
+}
+
+func (r *rpcRequest) Stream() bool {
+	return r.opts.Stream
+}

client/rpc_request_test.go

@@ -0,0 +1,23 @@
+package client
+
+import (
+	"testing"
+)
+
+func TestRequestOptions(t *testing.T) {
+	r := newRequest("service", "endpoint", nil, "application/json")
+	if r.Service() != "service" {
+		t.Fatalf("expected 'service' got %s", r.Service())
+	}
+	if r.Endpoint() != "endpoint" {
+		t.Fatalf("expected 'endpoint' got %s", r.Endpoint())
+	}
+	if r.ContentType() != "application/json" {
+		t.Fatalf("expected 'endpoint' got %s", r.ContentType())
+	}
+
+	r2 := newRequest("service", "endpoint", nil, "application/json", WithContentType("application/protobuf"))
+	if r2.ContentType() != "application/protobuf" {
+		t.Fatalf("expected 'endpoint' got %s", r2.ContentType())
+	}
+}

client/rpc_response.go

@@ -0,0 +1,35 @@
+package client
+
+import (
+	"go-micro.dev/v6/codec"
+	"go-micro.dev/v6/transport"
+)
+
+type rpcResponse struct {
+	socket transport.Socket
+	codec  codec.Codec
+	header map[string]string
+	body   []byte
+}
+
+func (r *rpcResponse) Codec() codec.Reader {
+	return r.codec
+}
+
+func (r *rpcResponse) Header() map[string]string {
+	return r.header
+}
+
+func (r *rpcResponse) Read() ([]byte, error) {
+	var msg transport.Message
+
+	if err := r.socket.Recv(&msg); err != nil {
+		return nil, err
+	}
+
+	// set internals
+	r.header = msg.Header
+	r.body = msg.Body
+
+	return msg.Body, nil
+}

client/rpc_stream.go

@@ -0,0 +1,187 @@
+package client
+
+import (
+	"context"
+	"errors"
+	"io"
+	"sync"
+
+	"go-micro.dev/v6/codec"
+)
+
+// Implements the streamer interface.
+type rpcStream struct {
+	err      error
+	request  Request
+	response Response
+	codec    codec.Codec
+	context  context.Context
+
+	closed chan bool
+
+	// release releases the connection back to the pool
+	release func(err error)
+	id      string
+	sync.RWMutex
+	// Indicates whether connection should be closed directly.
+	close bool
+
+	// signal whether we should send EOS
+	sendEOS bool
+}
+
+func (r *rpcStream) isClosed() bool {
+	select {
+	case <-r.closed:
+		return true
+	default:
+		return false
+	}
+}
+
+func (r *rpcStream) Context() context.Context {
+	return r.context
+}
+
+func (r *rpcStream) Request() Request {
+	return r.request
+}
+
+func (r *rpcStream) Response() Response {
+	return r.response
+}
+
+func (r *rpcStream) Send(msg interface{}) error {
+	r.Lock()
+	defer r.Unlock()
+
+	if r.isClosed() {
+		r.err = errShutdown
+		return errShutdown
+	}
+
+	req := codec.Message{
+		Id:       r.id,
+		Target:   r.request.Service(),
+		Method:   r.request.Method(),
+		Endpoint: r.request.Endpoint(),
+		Type:     codec.Request,
+	}
+
+	if err := r.codec.Write(&req, msg); err != nil {
+		r.err = err
+		return err
+	}
+
+	return nil
+}
+
+func (r *rpcStream) Recv(msg interface{}) error {
+	r.Lock()
+
+	if r.isClosed() {
+		r.err = errShutdown
+		r.Unlock()
+
+		return errShutdown
+	}
+
+	var resp codec.Message
+
+	r.Unlock()
+	err := r.codec.ReadHeader(&resp, codec.Response)
+	r.Lock()
+
+	if err != nil {
+		if errors.Is(err, io.EOF) && !r.isClosed() {
+			r.err = io.ErrUnexpectedEOF
+			r.Unlock()
+
+			return io.ErrUnexpectedEOF
+		}
+
+		r.err = err
+
+		r.Unlock()
+
+		return err
+	}
+
+	switch {
+	case len(resp.Error) > 0:
+		// We've got an error response. Give this to the request;
+		// any subsequent requests will get the ReadResponseBody
+		// error if there is one.
+		if resp.Error != lastStreamResponseError {
+			r.err = serverError(resp.Error)
+		} else {
+			r.err = io.EOF
+		}
+		r.Unlock()
+		err = r.codec.ReadBody(nil)
+		r.Lock()
+		if err != nil {
+			r.err = err
+		}
+	default:
+		r.Unlock()
+		err = r.codec.ReadBody(msg)
+		r.Lock()
+		if err != nil {
+			r.err = err
+		}
+	}
+
+	defer r.Unlock()
+
+	return r.err
+}
+
+func (r *rpcStream) Error() error {
+	r.RLock()
+	defer r.RUnlock()
+
+	return r.err
+}
+
+func (r *rpcStream) CloseSend() error {
+	return errors.New("streamer not implemented")
+}
+
+func (r *rpcStream) Close() error {
+	r.Lock()
+
+	select {
+	case <-r.closed:
+		r.Unlock()
+		return nil
+	default:
+		close(r.closed)
+		r.Unlock()
+
+		// send the end of stream message
+		if r.sendEOS {
+			// no need to check for error
+			//nolint:errcheck,gosec
+			r.codec.Write(&codec.Message{
+				Id:       r.id,
+				Target:   r.request.Service(),
+				Method:   r.request.Method(),
+				Endpoint: r.request.Endpoint(),
+				Type:     codec.Error,
+				Error:    lastStreamResponseError,
+			}, nil)
+		}
+
+		err := r.codec.Close()
+
+		rerr := r.Error()
+		if r.close && rerr == nil {
+			rerr = errors.New("connection header set to close")
+		}
+		// release the connection
+		r.release(rerr)
+
+		return err
+	}
+}

client/wrapper.go

@@ -0,0 +1,19 @@
+package client
+
+import (
+	"context"
+
+	"go-micro.dev/v6/registry"
+)
+
+// CallFunc represents the individual call func.
+type CallFunc func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error
+
+// CallWrapper is a low level wrapper for the CallFunc.
+type CallWrapper func(CallFunc) CallFunc
+
+// Wrapper wraps a client and returns a client.
+type Wrapper func(Client) Client
+
+// StreamWrapper wraps a Stream and returns the equivalent.
+type StreamWrapper func(Stream) Stream