dnet

Documentation

Overview

Package dnet contains alternative net.Conn implementations.

Index

• func FreePortsTCP(count int) ([]*net.TCPAddr, error)
• func WithPortForwardDialer(ctx context.Context, pf PortForwardDialer) context.Context
• type Addr
  • func (a Addr) Network() string
  • func (a Addr) String() string
• type Conn
  • func WrapUnbufferedConn(inner UnbufferedConn) Conn
• type DialerFunc
• type PortForwardDialer
  • func GetPortForwardDialer(ctx context.Context) PortForwardDialer
  • func NewK8sPortForwardDialer(logCtx context.Context, kubeConfig *rest.Config, ...) (PortForwardDialer, error)
• type UnbufferedConn

Functions

func FreePortsTCP

func FreePortsTCP(count int) ([]*net.TCPAddr, error)

FreePortsTCP uses net.Listen repeatedly to choose free TCP ports for the localhost. It then immediately closes the listeners and returns the addresses that were allocated.

NOTE: Since the listeners are closed, there's a chance that someone else might allocate the returned addresses before they are actually used. The chances are slim though, since tests show that in most cases (at least on macOS and Linux), the same address isn't allocated for a while even if the allocation is made from different processes.

func WithPortForwardDialer

func WithPortForwardDialer(ctx context.Context, pf PortForwardDialer) context.Context

Types

type Addr

type Addr struct {
	Net  string
	Addr string
}

func (Addr) Network

func (a Addr) Network() string

func (Addr) String

func (a Addr) String() string

type Conn

type Conn interface {
	net.Conn

	// Wait until either the connection is Close()d, or one of Read() or Write() encounters an
	// error (*not* counting errors caused by deadlines).  If this returns because Close() was
	// called, nil is returned; otherwise the triggering error is returned.
	//
	// Essentially: Wait until the connection is finished.
	Wait() error
}

Conn is a net.Conn, plus a Wait() method.

func WrapUnbufferedConn

func WrapUnbufferedConn(inner UnbufferedConn) Conn

type DialerFunc

type DialerFunc func(context.Context, string) (net.Conn, error)

type PortForwardDialer

type PortForwardDialer interface {
	io.Closer
	Dial(ctx context.Context, addr string) (net.Conn, error)
	DialPod(ctx context.Context, name, namespace string, port uint16) (net.Conn, error)
}

func GetPortForwardDialer

func GetPortForwardDialer(ctx context.Context) PortForwardDialer

func NewK8sPortForwardDialer

func NewK8sPortForwardDialer(logCtx context.Context, kubeConfig *rest.Config, k8sInterface kubernetes.Interface) (PortForwardDialer, error)

NewK8sPortForwardDialer returns a dialer function (matching the signature required by grpc.WithContextDialer) that dials to a port on a Kubernetes Pod, in the manor of `kubectl port-forward`. It returns the direct connection to the apiserver; it does not establish a local port being forwarded from or otherwise pump data over the connection.

type UnbufferedConn

type UnbufferedConn interface {
	// Receive some data over the connection.
	Recv() ([]byte, error)

	// Send some data over the connection.  Because the connection is fully-synchronous and has
	// no internal buffering, Send must not return until the remote end acknowledges the full
	// transmission (or an error is encountered).
	Send([]byte) error

	// MTU returns the largest amount of data that is permissible to include in a single Send
	// call.
	MTU() int

	// CloseOnce closes both the read-end and write-end of the connection.  Any blocked Recv or
	// Send operations will be unblocked and return errors.  It is an error to call CloseOnce
	// more than once.
	CloseOnce() error

	// LocalAddr returns the local network address.
	LocalAddr() net.Addr

	// RemoteAddr returns the remote network address.
	RemoteAddr() net.Addr
}

UnbufferedConn represents a reliable fully-synchronous stream with *no* internal buffering. But really, what it is is "everything that isn't generic enough to be in bufferedConn".