server

Documentation

Overview

nolint

Index

• Variables
• type DecayingTagSpec
• type Handler
• type Host
• type Opt
  • func WithDecayingTag(tag DecayingTagSpec) Opt
  • func WithHardTimeout(timeout time.Duration) Opt
  • func WithLog(log log.Log) Opt
  • func WithMetrics() Opt
  • func WithQueueSize(size int) Opt
  • func WithRequestSizeLimit(limit int) Opt
  • func WithRequestsPerInterval(n int, interval time.Duration) Opt
  • func WithTimeout(timeout time.Duration) Opt
• type Response
  • func (t *Response) DecodeScale(dec *scale.Decoder) (total int, err error)
  • func (t *Response) EncodeScale(enc *scale.Encoder) (total int, err error)
• type Server
  • func New(h Host, proto string, handler Handler, opts ...Opt) *Server
  • func (s *Server) Request(ctx context.Context, pid peer.ID, req []byte) ([]byte, error)
  • func (s *Server) Run(ctx context.Context) error

Variables

var (
	// ErrNotConnected is returned when peer is not connected.
	ErrNotConnected = errors.New("peer is not connected")
	// ErrPeerResponseFailed raised if peer responded with an error.
	ErrPeerResponseFailed = errors.New("peer response failed")
)

Types

type DecayingTagSpec

type DecayingTagSpec struct {
	Interval time.Duration `mapstructure:"interval"`
	Inc      int           `mapstructure:"inc"`
	Dec      int           `mapstructure:"dec"`
	Cap      int           `mapstructure:"cap"`
}

type Handler

type Handler func(context.Context, []byte) ([]byte, error)

Handler is the handler to be defined by the application.

type Host

type Host interface {
	SetStreamHandler(protocol.ID, network.StreamHandler)
	NewStream(context.Context, peer.ID, ...protocol.ID) (network.Stream, error)
	Network() network.Network
	ConnManager() connmgr.ConnManager
}

Host is a subset of libp2p Host interface that needs to be implemented to be usable with server.

type Opt

type Opt func(s *Server)

Opt is a type to configure a server.

func WithDecayingTag

func WithDecayingTag(tag DecayingTagSpec) Opt

func WithHardTimeout

func WithHardTimeout(timeout time.Duration) Opt

WithHardTimeout configures the hard timeout for requests. Requests are terminated if they take longer than the specified duration.

func WithLog

func WithLog(log log.Log) Opt

WithLog configures logger for the server.

func WithMetrics

func WithMetrics() Opt

WithMetrics will enable metrics collection in the server.

func WithQueueSize

func WithQueueSize(size int) Opt

WithQueueSize parametrize number of message that will be kept in queue and eventually processed by server. Otherwise stream is closed immediately.

Size of the queue should be set to account for maximum expected latency, such as if expected latency is 10s and server processes 1000 requests per second size should be 100.

Defaults to 100.

func WithRequestSizeLimit

func WithRequestSizeLimit(limit int) Opt

func WithRequestsPerInterval

func WithRequestsPerInterval(n int, interval time.Duration) Opt

WithRequestsPerInterval parametrizes server rate limit to limit maximum amount of bandwidth that this handler can consume.

Defaults to 100 requests per second.

func WithTimeout

func WithTimeout(timeout time.Duration) Opt

WithTimeout configures stream timeout. The requests are terminated when no data is received or sent for the specified duration.

type Response

type Response struct {
	Data  []byte `scale:"max=89128960"` // 85 MiB
	Error string `scale:"max=1024"`     // TODO(mafa): make error code instead of string
}

Response is a server response.

func (*Response) DecodeScale

func (t *Response) DecodeScale(dec *scale.Decoder) (total int, err error)

func (*Response) EncodeScale

func (t *Response) EncodeScale(enc *scale.Encoder) (total int, err error)

type Server

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

Server for the Handler.

func New

func New(h Host, proto string, handler Handler, opts ...Opt) *Server

New server for the handler.

func (*Server) Request

func (s *Server) Request(ctx context.Context, pid peer.ID, req []byte) ([]byte, error)

Request sends a binary request to the peer. Request is executed in the background, one of the callbacks is guaranteed to be called on success/error.

func (*Server) Run

func (s *Server) Run(ctx context.Context) error