rpc

package
v0.10.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 29, 2021 License: ISC Imports: 57 Imported by: 1

Documentation

Index

Constants

View Source 
const MaxInvPerMsg = 50000

MaxInvPerMsg is the maximum number of inventory vectors that can be in a single inv message.

Variables

View Source 
var (
	// ErrNotificationsUnsupported is returned when the connection doesn't support notifications
	ErrNotificationsUnsupported = errors.New("notifications not supported")
	// ErrNotificationNotFound is returned when the notification for the given id is not found
	ErrSubscriptionNotFound = errors.New("subscription not found")
)
View Source 
var ErrClientQuit = errors.New("client quit")
View Source 
var ErrRescanReorg = cmds.ErrRPCDatabase

ErrRescanReorg defines the error that is returned when an unrecoverable reorganize is detected during a rescan.

Functions

func GenCertPair added in v0.10.1 

func GenCertPair(certFile, keyFile string) error

genCertPair generates a key/cert pair to the paths provided.

func GetTxsHexFromBlock added in v0.10.1 

func GetTxsHexFromBlock(block *types.SerializedBlock, duplicate bool) ([]string, error)

func RPCClientInInitialDownloadError 

func RPCClientInInitialDownloadError(err, context string) error

LL(getblocktemplate RPC) 2018-10-28 client errors.

func RpcAddressKeyError 

func RpcAddressKeyError(fmtStr string, args ...interface{}) error

RpcAddressKeyError is a convenience function to convert an address/key error to an RPC error.

func RpcDecodeHexError 

func RpcDecodeHexError(gotHex string) error

RpcDecodeHexError is a convenience function for returning a nicely formatted RPC error which indicates the provided hex string failed to decode.

func RpcDeserializationError 

func RpcDeserializationError(fmtStr string, args ...interface{}) error

RpcDeserializetionError is a convenience function to convert a deserialization error to an RPC error

func RpcDuplicateTxError 

func RpcDuplicateTxError(fmtStr string, args ...interface{}) error

RpcDuplicateTxError is a convenience function to convert a rejected duplicate tx error to an RPC error

func RpcInternalError 

func RpcInternalError(err, context string) error

func RpcInvalidError 

func RpcInvalidError(fmtStr string, args ...interface{}) error

RpcInvalidError is a convenience function to convert an invalid parameter error to an RPC error with the appropriate code set.

func RpcNoTxInfoError 

func RpcNoTxInfoError(txHash *hash.Hash) error

RpcNoTxInfoError is a convenience function for returning a nicely formatted RPC error which indicates there is no information available for the provided transaction hash.

func RpcRuleError 

func RpcRuleError(fmtStr string, args ...interface{}) error

RpcRuleError is a convenience function to convert a rule error to an RPC error

func RpcSubmitError added in v0.10.4 

func RpcSubmitError(fmtStr string, args ...interface{}) error

func UseLogger added in v0.10.1 

func UseLogger(logger l.Logger)

UseLogger uses a specified Logger to output package logging info.

Types

type API 

type API struct {
	NameSpace string      // namespace under which the rpc methods of Service are exposed
	Service   interface{} // receiver instance which holds the methods
	Public    bool        // indication if the methods must be considered safe for public use
}

API describes the set of methods offered over the RPC interface

type CodecOption 

type CodecOption int

CodecOption specifies which type of messages this codec supports 

const (
	// OptionMethodInvocation is an indication that the codec supports RPC method calls
	OptionMethodInvocation CodecOption = 1 << iota

	// OptionSubscriptions is an indication that the codec suports RPC notifications
	OptionSubscriptions = 1 << iota // support pub sub
)

type Error 

type Error interface {
	Error() string  // returns the message
	ErrorCode() int // returns the code
}

Error wraps RPC errors, which contain an error code in addition to the message.

type ID 

type ID string

ID defines a pseudo random number that is used to identify RPC subscriptions.

func NewID 

func NewID() ID

NewID generates a identifier that can be used as an identifier in the RPC interface. e.g. filter and subscription identifier.

type Notifier 

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

Notifier is tight to a RPC connection that supports subscriptions. Server callbacks use the notifier to send notifications.

func NotifierFromContext 

func NotifierFromContext(ctx context.Context) (*Notifier, bool)

NotifierFromContext returns the Notifier value stored in ctx, if any.

func (*Notifier) Closed 

func (n *Notifier) Closed() <-chan interface{}

