Documentation
¶
Index ¶
- Constants
- func Initialize()
- func RequestTerminate()
- func Run()
- type AuthorizationRoleBindingController
- type AuthorizationRoleController
- type CloudSynchronizer
- type ClusterLabelController
- type ContainershipController
- type NodePoolLabelController
- type PluginController
- type RegistryController
- type UpgradeController
Constants ¶
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
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.
Source Files