manager

Documentation

Index

• func New(ctx *context.T, rid naming.RoutingID, dhcpPublisher *pubsub.Publisher, ...) flow.Manager
• type CachedConn
• type ConnCache
  • func NewConnCache(idleExpiry time.Duration) *ConnCache
  • func (c *ConnCache) Close(ctx *context.T)
  • func (c *ConnCache) EnterLameDuckMode(ctx *context.T)
  • func (c *ConnCache) ExportStats(prefix string)
  • func (c *ConnCache) Find(ctx *context.T, remote naming.Endpoint, auth flow.PeerAuthorizer) (conn CachedConn, names []string, rejected []security.RejectedBlessing, ...)
  • func (c *ConnCache) FindAllCached(ctx *context.T, remote naming.Endpoint, auth flow.PeerAuthorizer) ([]CachedConn, error)
  • func (c *ConnCache) FindCached(ctx *context.T, remote naming.Endpoint, auth flow.PeerAuthorizer) (conn CachedConn, names []string, rejected []security.RejectedBlessing, ...)
  • func (c *ConnCache) Insert(conn CachedConn, proxy bool) error
  • func (c *ConnCache) InsertWithRoutingID(conn CachedConn, proxy bool) error
  • func (c *ConnCache) KillConnections(ctx *context.T, num int) error
  • func (c *ConnCache) Reserve(ctx *context.T, remote naming.Endpoint) *Reservation
  • func (c *ConnCache) String() string
• type Reservation
  • func (r *Reservation) Context() *context.T
  • func (r *Reservation) ProxyConn() CachedConn
  • func (r *Reservation) Unreserve(conn, proxyConn CachedConn, err error) error

Functions

func New

func New(
	ctx *context.T,
	rid naming.RoutingID,
	dhcpPublisher *pubsub.Publisher,
	channelTimeout time.Duration,
	idleExpiry time.Duration,
	authorizedPeers []security.BlessingPattern) flow.Manager

New creates a new flow manager.

Types

type CachedConn

type CachedConn interface {
	Status() conn.Status
	IsEncapsulated() bool
	IsIdle(*context.T, time.Duration) bool
	EnterLameDuck(*context.T) chan struct{}
	RemoteLameDuck() bool
	CloseIfIdle(*context.T, time.Duration) bool
	Close(*context.T, error)
	RemoteEndpoint() naming.Endpoint
	LocalEndpoint() naming.Endpoint
	RemoteBlessings() security.Blessings
	RemoteDischarges() map[string]security.Discharge
	RTT() time.Duration
	LastUsed() time.Time
	DebugString() string
}

CachedConn is the interface implemented by *conn.Conn that is used by ConnCache. We make the ConnCache API take this interface to make testing easier.

type ConnCache

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

ConnCache is a cache from (protocol, address) and (routingID) to a set of Conns. Multiple goroutines may invoke methods on the ConnCache simultaneously.

func NewConnCache

func NewConnCache(idleExpiry time.Duration) *ConnCache

NewConnCache creates a ConnCache with an idleExpiry for connections. If idleExpiry is zero, connections will never expire.

func (*ConnCache) Close

func (c *ConnCache) Close(ctx *context.T)

Close closes all connections in the cache.

func (*ConnCache) EnterLameDuckMode

func (c *ConnCache) EnterLameDuckMode(ctx *context.T)

EnterLameDuckMode lame ducks all connections and waits for the the remote end to acknowledge the lameduck.

func (*ConnCache) ExportStats

func (c *ConnCache) ExportStats(prefix string)

ExportStats exports cache information to the global stats.

func (*ConnCache) Find

func (c *ConnCache) Find(
	ctx *context.T,
	remote naming.Endpoint,
	auth flow.PeerAuthorizer,
) (conn CachedConn, names []string, rejected []security.RejectedBlessing, err error)

Find returns a Conn based on the input remoteEndpoint. nil is returned if there is no such Conn.

Find calls will block if the desired connections are currently being dialed. Find will return immediately if the given context is canceled.

func (*ConnCache) FindAllCached

func (c *ConnCache) FindAllCached(
	ctx *context.T,
	remote naming.Endpoint,
	auth flow.PeerAuthorizer) ([]CachedConn, error)

FindAllCached returns all Conns for the specified endpoint that are already in the cache.

func (*ConnCache) FindCached

func (c *ConnCache) FindCached(
	ctx *context.T,
	remote naming.Endpoint,
	auth flow.PeerAuthorizer) (conn CachedConn, names []string, rejected []security.RejectedBlessing, err error)

FindCached returns a Conn only if it's already in the cache.

func (*ConnCache) Insert

func (c *ConnCache) Insert(conn CachedConn, proxy bool) error

Insert adds conn to the cache, keyed by both (protocol, address) and (routingID). An error will be returned iff the cache has been closed.

func (*ConnCache) InsertWithRoutingID

func (c *ConnCache) InsertWithRoutingID(conn CachedConn, proxy bool) error

InsertWithRoutingID adds conn to the cache keyed only by conn's RoutingID.

func (*ConnCache) KillConnections

func (c *ConnCache) KillConnections(ctx *context.T, num int) error

KillConnections will closes at least num Conns in the cache. This is useful when the manager is approaching system FD limits.

The policy is as follows: (1) Remove undialable (closing/closed) conns from the cache, there is no point

in closing undialable connections to address a FD limit.

(2) Close and remove lameducked, expired connections from the cache,

counting non-proxied connections towards the removed FD count (num).

(3) LameDuck idle expired connections, killing them if num is still greater

than 0.

(4) Finally if 'num' hasn't been reached, remove the LRU remaining conns

until num is reached.

If num is greater than the number of connections in the cache, all cached connections will be closed and removed. KillConnections returns an error iff the cache is closed.

func (*ConnCache) Reserve

func (c *ConnCache) Reserve(ctx *context.T, remote naming.Endpoint) *Reservation

Reserve reserves the right to dial a remote endpoint.

func (*ConnCache) String

func (c *ConnCache) String() string

String returns a user friendly representation of the connections in the cache.

type Reservation

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

Reservation represents the right to dial a connection. We only hand out one reservation for a given connection at a time.

func (*Reservation) Context

func (r *Reservation) Context() *context.T

Context returns the context that should be used to dial the new connection.

func (*Reservation) ProxyConn

func (r *Reservation) ProxyConn() CachedConn

ProxyConn returns a connection to a relevant proxy if it exists. Otherwise it returns nil and the reservation holder should dial the proxy if necessary.

func (*Reservation) Unreserve

func (r *Reservation) Unreserve(conn, proxyConn CachedConn, err error) error

Unreserve removes this reservation, and broadcasts waiting threads to continue with their halted Find call.