userspace

Documentation

Index

• Variables
• func CleanupLeftovers(ipt iptables.Interface) (encounteredError bool)
• func IsProxyLocked(err error) bool
• func ProxyTCP(in, out *net.TCPConn)
• func TryConnectEndpoints(service proxy.ServicePortName, srcAddr net.Addr, protocol string, ...) (net.Conn, error)
• type ClientCache
• type LoadBalancer
• type LoadBalancerRR
  • func NewLoadBalancerRR() *LoadBalancerRR
  • func (lb *LoadBalancerRR) CleanupStaleStickySessions(svcPort proxy.ServicePortName)
  • func (lb *LoadBalancerRR) NewService(svcPort proxy.ServicePortName, affinityType api.ServiceAffinity, ...) error
  • func (lb *LoadBalancerRR) NextEndpoint(svcPort proxy.ServicePortName, srcAddr net.Addr, sessionAffinityReset bool) (string, error)
  • func (lb *LoadBalancerRR) OnEndpointsUpdate(allEndpoints []api.Endpoints)
  • func (lb *LoadBalancerRR) ServiceHasEndpoints(svcPort proxy.ServicePortName) bool
• type PortAllocator
• type Proxier
  • func NewCustomProxier(loadBalancer LoadBalancer, listenIP net.IP, iptables iptables.Interface, ...) (*Proxier, error)
  • func NewProxier(loadBalancer LoadBalancer, listenIP net.IP, iptables iptables.Interface, ...) (*Proxier, error)
  • func (proxier *Proxier) OnServiceUpdate(services []api.Service)
  • func (proxier *Proxier) Sync()
  • func (proxier *Proxier) SyncLoop()
• type ProxySocket
  • func NewProxySocket(protocol api.Protocol, ip net.IP, port int) (ProxySocket, error)
• type ProxySocketFunc
• type ServiceInfo
  • func (info *ServiceInfo) IsAlive() bool

Variables

var (
	ErrMissingServiceEntry = errors.New("missing service entry")
	ErrMissingEndpoints    = errors.New("missing endpoints")
)

var EndpointDialTimeout = []time.Duration{250 * time.Millisecond, 500 * time.Millisecond, 1 * time.Second, 2 * time.Second}

How long we wait for a connection to a backend in seconds

var (
	// ErrProxyOnLocalhost is returned by NewProxier if the user requests a proxier on
	// the loopback address. May be checked for by callers of NewProxier to know whether
	// the caller provided invalid input.
	ErrProxyOnLocalhost = fmt.Errorf("cannot proxy on localhost")
)

Functions

func CleanupLeftovers

func CleanupLeftovers(ipt iptables.Interface) (encounteredError bool)

CleanupLeftovers removes all iptables rules and chains created by the Proxier It returns true if an error was encountered. Errors are logged.

func IsProxyLocked

func IsProxyLocked(err error) bool

IsProxyLocked returns true if the proxy could not acquire the lock on iptables.

func ProxyTCP

func ProxyTCP(in, out *net.TCPConn)

proxyTCP proxies data bi-directionally between in and out.

func TryConnectEndpoints

func TryConnectEndpoints(service proxy.ServicePortName, srcAddr net.Addr, protocol string, loadBalancer LoadBalancer) (net.Conn, error)

TryConnectEndpoints attempts to connect to the next available endpoint for the given service, cycling through until it is able to successfully connect, or it has tried with all timeouts in EndpointsDialTimeout.

Types

type ClientCache

type ClientCache struct {
	sync.Mutex
	Clients map[string]net.Conn // addr string -> connection
}

Holds all the known UDP clients that have not timed out.

type LoadBalancer

type LoadBalancer interface {
	// NextEndpoint returns the endpoint to handle a request for the given
	// service-port and source address.
	NextEndpoint(service proxy.ServicePortName, srcAddr net.Addr, sessionAffinityReset bool) (string, error)
	NewService(service proxy.ServicePortName, sessionAffinityType api.ServiceAffinity, stickyMaxAgeMinutes int) error
	CleanupStaleStickySessions(service proxy.ServicePortName)
	ServiceHasEndpoints(service proxy.ServicePortName) bool
}

LoadBalancer is an interface for distributing incoming requests to service endpoints.

type LoadBalancerRR

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

LoadBalancerRR is a round-robin load balancer.

func NewLoadBalancerRR

func NewLoadBalancerRR() *LoadBalancerRR

NewLoadBalancerRR returns a new LoadBalancerRR.

