connmgr

Documentation

Index

• Constants
• Variables
• func DisableLog()
• func TorLookupIP(host, proxy string) ([]net.IP, error)
• func UseLogger(logger elalog.Logger)
• type Config
• type ConnManager
  • func New(cfg *Config) (*ConnManager, error)
  • func (cm *ConnManager) Connect(c *ConnReq)
  • func (cm *ConnManager) Disconnect(id uint64)
  • func (cm *ConnManager) NewConnReq()
  • func (cm *ConnManager) OnSelfConnection(addr string)
  • func (cm *ConnManager) Remove(id uint64)
  • func (cm *ConnManager) Start()
  • func (cm *ConnManager) Stop()
  • func (cm *ConnManager) Wait()
• type ConnReq
  • func (c *ConnReq) ID() uint64
  • func (c *ConnReq) State() ConnState
  • func (c *ConnReq) String() string
• type ConnState
• type DynamicBanScore
  • func (s *DynamicBanScore) Increase(persistent, transient uint32) uint32
  • func (s *DynamicBanScore) Int() uint32
  • func (s *DynamicBanScore) Reset()
  • func (s *DynamicBanScore) String() string

Constants

const (
	// Halflife defines the time (in seconds) by which the transient part
	// of the ban score decays to one half of it's original value.
	Halflife = 60

	// Lifetime defines the maximum age of the transient part of the ban
	// score to be considered a non-zero score (in seconds).
	Lifetime = 1800
)

Variables

var (
	// ErrDialNil is used to indicate that Dial cannot be nil in the configuration.
	ErrDialNil = errors.New("Config: Dial cannot be nil")

	// ErrDialSelf indicates the connection is dialling to self address.
	ErrDialSelf = errors.New("dial to self address")

	// ErrDuplicateAddr indicates the connection is using a duplicate address.
	ErrDuplicateAddr = errors.New("connecting to duplicate addr")
)

var (
	// ErrTorInvalidAddressResponse indicates an invalid address was
	// returned by the Tor DNS resolver.
	ErrTorInvalidAddressResponse = errors.New("invalid address response")

	// ErrTorInvalidProxyResponse indicates the Tor proxy returned a
	// response in an unexpected format.
	ErrTorInvalidProxyResponse = errors.New("invalid proxy response")

	// ErrTorUnrecognizedAuthMethod indicates the authentication method
	// provided is not recognized.
	ErrTorUnrecognizedAuthMethod = errors.New("invalid proxy authentication method")
)

Functions

func DisableLog

func DisableLog()

DisableLog disables all library log output. Logging output is disabled by default until either UseLogger or SetLogWriter are called.

func TorLookupIP

func TorLookupIP(host, proxy string) ([]net.IP, error)

TorLookupIP uses Tor to resolve DNS via the SOCKS extension they provide for resolution over the Tor network. Tor itself doesn't support ipv6 so this doesn't either.

func UseLogger

func UseLogger(logger elalog.Logger)

UseLogger uses a specified Logger to output package logging info. This should be used in preference to SetLogWriter if the caller is also using elalog.

Types

type Config

type Config struct {
	// Listeners defines a slice of listeners for which the connection
	// manager will take ownership of and accept connections.  When a
	// connection is accepted, the OnAccept handler will be invoked with the
	// connection.  Since the connection manager takes ownership of these
	// listeners, they will be closed when the connection manager is
	// stopped.
	//
	// This field will not have any effect if the OnAccept field is not
	// also specified.  It may be nil if the caller does not wish to listen
	// for incoming connections.
	Listeners []net.Listener

	// OnAccept is a callback that is fired when an inbound connection is
	// accepted.  It is the caller's responsibility to close the connection.
	// Failure to close the connection will result in the connection manager
	// believing the connection is still active and thus have undesirable
	// side effects such as still counting toward maximum connection limits.
	//
	// This field will not have any effect if the Listeners field is not
	// also specified since there couldn't possibly be any accepted
	// connections in that case.
	OnAccept func(net.Conn)

	// TargetOutbound is the number of outbound network connections to
	// maintain. Defaults to 8.
	TargetOutbound uint32

	// RetryDuration is the duration to wait before retrying connection
	// requests. Defaults to 5s.
	RetryDuration time.Duration

	// OnConnection is a callback that is fired when a new outbound
	// connection is established.
	OnConnection func(*ConnReq, net.Conn)

	// OnDisconnection is a callback that is fired when an outbound
	// connection is disconnected.
	OnDisconnection func(*ConnReq)

	// GetNewAddress is a way to get an address to make a network connection
	// to.  If nil, no new connections will be made automatically.
	GetNewAddress func() (net.Addr, error)

	// Dial connects to the address on the named network. It cannot be nil.
	Dial func(net.Addr) (net.Conn, error)
}

Config holds the configuration options related to the connection manager.

type ConnManager

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

ConnManager provides a manager to handle network connections.

func New

func New(cfg *Config) (*ConnManager, error)

New returns a new connection manager. Use Start to start connecting to the network.

func (*ConnManager) Connect

func (cm *ConnManager) Connect(c *ConnReq)

Connect assigns an id and dials a connection to the address of the connection request.

func (*ConnManager) Disconnect

func (cm *ConnManager) Disconnect(id uint64)

Disconnect disconnects the connection corresponding to the given connection id. If permanent, the connection will be retried with an increasing backoff duration.

func (*ConnManager) NewConnReq

func (cm *ConnManager) NewConnReq()

NewConnReq creates a new connection request and connects to the corresponding address.

func (*ConnManager) OnSelfConnection

func (cm *ConnManager) OnSelfConnection(addr string)

OnSelfConnection tells the ConnManager a connected address is self connection so the ConnManager can avoid to connect to the address again.

func (*ConnManager) Remove

func (cm *ConnManager) Remove(id uint64)

Remove removes the connection corresponding to the given connection id from known connections.

NOTE: This method can also be used to cancel a lingering connection attempt that hasn't yet succeeded.

func (*ConnManager) Start

func (cm *ConnManager) Start()

Start launches the connection manager and begins connecting to the network.

func (*ConnManager) Stop

func (cm *ConnManager) Stop()

Stop gracefully shuts down the connection manager.

func (*ConnManager) Wait

func (cm *ConnManager) Wait()

Wait blocks until the connection manager halts gracefully.

type ConnReq

type ConnReq struct {
	Addr      net.Addr
	Permanent bool
	// contains filtered or unexported fields
}

ConnReq is the connection request to a network address. If permanent, the connection will be retried on disconnection.

func (*ConnReq) ID

func (c *ConnReq) ID() uint64

ID returns a unique identifier for the connection request.

func (*ConnReq) State

func (c *ConnReq) State() ConnState

State is the connection state of the requested connection.

func (*ConnReq) String

func (c *ConnReq) String() string

String returns a human-readable string for the connection request.

type ConnState

type ConnState uint8

ConnState represents the state of the requested connection.

const (
	ConnPending ConnState = iota
	ConnFailing
	ConnCanceled
	ConnEstablished
	ConnDisconnected
)

ConnState can be either pending, established, disconnected or failed. When a new connection is requested, it is attempted and categorized as established or failed depending on the connection result. An established connection which was disconnected is categorized as disconnected.

type DynamicBanScore

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

DynamicBanScore provides dynamic ban scores consisting of a persistent and a decaying component. The persistent score could be utilized to create simple additive banning policies similar to those found in other node implementations.

The decaying score enables the creation of evasive logic which handles misbehaving peers (especially application layer DoS attacks) gracefully by disconnecting and banning peers attempting various kinds of flooding. DynamicBanScore allows these two approaches to be used in tandem.

Zero value: Values of type DynamicBanScore are immediately ready for use upon declaration.

func (*DynamicBanScore) Increase

func (s *DynamicBanScore) Increase(persistent, transient uint32) uint32

Increase increases both the persistent and decaying scores by the values passed as parameters. The resulting score is returned.

This function is safe for concurrent access.

func (*DynamicBanScore) Int

func (s *DynamicBanScore) Int() uint32

Int returns the current ban score, the sum of the persistent and decaying scores.

This function is safe for concurrent access.

func (*DynamicBanScore) Reset

func (s *DynamicBanScore) Reset()

Reset set both persistent and decaying scores to zero.

This function is safe for concurrent access.

func (*DynamicBanScore) String

func (s *DynamicBanScore) String() string

String returns the ban score as a human-readable string.