rpcclient

Documentation

Overview

Package rpcclient contains implementations for net rpc client.

Package rpcclient contains implementations for net rpc client.

Index

• Variables
• type Client
  • func Dial(rawurl string) (*Client, error)
  • func DialContext(ctx context.Context, rawurl string) (*Client, error)
  • func DialHTTP(endpoint string) (*Client, error)
  • func DialHTTPWithClient(endpoint string, client *http.Client) (*Client, error)
  • func DialWebsocket(ctx context.Context, endpoint, origin string) (*Client, error)
  • func (c *Client) Call(result interface{}, method string, args ...interface{}) error
  • func (c *Client) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error
  • func (c *Client) Close()
  • func (c *Client) Subscribe(ctx context.Context, namespace string, channel interface{}, ...) (*ClientSubscription, error)
  • func (c *Client) SupportedModules() (map[string]string, error)
• type ClientSubscription
  • func (sub *ClientSubscription) Err() <-chan error
  • func (sub *ClientSubscription) Unsubscribe()
• type RpcConnPool
  • func NewRpcConnPool(lifetime int) *RpcConnPool
  • func (p *RpcConnPool) FetchRpcConn(rpcAddr string) *RpcConnection
• type RpcConnection
  • func (c *RpcConnection) Release()

Variables

var (
	ErrClientQuit                = errors.New("client is closed")
	ErrNoResult                  = errors.New("no result in JSON-RPC response")
	ErrSubscriptionQueueOverflow = errors.New("subscription queue overflow")
)

Types

type Client

type Client struct {
	// contains filtered or unexported fields
}

Client represents a connection to an RPC server.

func Dial

func Dial(rawurl string) (*Client, error)

Dial creates a new client for the given URL.

The currently supported URL schemes are "http", "https", "ws" and "wss". If rawurl is a file name with no URL scheme, a local socket connection is established using UNIX domain sockets on supported platforms and named pipes on Windows. If you want to configure transport options, use DialHTTP, DialWebsocket or DialIPC instead.

For websocket connections, the origin is set to the local host name.

The client reconnects automatically if the connection is lost.

func DialContext

func DialContext(ctx context.Context, rawurl string) (*Client, error)

DialContext creates a new RPC client, just like Dial.

The context is used to cancel or time out the initial connection establishment. It does not affect subsequent interactions with the client.

func DialHTTP

func DialHTTP(endpoint string) (*Client, error)

DialHTTP creates a new RPC client that connects to an RPC server over HTTP.

func DialHTTPWithClient

func DialHTTPWithClient(endpoint string, client *http.Client) (*Client, error)

DialHTTPWithClient creates a new RPC client that connects to an RPC server over HTTP using the provided HTTP Client.

func DialWebsocket

func DialWebsocket(ctx context.Context, endpoint, origin string) (*Client, error)

DialWebsocket creates a new RPC client that communicates with a JSON-RPC server that is listening on the given endpoint.

The context is used for the initial connection establishment. It does not affect subsequent interactions with the client.

func (*Client) Call

func (c *Client) Call(result interface{}, method string, args ...interface{}) error

Call performs a JSON-RPC call with the given arguments and unmarshals into result if no error occurred.

The result must be a pointer so that package json can unmarshal into it. You can also pass nil, in which case the result is ignored.

func (*Client) CallContext

func (c *Client) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error

CallContext performs a JSON-RPC call with the given arguments. If the context is canceled before the call has successfully returned, CallContext returns immediately.

The result must be a pointer so that package json can unmarshal into it. You can also pass nil, in which case the result is ignored.

func (*Client) Close

func (c *Client) Close()

Close closes the client, aborting any in-flight requests.

func (*Client) Subscribe

func (c *Client) Subscribe(ctx context.Context, namespace string, channel interface{}, args ...interface{}) (*ClientSubscription, error)

Subscribe calls the "<namespace>_subscribe" method with the given arguments, registering a subscription. Server notifications for the subscription are sent to the given channel. The element type of the channel must match the expected type of content returned by the subscription.

The context argument cancels the RPC request that sets up the subscription but has no effect on the subscription after Subscribe has returned.

Slow subscribers will be dropped eventually. Client buffers up to 8000 notifications before considering the subscriber dead. The subscription Err channel will receive ErrSubscriptionQueueOverflow. Use a sufficiently large buffer on the channel or ensure that the channel usually has at least one reader to prevent this issue.

func (*Client) SupportedModules

func (c *Client) SupportedModules() (map[string]string, error)

SupportedModules calls the rpc_modules method, retrieving the list of APIs that are available on the server.

type ClientSubscription

type ClientSubscription struct {
	// contains filtered or unexported fields
}

A ClientSubscription represents a subscription established through EthSubscribe.

func (*ClientSubscription) Err

func (sub *ClientSubscription) Err() <-chan error

Err returns the subscription error channel. The intended use of Err is to schedule resubscription when the client connection is closed unexpectedly.

The error channel receives a value when the subscription has ended due to an error. The received error is nil if Close has been called on the underlying client and no other error has occurred.

The error channel is closed when Unsubscribe is called on the subscription.

func (*ClientSubscription) Unsubscribe

func (sub *ClientSubscription) Unsubscribe()

Unsubscribe unsubscribes the notification and closes the error channel. It can safely be called more than once.

type RpcConnPool

type RpcConnPool struct {
	// contains filtered or unexported fields
}

func NewRpcConnPool

func NewRpcConnPool(lifetime int) *RpcConnPool

func (*RpcConnPool) FetchRpcConn

func (p *RpcConnPool) FetchRpcConn(rpcAddr string) *RpcConnection

type RpcConnection

type RpcConnection struct {
	Client *Client
	// contains filtered or unexported fields
}

func (*RpcConnection) Release

func (c *RpcConnection) Release()