func (*LoadBalancerRR) CleanupStaleStickySessions

func (lb *LoadBalancerRR) CleanupStaleStickySessions(svcPort proxy.ServicePortName)

func (*LoadBalancerRR) NewService

func (lb *LoadBalancerRR) NewService(svcPort proxy.ServicePortName, affinityType api.ServiceAffinity, ttlMinutes int) error

func (*LoadBalancerRR) NextEndpoint

func (lb *LoadBalancerRR) NextEndpoint(svcPort proxy.ServicePortName, srcAddr net.Addr, sessionAffinityReset bool) (string, error)

NextEndpoint returns a service endpoint. The service endpoint is chosen using the round-robin algorithm.

func (*LoadBalancerRR) OnEndpointsUpdate

func (lb *LoadBalancerRR) OnEndpointsUpdate(allEndpoints []api.Endpoints)

OnEndpointsUpdate manages the registered service endpoints. Registered endpoints are updated if found in the update set or unregistered if missing from the update set.

func (*LoadBalancerRR) ServiceHasEndpoints

func (lb *LoadBalancerRR) ServiceHasEndpoints(svcPort proxy.ServicePortName) bool

ServiceHasEndpoints checks whether a service entry has endpoints.

type PortAllocator

type PortAllocator interface {
	AllocateNext() (int, error)
	Release(int)
}

type Proxier

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

Proxier is a simple proxy for TCP connections between a localhost:lport and services that provide the actual implementations.

func NewCustomProxier

func NewCustomProxier(loadBalancer LoadBalancer, listenIP net.IP, iptables iptables.Interface, exec utilexec.Interface, pr utilnet.PortRange, syncPeriod, udpIdleTimeout time.Duration, makeProxySocket ProxySocketFunc) (*Proxier, error)

NewCustomProxier functions similarly to NewProxier, returing a new Proxier for the given LadBalancer and address. The new proxier is constructed using the ProxySocket constructor provided, however, instead of constructing the default ProxySockets.

func NewProxier

func NewProxier(loadBalancer LoadBalancer, listenIP net.IP, iptables iptables.Interface, exec utilexec.Interface, pr utilnet.PortRange, syncPeriod, udpIdleTimeout time.Duration) (*Proxier, error)

NewProxier returns a new Proxier given a LoadBalancer and an address on which to listen. Because of the iptables logic, It is assumed that there is only a single Proxier active on a machine. An error will be returned if the proxier cannot be started due to an invalid ListenIP (loopback) or if iptables fails to update or acquire the initial lock. Once a proxier is created, it will keep iptables up to date in the background and will not terminate if a particular iptables call fails.

func (*Proxier) OnServiceUpdate

func (proxier *Proxier) OnServiceUpdate(services []api.Service)

OnServiceUpdate manages the active set of service proxies. Active service proxies are reinitialized if found in the update set or shutdown if missing from the update set.

func (*Proxier) Sync

func (proxier *Proxier) Sync()

Sync is called to immediately synchronize the proxier state to iptables

func (*Proxier) SyncLoop

func (proxier *Proxier) SyncLoop()

SyncLoop runs periodic work. This is expected to run as a goroutine or as the main loop of the app. It does not return.

type ProxySocket

type ProxySocket interface {
	// Addr gets the net.Addr for a ProxySocket.
	Addr() net.Addr
	// Close stops the ProxySocket from accepting incoming connections.
	// Each implementation should comment on the impact of calling Close
	// while sessions are active.
	Close() error
	// ProxyLoop proxies incoming connections for the specified service to the service endpoints.
	ProxyLoop(service proxy.ServicePortName, info *ServiceInfo, loadBalancer LoadBalancer)
	// ListenPort returns the host port that the ProxySocket is listening on
	ListenPort() int
}

Abstraction over TCP/UDP sockets which are proxied.

func NewProxySocket

func NewProxySocket(protocol api.Protocol, ip net.IP, port int) (ProxySocket, error)

type ProxySocketFunc

type ProxySocketFunc func(protocol api.Protocol, ip net.IP, port int) (ProxySocket, error)

ProxySocketFunc is a function which constructs a ProxySocket from a protocol, ip, and port

type ServiceInfo

type ServiceInfo struct {
	Timeout       time.Duration
	ActiveClients *ClientCache
	ServiceRef    api.ObjectReference
	// contains filtered or unexported fields
}

func (*ServiceInfo) IsAlive

func (info *ServiceInfo) IsAlive() bool