synccontroller

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: 28 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AuthorizationRoleBindingSyncController

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

AuthorizationRoleBindingSyncController is the implementation for syncing AuthorizationRoleBinding CRDs

func NewAuthorizationRoleBinding

func NewAuthorizationRoleBinding(kubeclientset kubernetes.Interface, clientset csclientset.Interface, csInformerFactory csinformers.SharedInformerFactory, cloud cscloud.Interface) *AuthorizationRoleBindingSyncController

NewAuthorizationRoleBinding returns a AuthorizationRoleBindingSyncController that will be in control of pulling from cloud comparing to the CRD cache and modifying based on those compares

func (*AuthorizationRoleBindingSyncController) Create

Create takes a authorizationRoleBinding spec in cache and creates the CRD

func (*AuthorizationRoleBindingSyncController) Delete

func (c *AuthorizationRoleBindingSyncController) Delete(namespace, name string) error

Delete takes a name of the CR and deletes it

func (*AuthorizationRoleBindingSyncController) SyncWithCloud

func (c *AuthorizationRoleBindingSyncController) SyncWithCloud(stopCh <-chan struct{}) error

SyncWithCloud kicks of the Sync() function, should be started only after Informer caches we are about to use are synced

func (*AuthorizationRoleBindingSyncController) Update

Update takes a authorizationRoleBinding spec and updates the associated AuthorizationRoleBinding CR spec with the new values

type AuthorizationRoleSyncController

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

AuthorizationRoleSyncController is the implementation for syncing AuthorizationRole CRDs

func NewAuthorizationRole

func NewAuthorizationRole(kubeclientset kubernetes.Interface, clientset csclientset.Interface, csInformerFactory csinformers.SharedInformerFactory, cloud cscloud.Interface) *AuthorizationRoleSyncController

NewAuthorizationRole returns a AuthorizationRoleSyncController that will be in control of pulling from cloud comparing to the CRD cache and modifying based on those compares

func (*AuthorizationRoleSyncController) Create

Create takes a authorizationRole spec in cache and creates the CRD

func (*AuthorizationRoleSyncController) Delete

func (c *AuthorizationRoleSyncController) Delete(namespace, name string) error

Delete takes a name of the CR and deletes it

func (*AuthorizationRoleSyncController) SyncWithCloud

func (c *AuthorizationRoleSyncController) SyncWithCloud(stopCh <-chan struct{}) error

SyncWithCloud kicks of the Sync() function, should be started only after Informer caches we are about to use are synced

func (*AuthorizationRoleSyncController) Update

func (c *AuthorizationRoleSyncController) Update(l authv3.AuthorizationRoleSpec, obj interface{}) error

Update takes a authorizationRole spec and updates the associated AuthorizationRole CR spec with the new values

type AutoscalingGroupSyncController

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

AutoscalingGroupSyncController is the implementation for syncing AutoscalingGroup CRDs

func NewAutoscalingGroupController

func NewAutoscalingGroupController(kubeclientset kubernetes.Interface, clientset cerebral.Interface, cerebralInformerFactory cerebralinformers.SharedInformerFactory, cloud cscloud.Interface) *AutoscalingGroupSyncController

NewAutoscalingGroupController returns a AutoscalingGroupSyncController that will be in control of pulling from cloud comparing to the CR cache and modifying based on those compares

func (*AutoscalingGroupSyncController) Create

Create takes an AutoscalingGroup in cache and creates the CR

func (*AutoscalingGroupSyncController) Delete

Delete takes the name of the CR and deletes it

func (*AutoscalingGroupSyncController) SyncWithCloud

func (c *AutoscalingGroupSyncController) SyncWithCloud(stopCh <-chan struct{}) error

SyncWithCloud kicks of the Sync() function, should be started only after the informer caches we are about to use are synced

func (*AutoscalingGroupSyncController) Update

func (c *AutoscalingGroupSyncController) Update(updatedAG cerebralv1alpha1.AutoscalingGroup, obj interface{}) error

Update takes an AutoscalingGroup and updates the associated AutoscalingGroup CR spec with the new values

type AutoscalingPolicySyncController

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

AutoscalingPolicySyncController is the implementation for syncing AutoscalingPolicy CRDs

func NewAutoscalingPolicyController

func NewAutoscalingPolicyController(kubeclientset kubernetes.Interface, clientset cerebral.Interface, cerebralInformerFactory cerebralinformers.SharedInformerFactory, cloud cscloud.Interface) *AutoscalingPolicySyncController

NewAutoscalingPolicyController returns a AutoscalingPolicySyncController that will be in control of pulling from cloud comparing to the CR cache and modifying based on those compares

func (*AutoscalingPolicySyncController) Create

Create takes a AutoscalingPolicy in cache and creates the CR

func (*AutoscalingPolicySyncController) Delete

Delete takes a name or the CRD and deletes it

func (*AutoscalingPolicySyncController) SyncWithCloud

func (c *AutoscalingPolicySyncController) SyncWithCloud(stopCh <-chan struct{}) error

SyncWithCloud kicks of the Sync() function, should be started only after Informer caches are synced

func (*AutoscalingPolicySyncController) Update

func (c *AutoscalingPolicySyncController) Update(updatedAG cerebralv1alpha1.AutoscalingPolicy, obj interface{}) error

Update takes an AutoscalingPolicy spec and updates the associated AutoscalingPolicy CR spec with the new values

type ClusterLabelSyncController

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

ClusterLabelSyncController is the implementation for syncing ClusterLabel CRDs

func NewClusterLabel

