coordinator

package
v7.1.1+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Aug 29, 2019 License: Apache-2.0 Imports: 49 Imported by: 0

Documentation

Index

Constants

View Source
const (
	// DockerConfigStringFormat is used for Docker tokens, using endpoint, and auth token as password
	DockerConfigStringFormat = `{"%s":{"username":"_json_key","password":"%s","email":"none"}}`
	// DockerJSONStringFormat is used for JSON tokens, endpoint is used under auths,
	// while auth is the token generated
	DockerJSONStringFormat = `{"auths":{"%s":{"auth":"%s","email":"none"}}}`
)

Variables

This section is empty.

Functions

func Initialize

func Initialize()

Initialize creates the informer factories, controller, and synchronizer.

func RequestTerminate

func RequestTerminate()

RequestTerminate requests to stop syncing, clean up, and terminate

func Run

func Run()

Run kicks off the informer factories, controller, and synchronizer.

Types

type AuthorizationRoleBindingController

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

AuthorizationRoleBindingController syncs Containership role bindings to Kubernetes bindings

func NewAuthorizationRoleBindingController

func NewAuthorizationRoleBindingController(kubeclientset kubernetes.Interface,
	clientset csclientset.Interface,
	kubeInformerFactory kubeinformers.SharedInformerFactory,
	csInformerFactory csinformers.SharedInformerFactory) *AuthorizationRoleBindingController

NewAuthorizationRoleBindingController returns a new clusterRoleBinding controller

func (*AuthorizationRoleBindingController) Run

func (c *AuthorizationRoleBindingController) Run(numWorkers int, stopCh chan struct{})

Run will set up the event handlers for types we are interested in, as well as syncing informer caches and starting workers. It will block until stopCh is closed, at which point it will shutdown the workqueue and wait for workers to finish processing their current work items.

type AuthorizationRoleController

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

AuthorizationRoleController syncs Containership roles to Kubernetes roles

func NewAuthorizationRoleController

func NewAuthorizationRoleController(kubeclientset kubernetes.Interface,
	clientset csclientset.Interface,
	kubeInformerFactory kubeinformers.SharedInformerFactory,
	csInformerFactory csinformers.SharedInformerFactory) *AuthorizationRoleController

NewAuthorizationRoleController returns a new clusterRole controller

func (*AuthorizationRoleController) Run

func (c *AuthorizationRoleController) Run(numWorkers int, stopCh chan struct{})

Run will set up the event handlers for types we are interested in, as well as syncing informer caches and starting workers. It will block until stopCh is closed, at which point it will shutdown the workqueue and wait for workers to finish processing their current work items.

type CloudSynchronizer

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

CloudSynchronizer synchronizes Containership Cloud resources into our Kubernetes CRDs.

func NewCloudSynchronizer

func NewCloudSynchronizer(csInformerFactory csinformers.SharedInformerFactory, cerebralInformerFactory cerebralinformers.SharedInformerFactory) *CloudSynchronizer

NewCloudSynchronizer constructs a new CloudSynchronizer.

func (*CloudSynchronizer) RequestTerminate

func (s *CloudSynchronizer) RequestTerminate()

RequestTerminate requests that all Containership resources be deleted from the cluster. It kicks off a goroutine to marks resources for deletion and returns without blocking.

func (*CloudSynchronizer) Run

func (s *CloudSynchronizer) Run()

Run kicks off cloud sync routines.

type ClusterLabelController

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

ClusterLabelController is the controller implementation for the containership upgrading clusters to a users desired kubernetes version

func NewClusterLabelController

func NewClusterLabelController(kubeclientset kubernetes.Interface,
	clientset csclientset.Interface,
	kubeInformerFactory kubeinformers.SharedInformerFactory,
	csInformerFactory csinformers.SharedInformerFactory) *ClusterLabelController

NewClusterLabelController returns a new clusterLabel controller

func (*ClusterLabelController) Run

