Deprecated: Use github.com/decred/dcrd/connmgr/v3 instead.
The highest tagged major version is
README
¶
connmgr
Package connmgr implements a generic Decred network connection manager.
Overview
This package handles all the general connection concerns such as maintaining a set number of outbound connections, sourcing peers, banning, limiting max connections, tor lookup, etc.
The package provides a generic connection manager which is able to accept connection requests from a source or a set of given addresses, dial them and notify the caller on connections. The main intended use is to initialize a pool of active connections and maintain them to remain connected to the P2P network.
In addition the connection manager provides the following utilities:
- Notifications on connections or disconnections
- Handle failures and retry new addresses from the source
- Connect only to specified addresses
- Permanent connections with increasing backoff retry timers
- Disconnect or Remove an established connection
Installation and Updating
$ go get -u github.com/decred/dcrd/connmgr
License
Package connmgr is licensed under the copyfree ISC License.
Documentation
¶
Overview ¶
Package connmgr implements a generic Decred network connection manager.
Connection Manager Overview ¶
Connection manager handles all the general connection concerns such as maintaining a set number of outbound connections, sourcing peers, banning, limiting max connections, tor lookup, etc.
Index ¶
- Constants
- Variables
- func DisableLog()deprecated
- func SeedFromDNS(chainParams *chaincfg.Params, reqServices wire.ServiceFlag, ...)
- func TorLookupIP(host, proxy string) ([]net.IP, error)
- func UseLogger(logger slog.Logger)
- type Config
- type ConnManager
- type ConnReq
- type ConnState
- type DynamicBanScore
- type LookupFunc
- type OnSeed
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") // ErrBothDialsFilled is used to indicate that Dial and DialAddr cannot both // be specified in the configuration. ErrBothDialsFilled = errors.New("config: cannot specify both Dial and DialAddr") )
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
deprecated
func DisableLog()
DisableLog disables all library log output. Logging output is disabled by default until UseLogger is called.
Deprecated: Use UseLogger(slog.Disabled) instead.
func SeedFromDNS ¶
func SeedFromDNS(chainParams *chaincfg.Params, reqServices wire.ServiceFlag, lookupFn LookupFunc, seedFn OnSeed)
SeedFromDNS uses DNS seeding to populate the address manager with peers.
func TorLookupIP ¶
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.
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. Either Dial or
// DialAddr need to be specified (but not both).
Dial func(network, addr string) (net.Conn, error)
// DialAddr is an alternative to Dial which receives a full net.Addr instead
// of just the protocol family and address. Either DialAddr or Dial need
// to be specified (but not both).
DialAddr 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) 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 ¶
ConnReq is the connection request to a network address. If permanent, the connection will be retried on disconnection.
type ConnState ¶
type ConnState uint32
ConnState represents the state of the requested connection.
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 bitcoin 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.
type LookupFunc ¶
LookupFunc is the signature of the DNS lookup function.
type OnSeed ¶
type OnSeed func(addrs []*wire.NetAddress)
OnSeed is the signature of the callback function which is invoked when DNS seeding is succesfull.
Source Files