Closed returns a channel that is closed when the RPC connection is closed.

func (*Notifier) CreateSubscription 

func (n *Notifier) CreateSubscription() *Subscription

CreateSubscription returns a new subscription that is coupled to the RPC connection. By default subscriptions are inactive and notifications are dropped until the subscription is marked as active. This is done by the RPC server after the subscription ID is send to the client.

func (*Notifier) Notify 

func (n *Notifier) Notify(id ID, data interface{}) error

Notify sends a notification to the client with the given data as payload. If an error occurs the RPC connection is closed and the error is returned.

type RequestStatus added in v0.10.1 

type RequestStatus struct {
	Service      string
	Method       string
	TotalCalls   uint
	TotalTime    time.Duration
	MaxTime      time.Duration
	MinTime      time.Duration
	MaxTimeReqID string
	MinTimeReqID string

	Requests []*serverRequest
}

func NewRequestStatus added in v0.10.1 

func NewRequestStatus(sReq *serverRequest) (*RequestStatus, error)

func (*RequestStatus) AddRequst added in v0.10.1 

func (rs *RequestStatus) AddRequst(sReq *serverRequest)

func (*RequestStatus) GetName added in v0.10.1 

func (rs *RequestStatus) GetName() string

func (*RequestStatus) RemoveRequst added in v0.10.1 

func (rs *RequestStatus) RemoveRequst(sReq *serverRequest)

func (*RequestStatus) ToJson added in v0.10.1 

func (rs *RequestStatus) ToJson() *cmds.JsonRequestStatus

type RpcServer 

type RpcServer struct {
	ReqStatus map[string]*RequestStatus

	BC          *blockchain.BlockChain
	TxIndex     *index.TxIndex
	ChainParams *params.Params
	// contains filtered or unexported fields
}

RpcServer provides a concurrent safe RPC server to a chain server.

func NewRPCServer 

func NewRPCServer(cfg *config.Config, events *event.Feed) (*RpcServer, error)

newRPCServer returns a new instance of the rpcServer struct.

func (*RpcServer) AddRequstStatus added in v0.10.1 

func (s *RpcServer) AddRequstStatus(sReq *serverRequest)

func (*RpcServer) NotifyNewTransactions added in v0.10.1 

func (s *RpcServer) NotifyNewTransactions(txns []*types.TxDesc)

func (*RpcServer) RegisterService 

func (s *RpcServer) RegisterService(namespace string, regSvc interface{}) error

RegisterService will create a service for the given type under the given namespace. When no methods on the given type match the criteria to be either a RPC method or a subscription an error is returned. Otherwise a new service is created and added to the service registry.

func (*RpcServer) RemoveRequstStatus added in v0.10.1 

func (s *RpcServer) RemoveRequstStatus(sReq *serverRequest)

func (*RpcServer) RequestedProcessShutdown 

func (s *RpcServer) RequestedProcessShutdown() chan struct{}

func (*RpcServer) ServeSingleRequest 

func (s *RpcServer) ServeSingleRequest(ctx context.Context, codec ServerCodec, options CodecOption)

ServeSingleRequest reads and processes a single RPC request from the given codec. It will not close the codec unless a non-recoverable error has occurred. Note, this method will return after a single request has been processed!

func (*RpcServer) Start 

func (s *RpcServer) Start() error

func (*RpcServer) Stop 

func (s *RpcServer) Stop()

Stop will stop reading new requests, wait for stopPendingRequestTimeout to allow pending requests to finish, close all codecs which will cancel pending requests/subscriptions.

func (*RpcServer) WebsocketHandler added in v0.10.1 

func (s *RpcServer) WebsocketHandler(conn *websocket.Conn, remoteAddr string, isAdmin bool)

type ServerCodec 

type ServerCodec interface {
	// Read next request
	ReadRequestHeaders() ([]rpcRequest, bool, Error)
	// Parse request argument to the given types
	ParseRequestArguments(argTypes []reflect.Type, params interface{}) ([]reflect.Value, Error)
	// Assemble success response, expects response id and payload
	CreateResponse(id interface{}, reply interface{}) interface{}
	// Assemble error response, expects response id and error
	CreateErrorResponse(id interface{}, err Error) interface{}
	// Assemble error response with extra information about the error through info
	CreateErrorResponseWithInfo(id interface{}, err Error, info interface{}) interface{}
	// Create notification response
	CreateNotification(id, namespace string, event interface{}) interface{}
	// Write msg to client.
	Write(msg interface{}) error
	// Close underlying data stream
	Close()
	// Closed when underlying connection is closed
	Closed() <-chan interface{}
}

