connector

Documentation

Index

• Constants
• Variables
• type Action
• type Connector
  • func NewWithLimitAndOptionValues(limit int, ovs options.OptionValues) Connector
  • func NewWithLimitAndOptions(limit int, opts options.Options) Connector
  • func NewWithOptionValues(ovs options.OptionValues) Connector
  • func NewWithOptions(opts options.Options) Connector
• type CoreAction
• type Dialer
• type Listener
• type MsgReceiver
• type MsgSendReceiver
• type MsgSender
• type Negotiator
• type Pipe
• type PipeEvent
• type PipeEventHandlerFunc
• type Receiver
• type SendReceiver
• type Sender

Constants

const (
	ErrStopped = errs.Err("object is stopped")
)

errors

Variables

var (
	// OptionDomains is option's domain
	OptionDomains = []string{"Connector"}
	// Options for connector
	Options = connectorOptions{
		PipeLimit: options.NewIntOption(-1),
		Dialer: dialerOptions{
			Reconnect:        options.NewBoolOption(true),
			MinReconnectTime: options.NewTimeDurationOption(100 * time.Millisecond),
			MaxReconnectTime: options.NewTimeDurationOption(8 * time.Second),
			DialAsync:        options.NewBoolOption(false),
		},
		Pipe: pipeOptions{
			ReadBuffer:           options.NewIntOption(0),
			Raw:                  options.NewBoolOption(false),
			RawRecvBufSize:       options.NewIntOption(4 * 1024),
			CloseOnEOF:           options.NewBoolOption(true),
			MaxRecvContentLength: options.NewUint32Option(128 * 1024),
		},
	}
)

Types

type Action

type Action interface {
	SetNegotiator(Negotiator)

	CoreAction

	GetPipe(id uint32) Pipe
	ClosePipe(id uint32)
}

Action is connector's action

type Connector

type Connector interface {
	options.Options
	Action
	Close()
	SetPipeEventHandler(PipeEventHandlerFunc)
	ClearPipeEventHandler(PipeEventHandlerFunc)
}

Connector controls socket's connections

func NewWithLimitAndOptionValues

func NewWithLimitAndOptionValues(limit int, ovs options.OptionValues) Connector

NewWithLimitAndOptionValues create a Connector with limit and option values

func NewWithLimitAndOptions

func NewWithLimitAndOptions(limit int, opts options.Options) Connector

NewWithLimitAndOptions create a Connector with limit and options

func NewWithOptionValues

func NewWithOptionValues(ovs options.OptionValues) Connector

NewWithOptionValues create a Connector with option values

func NewWithOptions

func NewWithOptions(opts options.Options) Connector

NewWithOptions create a Connector with options

type CoreAction

type CoreAction interface {
	Dial(addr string) error
	DialOptions(addr string, ovs options.OptionValues) error
	NewDialer(addr string, ovs options.OptionValues) (Dialer, error)
	// StopDial stop dial to address, but keep connected pipes.
	StopDial(addr string)

	Listen(addr string) error
	ListenOptions(addr string, ovs options.OptionValues) error
	NewListener(addr string, ovs options.OptionValues) (Listener, error)
	// StopDial stop listen on address, but keep accepted pipes.
	StopListen(addr string)
}

CoreAction is connector's core action

type Dialer

type Dialer interface {
	options.Options

	Dial() error
	Close() error
	TransportDialer() transport.Dialer
}

Dialer is for connecting a listening socket.

type Listener

type Listener interface {
	options.Options

	Listen() error
	Close() error
	TransportListener() transport.Listener
}

Listener is for listening and accepting connections.

type MsgReceiver

type MsgReceiver interface {
	RecvMsg() (msg *message.Message, err error)
}

MsgReceiver receive messages

type MsgSendReceiver

type MsgSendReceiver interface {
	MsgSender
	MsgReceiver
}

MsgSendReceiver send and receive messages

type MsgSender

type MsgSender interface {
	SendMsg(msg *message.Message) (err error)
}

MsgSender send messages

type Negotiator

type Negotiator interface {
	Negotiate(pipe Pipe) error
}

Negotiator is use for handshaking when adding pipe

type Pipe

type Pipe interface {
	options.ReadOnlyOptions

	ID() uint32
	IsRaw() bool
	MsgFreeLevel() message.FreeLevel

	transport.Connection

	MsgSendReceiver
}

Pipe is a connection between two peers.

type PipeEvent

type PipeEvent int

PipeEvent is pipe event

const (
	PipeEventAdd PipeEvent = iota
	PipeEventRemove
)

pipe events

type PipeEventHandlerFunc

type PipeEventHandlerFunc func(PipeEvent, Pipe)

PipeEventHandlerFunc can handle pipe event

type Receiver

type Receiver interface {
	Recv() (b []byte, err error)
}

Receiver receive packet

type SendReceiver

type SendReceiver interface {
	Sender
	Receiver
}

SendReceiver send and receive packet

type Sender

type Sender interface {
	Send(b []byte) (err error)
}

Sender send packet