config

Documentation

Overview

Package config provides decoupling between various configuration sources (etcd, files,...) and the pieces that actually care about them (loadbalancer, proxy). Config takes 1 or more configuration sources and allows for incremental (add/remove) and full replace (set) changes from each of the sources, then creates a union of the configuration and provides a unified view for both service handlers as well as endpoint handlers. There is no attempt to resolve conflicts of any sort. Basic idea is that each configuration source gets a channel from the Config service and pushes updates to it via that channel. Config then keeps track of incremental & replace changes and distributes them to listeners as appropriate.

Index

• type EndpointSliceConfig
  • func NewEndpointSliceConfig(ctx context.Context, ...) *EndpointSliceConfig
  • func (c *EndpointSliceConfig) RegisterEventHandler(handler EndpointSliceHandler)
  • func (c *EndpointSliceConfig) Run(stopCh <-chan struct{})
• type EndpointSliceHandler
• type NodeConfig
  • func NewNodeConfig(ctx context.Context, nodeInformer v1informers.NodeInformer, ...) *NodeConfig
  • func (c *NodeConfig) RegisterEventHandler(handler NodeHandler)
  • func (c *NodeConfig) Run(stopCh <-chan struct{})
• type NodeHandler
• type NoopNodeHandler
  • func (*NoopNodeHandler) OnNodeAdd(node *v1.Node)
  • func (*NoopNodeHandler) OnNodeDelete(node *v1.Node)
  • func (*NoopNodeHandler) OnNodeSynced()
  • func (*NoopNodeHandler) OnNodeUpdate(oldNode, node *v1.Node)
• type ServiceCIDRConfig
  • func NewServiceCIDRConfig(ctx context.Context, ...) *ServiceCIDRConfig
  • func (c *ServiceCIDRConfig) RegisterEventHandler(handler ServiceCIDRHandler)
  • func (c *ServiceCIDRConfig) Run(stopCh <-chan struct{})
• type ServiceCIDRHandler
• type ServiceConfig
  • func NewServiceConfig(ctx context.Context, serviceInformer v1informers.ServiceInformer, ...) *ServiceConfig
  • func (c *ServiceConfig) RegisterEventHandler(handler ServiceHandler)
  • func (c *ServiceConfig) Run(stopCh <-chan struct{})
• type ServiceHandler

Types

type EndpointSliceConfig

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

EndpointSliceConfig tracks a set of endpoints configurations.

func NewEndpointSliceConfig

func NewEndpointSliceConfig(ctx context.Context, endpointSliceInformer discoveryv1informers.EndpointSliceInformer, resyncPeriod time.Duration) *EndpointSliceConfig

NewEndpointSliceConfig creates a new EndpointSliceConfig.

func (*EndpointSliceConfig) RegisterEventHandler

func (c *EndpointSliceConfig) RegisterEventHandler(handler EndpointSliceHandler)

RegisterEventHandler registers a handler which is called on every endpoint slice change.

func (*EndpointSliceConfig) Run

func (c *EndpointSliceConfig) Run(stopCh <-chan struct{})

Run waits for cache synced and invokes handlers after syncing.

type EndpointSliceHandler

type EndpointSliceHandler interface {
	// OnEndpointSliceAdd is called whenever creation of new endpoint slice
	// object is observed.
	OnEndpointSliceAdd(endpointSlice *discoveryv1.EndpointSlice)
	// OnEndpointSliceUpdate is called whenever modification of an existing
	// endpoint slice object is observed.
	OnEndpointSliceUpdate(oldEndpointSlice, newEndpointSlice *discoveryv1.EndpointSlice)
	// OnEndpointSliceDelete is called whenever deletion of an existing
	// endpoint slice object is observed.
	OnEndpointSliceDelete(endpointSlice *discoveryv1.EndpointSlice)
	// OnEndpointSlicesSynced is called once all the initial event handlers were
	// called and the state is fully propagated to local cache.
	OnEndpointSlicesSynced()
}

EndpointSliceHandler is an abstract interface of objects which receive notifications about endpoint slice object changes.

type NodeConfig

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

NodeConfig tracks a set of node configurations. It accepts "set", "add" and "remove" operations of node via channels, and invokes registered handlers on change.

func NewNodeConfig

func NewNodeConfig(ctx context.Context, nodeInformer v1informers.NodeInformer, resyncPeriod time.Duration) *NodeConfig

NewNodeConfig creates a new NodeConfig.

func (*NodeConfig) RegisterEventHandler

func (c *NodeConfig) RegisterEventHandler(handler NodeHandler)

RegisterEventHandler registers a handler which is called on every node change.

func (*NodeConfig) Run

func (c *NodeConfig) Run(stopCh <-chan struct{})

Run starts the goroutine responsible for calling registered handlers.

type NodeHandler

type NodeHandler interface {
	// OnNodeAdd is called whenever creation of new node object
	// is observed.
	OnNodeAdd(node *v1.Node)
	// OnNodeUpdate is called whenever modification of an existing
	// node object is observed.
	OnNodeUpdate(oldNode, node *v1.Node)
	// OnNodeDelete is called whenever deletion of an existing node
	// object is observed.
	OnNodeDelete(node *v1.Node)
	// OnNodeSynced is called once all the initial event handlers were
	// called and the state is fully propagated to local cache.
	OnNodeSynced()
}

NodeHandler is an abstract interface of objects which receive notifications about node object changes.

type NoopNodeHandler

type NoopNodeHandler struct{}

NoopNodeHandler is a noop handler for proxiers that have not yet implemented a full NodeHandler.

func (*NoopNodeHandler) OnNodeAdd

func (*NoopNodeHandler) OnNodeAdd(node *v1.Node)

OnNodeAdd is a noop handler for Node creates.

func (*NoopNodeHandler) OnNodeDelete

func (*NoopNodeHandler) OnNodeDelete(node *v1.Node)

OnNodeDelete is a noop handler for Node deletes.

func (*NoopNodeHandler) OnNodeSynced

func (*NoopNodeHandler) OnNodeSynced()

OnNodeSynced is a noop handler for Node syncs.

func (*NoopNodeHandler) OnNodeUpdate

func (*NoopNodeHandler) OnNodeUpdate(oldNode, node *v1.Node)

OnNodeUpdate is a noop handler for Node updates.

type ServiceCIDRConfig

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

ServiceCIDRConfig tracks a set of service configurations.

func NewServiceCIDRConfig

func NewServiceCIDRConfig(ctx context.Context, serviceCIDRInformer networkingv1beta1informers.ServiceCIDRInformer, resyncPeriod time.Duration) *ServiceCIDRConfig

NewServiceCIDRConfig creates a new ServiceCIDRConfig.

func (*ServiceCIDRConfig) RegisterEventHandler

func (c *ServiceCIDRConfig) RegisterEventHandler(handler ServiceCIDRHandler)

RegisterEventHandler registers a handler which is called on every ServiceCIDR change.

func (*ServiceCIDRConfig) Run

func (c *ServiceCIDRConfig) Run(stopCh <-chan struct{})

Run waits for cache synced and invokes handlers after syncing.

type ServiceCIDRHandler

type ServiceCIDRHandler interface {
	// OnServiceCIDRsChanged is called whenever a change is observed
	// in any of the ServiceCIDRs, and provides complete list of service cidrs.
	OnServiceCIDRsChanged(cidrs []string)
}

ServiceCIDRHandler is an abstract interface of objects which receive notifications about ServiceCIDR object changes.

type ServiceConfig

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

ServiceConfig tracks a set of service configurations.

func NewServiceConfig

func NewServiceConfig(ctx context.Context, serviceInformer v1informers.ServiceInformer, resyncPeriod time.Duration) *ServiceConfig

NewServiceConfig creates a new ServiceConfig.

func (*ServiceConfig) RegisterEventHandler

func (c *ServiceConfig) RegisterEventHandler(handler ServiceHandler)

RegisterEventHandler registers a handler which is called on every service change.

func (*ServiceConfig) Run

func (c *ServiceConfig) Run(stopCh <-chan struct{})

Run waits for cache synced and invokes handlers after syncing.

type ServiceHandler

type ServiceHandler interface {
	// OnServiceAdd is called whenever creation of new service object
	// is observed.
	OnServiceAdd(service *v1.Service)
	// OnServiceUpdate is called whenever modification of an existing
	// service object is observed.
	OnServiceUpdate(oldService, service *v1.Service)
	// OnServiceDelete is called whenever deletion of an existing service
	// object is observed.
	OnServiceDelete(service *v1.Service)
	// OnServiceSynced is called once all the initial event handlers were
	// called and the state is fully propagated to local cache.
	OnServiceSynced()
}

ServiceHandler is an abstract interface of objects which receive notifications about service object changes.