ServerCodec implements reading, parsing and writing RPC messages for the server side of a RPC session. Implementations must be go-routine safe since the codec can be called in multiple go-routines concurrently.

func NewCodec 

func NewCodec(rwc io.ReadWriteCloser, encode, decode func(v interface{}) error) ServerCodec

NewCodec creates a new RPC server codec with support for JSON-RPC 2.0 based on explicitly given encoding and decoding methods.

func NewJSONCodec 

func NewJSONCodec(rwc io.ReadWriteCloser) ServerCodec

NewJSONCodec creates a new RPC server codec with support for JSON-RPC 2.0.

type SessionResult added in v0.10.1 

type SessionResult struct {
	SessionID uint64 `json:"sessionid"`
}

type Subscription 

type Subscription struct {
	ID ID
	// contains filtered or unexported fields
}

a Subscription is created by a notifier and tight to that notifier. The client can use this subscription to wait for an unsubscribe request for the client, see Err().

func (*Subscription) Err 

func (s *Subscription) Err() <-chan error

Err returns a channel that is closed when the client send an unsubscribe request.

type TxConfirm added in v0.10.1 

type TxConfirm struct {
	Confirms  uint64
	TxHash    string
	EndHeight uint64 // timeout
}

type WSCodec added in v0.10.1 

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

func NewWSCodec added in v0.10.1 

func NewWSCodec(msg []byte, client *wsClient) *WSCodec

func (*WSCodec) Close added in v0.10.1 

func (c *WSCodec) Close()

Close the underlying connection

func (*WSCodec) Closed added in v0.10.1 

func (c *WSCodec) Closed() <-chan interface{}

Closed returns a channel which will be closed when Close is called

func (*WSCodec) CreateErrorResponse added in v0.10.1 

func (c *WSCodec) CreateErrorResponse(id interface{}, err Error) interface{}

CreateErrorResponse will create a JSON-RPC error response with the given id and error.

func (*WSCodec) CreateErrorResponseWithInfo added in v0.10.1 

func (c *WSCodec) CreateErrorResponseWithInfo(id interface{}, err Error, info interface{}) interface{}

CreateErrorResponseWithInfo will create a JSON-RPC error response with the given id and error. info is optional and contains additional information about the error. When an empty string is passed it is ignored.

func (*WSCodec) CreateNotification added in v0.10.1 

func (c *WSCodec) CreateNotification(subid, namespace string, event interface{}) interface{}

CreateNotification will create a JSON-RPC notification with the given subscription id and event as params.

func (*WSCodec) CreateResponse added in v0.10.1 

func (c *WSCodec) CreateResponse(id interface{}, reply interface{}) interface{}

CreateResponse will create a JSON-RPC success response with the given id and reply as result.

func (*WSCodec) ParseRequestArguments added in v0.10.1 

func (c *WSCodec) ParseRequestArguments(argTypes []reflect.Type, params interface{}) ([]reflect.Value, Error)

func (*WSCodec) ReadRequestHeaders added in v0.10.1 

func (c *WSCodec) ReadRequestHeaders() ([]rpcRequest, bool, Error)

func (*WSCodec) Write added in v0.10.1 

func (c *WSCodec) Write(res interface{}) error

Write message to client

type WatchTxConfirmServer added in v0.10.1 

type WatchTxConfirmServer map[string]TxConfirm

func (*WatchTxConfirmServer) AddTxConfirms added in v0.10.1 

func (w *WatchTxConfirmServer) AddTxConfirms(confirm TxConfirm)

func (*WatchTxConfirmServer) Handle added in v0.10.1 

func (w *WatchTxConfirmServer) Handle(wsc *wsClient, currentHeight uint64)

func (*WatchTxConfirmServer) RemoveTxConfirms added in v0.10.6 

func (w *WatchTxConfirmServer) RemoveTxConfirms(confirm TxConfirm)

func (*WatchTxConfirmServer) SendTxNotification added in v0.10.1 

func (w *WatchTxConfirmServer) SendTxNotification(tx string, confirms uint64, wsc *wsClient, isBlue, isValid bool)

Source Files

View all Source files

Directories

Path Synopsis
cmds

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.