v.io: v.io/x/ref/runtime/internal/flow/manager Index | Files

package manager

import "v.io/x/ref/runtime/internal/flow/manager"


Package Files

conncache.go errors.go manager.go

func New Uses

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.

type CachedConn Uses

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 Uses

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 Uses

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 Uses

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

Close closes all connections in the cache.

func (*ConnCache) EnterLameDuckMode Uses

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 Uses

func (c *ConnCache) ExportStats(prefix string)

ExportStats exports cache information to the global stats.

func (*ConnCache) Find Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

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

func (*ConnCache) KillConnections Uses

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 Uses

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

Reserve reserves the right to dial a remote endpoint.

func (*ConnCache) String Uses

func (c *ConnCache) String() string

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

type Reservation Uses

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 Uses

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

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

func (*Reservation) ProxyConn Uses

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 Uses

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.

Package manager imports 29 packages (graph) and is imported by 10 packages. Updated 2020-10-22. Refresh now. Tools for package owners.