go-micro: github.com/micro/go-micro/client Index | Files | Directories

package client

import "github.com/micro/go-micro/client"

Package client is an interface for an RPC client


Package Files

backoff.go cache.go client.go context.go options.go retry.go rpc_client.go rpc_codec.go rpc_message.go rpc_request.go rpc_response.go rpc_stream.go wrapper.go


var (
    // DefaultClient is a default client to use out of the box
    DefaultClient Client = newRpcClient()
    // 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 = 1
    // DefaultRequestTimeout is the default request timeout
    DefaultRequestTimeout = time.Second * 5
    // DefaultPoolSize sets the connection pool size
    DefaultPoolSize = 100
    // DefaultPoolTTL sets the connection pool ttl
    DefaultPoolTTL = time.Minute

    // NewClient returns a new client
    NewClient func(...Option) Client = newRpcClient
var (
    DefaultContentType = "application/protobuf"

    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,

func Call Uses

func Call(ctx context.Context, request Request, response interface{}, opts ...CallOption) error

Makes a synchronous call to a service using the default client

func NewContext Uses

func NewContext(ctx context.Context, c Client) context.Context

func Publish Uses

func Publish(ctx context.Context, msg Message, opts ...PublishOption) error

Publishes a publication using the default client. Using the underlying broker set within the options.

func RetryAlways Uses

func RetryAlways(ctx context.Context, req Request, retryCount int, err error) (bool, error)

RetryAlways always retry on error

func RetryOnError Uses

func RetryOnError(ctx context.Context, req Request, retryCount int, err error) (bool, error)

RetryOnError retries a request on a 500 or timeout error

func String Uses

func String() string

type BackoffFunc Uses

type BackoffFunc func(ctx context.Context, req Request, attempts int) (time.Duration, error)

type Cache Uses

type Cache struct {
    // contains filtered or unexported fields

Cache for responses

func NewCache Uses

func NewCache() *Cache

NewCache returns an initialised cache.

func (*Cache) Get Uses

func (c *Cache) Get(ctx context.Context, req *Request) (interface{}, bool)

Get a response from the cache

func (*Cache) List Uses

func (c *Cache) List() map[string]string

List the key value pairs in the cache

func (*Cache) Set Uses

func (c *Cache) Set(ctx context.Context, req *Request, rsp interface{}, expiry time.Duration)

Set a response in the cache

type CallFunc Uses

type CallFunc func(ctx context.Context, node *registry.Node, req Request, rsp interface{}, opts CallOptions) error

CallFunc represents the individual call func

type CallOption Uses

type CallOption func(*CallOptions)

CallOption used by Call or Stream

func WithAddress Uses

func WithAddress(a ...string) CallOption

WithAddress sets the remote addresses to use rather than using service discovery

func WithBackoff Uses

func WithBackoff(fn BackoffFunc) CallOption

WithBackoff is a CallOption which overrides that which set in Options.CallOptions

func WithCache Uses

func WithCache(c time.Duration) CallOption

WithCache is a CallOption which sets the duration the response shoull be cached for

func WithCallWrapper Uses

func WithCallWrapper(cw ...CallWrapper) CallOption

WithCallWrapper is a CallOption which adds to the existing CallFunc wrappers

func WithDialTimeout Uses

func WithDialTimeout(d time.Duration) CallOption

WithDialTimeout is a CallOption which overrides that which set in Options.CallOptions

func WithRequestTimeout Uses

func WithRequestTimeout(d time.Duration) CallOption

WithRequestTimeout is a CallOption which overrides that which set in Options.CallOptions

func WithRetries Uses

func WithRetries(i int) CallOption

WithRetries is a CallOption which overrides that which set in Options.CallOptions

func WithRetry Uses

func WithRetry(fn RetryFunc) CallOption

WithRetry is a CallOption which overrides that which set in Options.CallOptions

func WithSelectOption Uses

func WithSelectOption(so ...selector.SelectOption) CallOption

func WithServiceToken Uses

func WithServiceToken() CallOption

WithServiceToken is a CallOption which overrides the authorization header with the services own auth token

func WithStreamTimeout Uses

func WithStreamTimeout(d time.Duration) CallOption

WithStreamTimeout sets the stream timeout

type CallOptions Uses

type CallOptions struct {
    SelectOptions []selector.SelectOption

    // Address of remote hosts
    Address []string
    // Backoff func
    Backoff BackoffFunc
    // Check if retriable func
    Retry RetryFunc
    // Transport Dial Timeout
    DialTimeout time.Duration
    // Number of Call attempts
    Retries int
    // Request/Response timeout
    RequestTimeout time.Duration
    // Stream timeout for the stream
    StreamTimeout time.Duration
    // Use the services own auth token
    ServiceToken bool
    // Duration to cache the response for
    CacheExpiry time.Duration

    // Middleware for low level call func
    CallWrappers []CallWrapper

    // Other options for implementations of the interface
    // can be stored in a context
    Context context.Context

type CallWrapper Uses

type CallWrapper func(CallFunc) CallFunc

CallWrapper is a low level wrapper for the CallFunc

type Client Uses

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

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.

func FromContext Uses

func FromContext(ctx context.Context) (Client, bool)

type Message Uses

type Message interface {
    Topic() string
    Payload() interface{}
    ContentType() string

Message is the interface for publishing asynchronously

func NewMessage Uses

func NewMessage(topic string, payload interface{}, opts ...MessageOption) Message

Creates a new message using the default client

type MessageOption Uses

type MessageOption func(*MessageOptions)

MessageOption used by NewMessage

func WithMessageContentType Uses

func WithMessageContentType(ct string) MessageOption

type MessageOptions Uses

type MessageOptions struct {
    ContentType string

type Option Uses

type Option func(*Options)

Option used by the Client

func Backoff Uses

func Backoff(fn BackoffFunc) Option

Backoff is used to set the backoff function used when retrying Calls

func Broker Uses

func Broker(b broker.Broker) Option

Broker to be used for pub/sub

func Codec Uses

func Codec(contentType string, c codec.NewCodec) Option

Codec to be used to encode/decode requests for a given content type

func ContentType Uses

func ContentType(ct string) Option

Default content type of the client

func DialTimeout Uses

func DialTimeout(d time.Duration) Option

Transport dial timeout

func PoolSize Uses

func PoolSize(d int) Option

PoolSize sets the connection pool size

func PoolTTL Uses

func PoolTTL(d time.Duration) Option

PoolTTL sets the connection pool ttl

func Registry Uses

func Registry(r registry.Registry) Option

Registry to find nodes for a given service

func RequestTimeout Uses

func RequestTimeout(d time.Duration) Option

The request timeout. Should this be a Call Option?

func Retries Uses

func Retries(i int) Option

Number of retries when making the request. Should this be a Call Option?

func Retry Uses

func Retry(fn RetryFunc) Option

Retry sets the retry function to be used when re-trying.

func Selector Uses

func Selector(s selector.Selector) Option

Select is used to select a node to route a request to

func StreamTimeout Uses

func StreamTimeout(d time.Duration) Option

StreamTimeout sets the stream timeout

func Transport Uses

func Transport(t transport.Transport) Option

Transport to use for communication e.g http, rabbitmq, etc

func WithRouter Uses

func WithRouter(r Router) Option

WithRouter sets the client router

func Wrap Uses

func Wrap(w Wrapper) Option

Adds a Wrapper to a list of options passed into the client

func WrapCall Uses

func WrapCall(cw ...CallWrapper) Option

Adds a Wrapper to the list of CallFunc wrappers

type Options Uses

type Options struct {
    // Used to select codec
    ContentType string

    // Plugged interfaces
    Broker    broker.Broker
    Codecs    map[string]codec.NewCodec
    Registry  registry.Registry
    Selector  selector.Selector
    Transport transport.Transport

    // Router sets the router
    Router Router

    // Connection Pool
    PoolSize int
    PoolTTL  time.Duration

    // Response cache
    Cache *Cache

    // Middleware for client
    Wrappers []Wrapper

    // Default Call Options
    CallOptions CallOptions

    // Other options for implementations of the interface
    // can be stored in a context
    Context context.Context

func NewOptions Uses

func NewOptions(options ...Option) Options

type PublishOption Uses

type PublishOption func(*PublishOptions)

PublishOption used by Publish

func PublishContext Uses

func PublishContext(ctx context.Context) PublishOption

PublishContext sets the context in publish options

func WithExchange Uses

func WithExchange(e string) PublishOption

WithExchange sets the exchange to route a message through

type PublishOptions Uses

type PublishOptions struct {
    // Exchange is the routing exchange for the message
    Exchange string
    // Other options for implementations of the interface
    // can be stored in a context
    Context context.Context

type Request Uses

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

Request is the interface for a synchronous request used by Call or Stream

func NewRequest Uses

func NewRequest(service, endpoint string, request interface{}, reqOpts ...RequestOption) Request

Creates a new request using the default client. Content Type will be set to the default within options and use the appropriate codec

type RequestOption Uses

type RequestOption func(*RequestOptions)

RequestOption used by NewRequest

func StreamingRequest Uses

func StreamingRequest() RequestOption

func WithContentType Uses

func WithContentType(ct string) RequestOption

type RequestOptions Uses

type RequestOptions struct {
    ContentType string
    Stream      bool

    // Other options for implementations of the interface
    // can be stored in a context
    Context context.Context

type Response Uses

type Response interface {
    // Read the response
    Codec() codec.Reader
    // read the header
    Header() map[string]string
    // Read the undecoded response
    Read() ([]byte, error)

Response is the response received from a service

type RetryFunc Uses

type RetryFunc func(ctx context.Context, req Request, retryCount int, err error) (bool, error)

note that returning either false or a non-nil error will result in the call not being retried

type Router Uses

type Router interface {
    SendRequest(context.Context, Request) (Response, error)

Router manages request routing

type Stream Uses

type Stream interface {
    // 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

Stream is the inteface for a bidirectional synchronous stream

func NewStream Uses

func NewStream(ctx context.Context, request Request, opts ...CallOption) (Stream, error)

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.

type StreamWrapper Uses

type StreamWrapper func(Stream) Stream

StreamWrapper wraps a Stream and returns the equivalent

type Wrapper Uses

type Wrapper func(Client) Client

Wrapper wraps a client and returns a client


grpcPackage grpc provides a gRPC client
mucpPackage mucp provides an mucp client
selectorPackage selector is a way to pick a list of service nodes
selector/dnsPackage dns provides a dns SRV selector
selector/registryPackage registry uses the go-micro registry for selection
selector/routerPackage router is a network/router selector
selector/staticPackage static provides a static resolver which returns the name/ip passed in without any change

Package client imports 29 packages (graph) and is imported by 974 packages. Updated 2020-05-27. Refresh now. Tools for package owners.