func NewClusterLabel(kubeclientset kubernetes.Interface, clientset csclientset.Interface, csInformerFactory csinformers.SharedInformerFactory, cloud cscloud.Interface) *ClusterLabelSyncController

NewClusterLabel returns a ClusterLabelSyncController that will be in control of pulling from cloud comparing to the CRD cache and modifying based on those compares

func (*ClusterLabelSyncController) Create

Create takes a clusterLabel spec in cache and creates the CRD

func (*ClusterLabelSyncController) Delete

func (c *ClusterLabelSyncController) Delete(namespace, name string) error

Delete takes a name of the CR and deletes it

func (*ClusterLabelSyncController) SyncWithCloud

func (c *ClusterLabelSyncController) SyncWithCloud(stopCh <-chan struct{}) error

SyncWithCloud kicks of the Sync() function, should be started only after Informer caches we are about to use are synced

func (*ClusterLabelSyncController) Update

func (c *ClusterLabelSyncController) Update(l csv3.ClusterLabelSpec, obj interface{}) error

Update takes a clusterLabel spec and updates the associated ClusterLabel CR spec with the new values

type NodePoolLabelSyncController

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

NodePoolLabelSyncController is the implementation for syncing NodePoolLabel CRDs

func NewNodePoolLabel

func NewNodePoolLabel(kubeclientset kubernetes.Interface, clientset csclientset.Interface, csInformerFactory csinformers.SharedInformerFactory, cloud cscloud.Interface) *NodePoolLabelSyncController

NewNodePoolLabel returns a NodePoolLabelSyncController that will be in control of pulling from cloud comparing to the CRD cache and modifying based on those compares

func (*NodePoolLabelSyncController) Create

Create takes a nodePoolLabel spec in cache and creates the CRD The standard Containership node pool label is added so we can easily get only node pool labels for a certain pool later on

func (*NodePoolLabelSyncController) Delete

func (c *NodePoolLabelSyncController) Delete(namespace, name string) error

Delete takes a name of the CR and deletes it

func (*NodePoolLabelSyncController) SyncWithCloud

func (c *NodePoolLabelSyncController) SyncWithCloud(stopCh <-chan struct{}) error

SyncWithCloud kicks of the Sync() function, should be started only after Informer caches we are about to use are synced

func (*NodePoolLabelSyncController) Update

func (c *NodePoolLabelSyncController) Update(l csv3.NodePoolLabelSpec, obj interface{}) error

Update takes a nodePoolLabel spec and updates the associated NodePoolLabel CR spec with the new values

type PluginSyncController

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

PluginSyncController is the implementation for syncing Plugin CRDs

func NewPlugin

func NewPlugin(kubeclientset kubernetes.Interface, clientset csclientset.Interface, csInformerFactory csinformers.SharedInformerFactory, cloud cscloud.Interface) *PluginSyncController

NewPlugin returns a PluginSyncController that will be in control of pulling from cloud comparing to the CRD cache and modifying based on those compares

func (*PluginSyncController) Create

Create takes a plugin spec in cache and creates the CRD

func (*PluginSyncController) Delete

func (c *PluginSyncController) Delete(namespace, name string) error

Delete takes a name or the CRD and deletes it

func (*PluginSyncController) SyncWithCloud

func (c *PluginSyncController) SyncWithCloud(stopCh <-chan struct{}) error

SyncWithCloud kicks of the Sync() function, should be started only after Informer caches we are about to use are synced

func (*PluginSyncController) Update

func (c *PluginSyncController) Update(p csv3.PluginSpec, obj interface{}) error

Update takes a plugin spec and updates the associated Plugin CR spec with the new values

type RegistrySyncController

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

RegistrySyncController is the implementation for syncing Registry CRDs

func NewRegistry

func NewRegistry(kubeclientset kubernetes.Interface, clientset csclientset.Interface, csInformerFactory csinformers.SharedInformerFactory, cloud cscloud.Interface) *RegistrySyncController

NewRegistry returns a RegistrySyncController that will be in control of pulling from cloud comparing to the CRD cache and modifying based on those compares

func (*RegistrySyncController) Create

Create takes a registry spec in cache and creates the CRD

func (*RegistrySyncController) Delete

func (c *RegistrySyncController) Delete(namespace, name string) error

Delete takes a name or the CRD and deletes it

func (*RegistrySyncController) SyncWithCloud

func (c *RegistrySyncController) SyncWithCloud(stopCh <-chan struct{}) error

SyncWithCloud kicks of the Sync() function, should be started only after Informer caches we are about to use are synced

type UserSyncController

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

UserSyncController is the implementation for syncing User CRDs

func NewUser

func NewUser(kubeclientset kubernetes.Interface, clientset csclientset.Interface, csInformerFactory csinformers.SharedInformerFactory, cloud cscloud.Interface) *UserSyncController

NewUser returns a UserSyncController that will be in control of pulling from cloud comparing to the CRD cache and modifying based on those compares

func (*UserSyncController) Create

func (c *UserSyncController) Create(u csv3.UserSpec) error

Create takes a user spec in cache and creates the CRD

func (*UserSyncController) Delete

func (c *UserSyncController) Delete(namespace, name string) error

Delete takes a name or the CRD and deletes it

func (*UserSyncController) SyncWithCloud

func (c *UserSyncController) SyncWithCloud(stopCh <-chan struct{}) error

SyncWithCloud kicks of the Sync() function, should be started only after Informer caches we are about to use are synced

func (*UserSyncController) Update

func (c *UserSyncController) Update(u csv3.UserSpec, obj interface{}) error

Update takes a user spec in cache and updates a User CRD spec with the same ID with that value

Jump to

Keyboard shortcuts

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