rpc

Documentation

Index

• func NewHTTPServer(grpcServer *grpc.Server, address string) *http.Server
• func NewRateLimiterInterceptor(log zerolog.Logger, apiRateLimits map[string]int, ...) *rateLimiterInterceptor
• type Config
• type Engine
  • func New(log zerolog.Logger, state protocol.State, config Config, ...) *Engine
  • func (e *Engine) Done() <-chan struct{}
  • func (e *Engine) GRPCAddress() net.Addr
  • func (e *Engine) Ready() <-chan struct{}
  • func (e *Engine) SubmitLocal(event interface{})
• type HTTPHeader

Functions

func NewHTTPServer

func NewHTTPServer(
	grpcServer *grpc.Server,
	address string,
) *http.Server

NewHTTPServer creates and intializes a new HTTP GRPC proxy server

func NewRateLimiterInterceptor

func NewRateLimiterInterceptor(log zerolog.Logger, apiRateLimits map[string]int, apiBurstLimits map[string]int) *rateLimiterInterceptor

NewRateLimiterInterceptor creates a new rate limiter interceptor with the defined per second rate limits and the optional burst limit for each API.

Types

type Config

type Config struct {
	GRPCListenAddr            string        // the GRPC server address as ip:port
	HTTPListenAddr            string        // the HTTP web proxy address as ip:port
	CollectionAddr            string        // the address of the upstream collection node
	HistoricalAccessAddrs     string        // the list of all access nodes from previous spork
	MaxMsgSize                int           // GRPC max message size
	ExecutionClientTimeout    time.Duration // execution API GRPC client timeout
	CollectionClientTimeout   time.Duration // collection API GRPC client timeout
	MaxHeightRange            uint          // max size of height range requests
	PreferredExecutionNodeIDs []string      // preferred list of upstream execution node IDs
	FixedExecutionNodeIDs     []string      // fixed list of execution node IDs to choose from if no node node ID can be chosen from the PreferredExecutionNodeIDs
}

Config defines the configurable options for the access node server

type Engine

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

Engine implements a gRPC server with a simplified version of the Observation API.

func New

func New(log zerolog.Logger,
	state protocol.State,
	config Config,
	collectionRPC accessproto.AccessAPIClient,
	historicalAccessNodes []accessproto.AccessAPIClient,
	blocks storage.Blocks,
	headers storage.Headers,
	collections storage.Collections,
	transactions storage.Transactions,
	executionReceipts storage.ExecutionReceipts,
	chainID flow.ChainID,
	transactionMetrics module.TransactionMetrics,
	collectionGRPCPort uint,
	executionGRPCPort uint,
	retryEnabled bool,
	rpcMetricsEnabled bool,
	apiRatelimits map[string]int,
	apiBurstLimits map[string]int,
) *Engine

New returns a new RPC engine.

func (*Engine) Done

func (e *Engine) Done() <-chan struct{}

Done returns a done channel that is closed once the engine has fully stopped. It sends a signal to stop the gRPC server, then closes the channel.

func (*Engine) GRPCAddress

func (e *Engine) GRPCAddress() net.Addr

func (*Engine) Ready

func (e *Engine) Ready() <-chan struct{}

Ready returns a ready channel that is closed once the engine has fully started. The RPC engine is ready when the gRPC server has successfully started.

func (*Engine) SubmitLocal

func (e *Engine) SubmitLocal(event interface{})

SubmitLocal submits an event originating on the local node.

type HTTPHeader

type HTTPHeader struct {
	Key   string
	Value string
}