func (uc *ClusterLabelController) Run(numWorkers int, stopCh chan struct{})

Run will set up the event handlers for types we are interested in, as well as syncing informer caches and starting workers. It will block until stopCh is closed, at which point it will shutdown the workqueue and wait for workers to finish processing their current work items.

type ContainershipController

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

ContainershipController is the controller implementation for the containership setup

func NewContainershipController

func NewContainershipController(kubeclientset kubernetes.Interface, kubeInformerFactory kubeinformers.SharedInformerFactory) *ContainershipController

NewContainershipController returns a new containership controller

func (*ContainershipController) Run

func (c *ContainershipController) Run(numWorkers int, stopCh chan struct{})

Run will set up the event handlers for types we are interested in, as well as syncing informer caches and starting workers. It will block until stopCh is closed, at which point it will shutdown the workqueue and wait for workers to finish processing their current work items.

type NodePoolLabelController

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

NodePoolLabelController is the controller implementation for the containership upgrading clusters to a users desired kubernetes version

func NewNodePoolLabelController

func NewNodePoolLabelController(kubeclientset kubernetes.Interface,
	clientset csclientset.Interface,
	kubeInformerFactory kubeinformers.SharedInformerFactory,
	csInformerFactory csinformers.SharedInformerFactory) *NodePoolLabelController

NewNodePoolLabelController returns a new nodePoolLabel controller

func (*NodePoolLabelController) Run

func (uc *NodePoolLabelController) Run(numWorkers int, stopCh chan struct{})

Run will set up the event handlers for types we are interested in, as well as syncing informer caches and starting workers. It will block until stopCh is closed, at which point it will shutdown the workqueue and wait for workers to finish processing their current work items.

type PluginController

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

PluginController is the controller implementation for the containership setup

func NewPluginController

func NewPluginController(kubeclientset kubernetes.Interface, clientset csclientset.Interface, csInformerFactory csinformers.SharedInformerFactory) *PluginController

NewPluginController returns a new containership controller

func (*PluginController) Run

func (c *PluginController) Run(numWorkers int, stopCh chan struct{})

Run will set up the event handlers for types we are interested in, as well as syncing informer caches and starting workers. It will block until stopCh is closed, at which point it will shutdown the workqueue and wait for workers to finish processing their current work items.

type RegistryController

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

RegistryController is the controller implementation for Registry resources

func NewRegistryController

func NewRegistryController(kubeclientset kubernetes.Interface, clientset csclientset.Interface, kubeInformerFactory kubeinformers.SharedInformerFactory, csInformerFactory csinformers.SharedInformerFactory) *RegistryController

NewRegistryController returns a new coordinator controller which watches namespace, service accounts, secrets and registries. It's job is to ensure each namespace has a secret for each registry, as well as ensuring that the containership SA in each namespace contains each secret as an image pull secret

func (*RegistryController) Run

func (c *RegistryController) Run(numWorkers int, stopCh chan struct{})

Run will set up the event handlers for types we are interested in, as well as syncing informer caches and starting workers. It will block until stopCh is closed, at which point it will shutdown the workqueue and wait for workers to finish processing their current work items.

type UpgradeController

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

UpgradeController is the controller implementation for the containership upgrading clusters to a users desired kubernetes version

func NewUpgradeController

func NewUpgradeController(kubeclientset kubernetes.Interface, clientset csclientset.Interface, kubeInformerFactory kubeinformers.SharedInformerFactory, csInformerFactory csinformers.SharedInformerFactory) *UpgradeController

NewUpgradeController returns a new upgrade controller

func (*UpgradeController) Run

func (uc *UpgradeController) Run(numWorkers int, stopCh chan struct{})

Run will set up the event handlers for types we are interested in, as well as syncing informer caches and starting workers. It will block until stopCh is closed, at which point it will shutdown the workqueue and wait for workers to finish processing their current work items.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL