kubernetes: k8s.io/kubernetes/pkg/proxy/config Index | Files

package config

import "k8s.io/kubernetes/pkg/proxy/config"

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

Package Files

config.go doc.go

type EndpointSliceConfig Uses

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

EndpointSliceConfig tracks a set of endpoints configurations.

func NewEndpointSliceConfig Uses

func NewEndpointSliceConfig(endpointSliceInformer discoveryinformers.EndpointSliceInformer, resyncPeriod time.Duration) *EndpointSliceConfig

NewEndpointSliceConfig creates a new EndpointSliceConfig.

func (*EndpointSliceConfig) RegisterEventHandler Uses

func (c *EndpointSliceConfig) RegisterEventHandler(handler EndpointSliceHandler)

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

func (*EndpointSliceConfig) Run Uses

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

Run waits for cache synced and invokes handlers after syncing.

type EndpointSliceHandler Uses

type EndpointSliceHandler interface {
    // OnEndpointSliceAdd is called whenever creation of new endpoint slice
    // object is observed.
    OnEndpointSliceAdd(endpointSlice *discovery.EndpointSlice)
    // OnEndpointSliceUpdate is called whenever modification of an existing
    // endpoint slice object is observed.
    OnEndpointSliceUpdate(oldEndpointSlice, newEndpointSlice *discovery.EndpointSlice)
    // OnEndpointSliceDelete is called whenever deletion of an existing
    // endpoint slice object is observed.
    OnEndpointSliceDelete(endpointSlice *discovery.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 EndpointsConfig Uses

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

EndpointsConfig tracks a set of endpoints configurations.

func NewEndpointsConfig Uses

func NewEndpointsConfig(endpointsInformer coreinformers.EndpointsInformer, resyncPeriod time.Duration) *EndpointsConfig

NewEndpointsConfig creates a new EndpointsConfig.

func (*EndpointsConfig) RegisterEventHandler Uses

func (c *EndpointsConfig) RegisterEventHandler(handler EndpointsHandler)

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

func (*EndpointsConfig) Run Uses

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

Run waits for cache synced and invokes handlers after syncing.

type EndpointsHandler Uses

type EndpointsHandler interface {
    // OnEndpointsAdd is called whenever creation of new endpoints object
    // is observed.
    OnEndpointsAdd(endpoints *v1.Endpoints)
    // OnEndpointsUpdate is called whenever modification of an existing
    // endpoints object is observed.
    OnEndpointsUpdate(oldEndpoints, endpoints *v1.Endpoints)
    // OnEndpointsDelete is called whenever deletion of an existing endpoints
    // object is observed.
    OnEndpointsDelete(endpoints *v1.Endpoints)
    // OnEndpointsSynced is called once all the initial event handlers were
    // called and the state is fully propagated to local cache.
    OnEndpointsSynced()
}

EndpointsHandler is an abstract interface of objects which receive notifications about endpoints object changes.

type NodeConfig Uses

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 Uses

func NewNodeConfig(nodeInformer coreinformers.NodeInformer, resyncPeriod time.Duration) *NodeConfig

NewNodeConfig creates a new NodeConfig.

func (*NodeConfig) RegisterEventHandler Uses

func (c *NodeConfig) RegisterEventHandler(handler NodeHandler)

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

func (*NodeConfig) Run Uses

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

Run starts the goroutine responsible for calling registered handlers.

type NodeHandler Uses

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 whever 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 NoopEndpointSliceHandler Uses

type NoopEndpointSliceHandler struct{}

NoopEndpointSliceHandler is a noop handler for proxiers that have not yet implemented a full EndpointSliceHandler.

func (*NoopEndpointSliceHandler) OnEndpointSliceAdd Uses

func (*NoopEndpointSliceHandler) OnEndpointSliceAdd(endpointSlice *discovery.EndpointSlice)

OnEndpointSliceAdd is a noop handler for EndpointSlice creates.

func (*NoopEndpointSliceHandler) OnEndpointSliceDelete Uses

func (*NoopEndpointSliceHandler) OnEndpointSliceDelete(endpointSlice *discovery.EndpointSlice)

OnEndpointSliceDelete is a noop handler for EndpointSlice deletes.

func (*NoopEndpointSliceHandler) OnEndpointSliceUpdate Uses

func (*NoopEndpointSliceHandler) OnEndpointSliceUpdate(oldEndpointSlice, newEndpointSlice *discovery.EndpointSlice)

OnEndpointSliceUpdate is a noop handler for EndpointSlice updates.

func (*NoopEndpointSliceHandler) OnEndpointSlicesSynced Uses

func (*NoopEndpointSliceHandler) OnEndpointSlicesSynced()

OnEndpointSlicesSynced is a noop handler for EndpointSlice syncs.

type NoopNodeHandler Uses

type NoopNodeHandler struct{}

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

func (*NoopNodeHandler) OnNodeAdd Uses

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

OnNodeAdd is a noop handler for Node creates.

func (*NoopNodeHandler) OnNodeDelete Uses

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

OnNodeDelete is a noop handler for Node deletes.

func (*NoopNodeHandler) OnNodeSynced Uses

func (*NoopNodeHandler) OnNodeSynced()

OnNodeSynced is a noop handler for Node syncs.

func (*NoopNodeHandler) OnNodeUpdate Uses

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

OnNodeUpdate is a noop handler for Node updates.

type ServiceConfig Uses

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

ServiceConfig tracks a set of service configurations.

func NewServiceConfig Uses

func NewServiceConfig(serviceInformer coreinformers.ServiceInformer, resyncPeriod time.Duration) *ServiceConfig

NewServiceConfig creates a new ServiceConfig.

func (*ServiceConfig) RegisterEventHandler Uses

func (c *ServiceConfig) RegisterEventHandler(handler ServiceHandler)

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

func (*ServiceConfig) Run Uses

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

Run waits for cache synced and invokes handlers after syncing.

type ServiceHandler Uses

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.

Package config imports 9 packages (graph) and is imported by 251 packages. Updated 2019-11-17. Refresh now. Tools for package owners.