Documentation
¶
Index ¶
- Constants
- func Initialize()
- func RequestTerminate()
- func Run()
- type AuthorizationRoleBindingController
- type AuthorizationRoleController
- type CloudSynchronizer
- type ClusterLabelController
- type HKSController
- 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 HKS role bindings to Kubernetes bindings
func NewAuthorizationRoleBindingController ¶
func NewAuthorizationRoleBindingController(kubeclientset kubernetes.Interface, clientset hksclientset.Interface, kubeInformerFactory kubeinformers.SharedInformerFactory, hksInformerFactory hksinformers.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 HKS roles to Kubernetes roles
func NewAuthorizationRoleController ¶
func NewAuthorizationRoleController(kubeclientset kubernetes.Interface, clientset hksclientset.Interface, kubeInformerFactory kubeinformers.SharedInformerFactory, hksInformerFactory hksinformers.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 HKS Cloud resources into our Kubernetes CRDs.
func NewCloudSynchronizer ¶
func NewCloudSynchronizer(hksInformerFactory hksinformers.SharedInformerFactory, cerebralInformerFactory cerebralinformers.SharedInformerFactory) *CloudSynchronizer
NewCloudSynchronizer constructs a new CloudSynchronizer.
func (*CloudSynchronizer) RequestTerminate ¶
func (s *CloudSynchronizer) RequestTerminate()
RequestTerminate requests that all HKS 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 hks upgrading clusters to a users desired kubernetes version
func NewClusterLabelController ¶
func NewClusterLabelController(kubeclientset kubernetes.Interface, clientset hksclientset.Interface, kubeInformerFactory kubeinformers.SharedInformerFactory, hksInformerFactory hksinformers.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 HKSController ¶
type HKSController struct {
// contains filtered or unexported fields
}
HKSController is the controller implementation for the hks setup
func NewHKSController ¶
func NewHKSController(kubeclientset kubernetes.Interface, kubeInformerFactory kubeinformers.SharedInformerFactory) *HKSController
NewHKSController returns a new hks controller
func (*HKSController) Run ¶
func (c *HKSController) 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 hks upgrading clusters to a users desired kubernetes version
func NewNodePoolLabelController ¶
func NewNodePoolLabelController(kubeclientset kubernetes.Interface, clientset hksclientset.Interface, kubeInformerFactory kubeinformers.SharedInformerFactory, hksInformerFactory hksinformers.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 hks setup
func NewPluginController ¶
func NewPluginController(kubeclientset kubernetes.Interface, clientset hksclientset.Interface, hksInformerFactory hksinformers.SharedInformerFactory) *PluginController
NewPluginController returns a new hks 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 hksclientset.Interface, kubeInformerFactory kubeinformers.SharedInformerFactory, hksInformerFactory hksinformers.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 hks 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 hks upgrading clusters to a users desired kubernetes version
func NewUpgradeController ¶
func NewUpgradeController(kubeclientset kubernetes.Interface, clientset hksclientset.Interface, kubeInformerFactory kubeinformers.SharedInformerFactory, hksInformerFactory hksinformers.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