mirror of
https://github.com/cloudnativelabs/kube-router.git
synced 2025-10-13 19:01:05 +02:00
127 lines
3.5 KiB
Go
127 lines
3.5 KiB
Go
/*
|
|
Copyright 2017 The Kubernetes Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package controller
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"k8s.io/apimachinery/pkg/fields"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
apiv1 "k8s.io/client-go/pkg/api/v1"
|
|
"k8s.io/client-go/rest"
|
|
"k8s.io/client-go/tools/cache"
|
|
|
|
tprv1 "k8s.io/client-go/examples/third-party-resources-deprecated/apis/tpr/v1"
|
|
)
|
|
|
|
// Watcher is an example of watching on resource create/update/delete events
|
|
type ExampleController struct {
|
|
ExampleClient *rest.RESTClient
|
|
ExampleScheme *runtime.Scheme
|
|
}
|
|
|
|
// Run starts an Example resource controller
|
|
func (c *ExampleController) Run(ctx context.Context) error {
|
|
fmt.Print("Watch Example objects\n")
|
|
|
|
// Watch Example objects
|
|
_, err := c.watchExamples(ctx)
|
|
if err != nil {
|
|
fmt.Printf("Failed to register watch for Example resource: %v\n", err)
|
|
return err
|
|
}
|
|
|
|
<-ctx.Done()
|
|
return ctx.Err()
|
|
}
|
|
|
|
func (c *ExampleController) watchExamples(ctx context.Context) (cache.Controller, error) {
|
|
source := cache.NewListWatchFromClient(
|
|
c.ExampleClient,
|
|
tprv1.ExampleResourcePlural,
|
|
apiv1.NamespaceAll,
|
|
fields.Everything())
|
|
|
|
_, controller := cache.NewInformer(
|
|
source,
|
|
|
|
// The object type.
|
|
&tprv1.Example{},
|
|
|
|
// resyncPeriod
|
|
// Every resyncPeriod, all resources in the cache will retrigger events.
|
|
// Set to 0 to disable the resync.
|
|
0,
|
|
|
|
// Your custom resource event handlers.
|
|
cache.ResourceEventHandlerFuncs{
|
|
AddFunc: c.onAdd,
|
|
UpdateFunc: c.onUpdate,
|
|
DeleteFunc: c.onDelete,
|
|
})
|
|
|
|
go controller.Run(ctx.Done())
|
|
return controller, nil
|
|
}
|
|
|
|
func (c *ExampleController) onAdd(obj interface{}) {
|
|
example := obj.(*tprv1.Example)
|
|
fmt.Printf("[CONTROLLER] OnAdd %s\n", example.ObjectMeta.SelfLink)
|
|
|
|
// NEVER modify objects from the store. It's a read-only, local cache.
|
|
// You can use exampleScheme.Copy() to make a deep copy of original object and modify this copy
|
|
// Or create a copy manually for better performance
|
|
copyObj, err := c.ExampleScheme.Copy(example)
|
|
if err != nil {
|
|
fmt.Printf("ERROR creating a deep copy of example object: %v\n", err)
|
|
return
|
|
}
|
|
|
|
exampleCopy := copyObj.(*tprv1.Example)
|
|
exampleCopy.Status = tprv1.ExampleStatus{
|
|
State: tprv1.ExampleStateProcessed,
|
|
Message: "Successfully processed by controller",
|
|
}
|
|
|
|
err = c.ExampleClient.Put().
|
|
Name(example.ObjectMeta.Name).
|
|
Namespace(example.ObjectMeta.Namespace).
|
|
Resource(tprv1.ExampleResourcePlural).
|
|
Body(exampleCopy).
|
|
Do().
|
|
Error()
|
|
|
|
if err != nil {
|
|
fmt.Printf("ERROR updating status: %v\n", err)
|
|
} else {
|
|
fmt.Printf("UPDATED status: %#v\n", exampleCopy)
|
|
}
|
|
}
|
|
|
|
func (c *ExampleController) onUpdate(oldObj, newObj interface{}) {
|
|
oldExample := oldObj.(*tprv1.Example)
|
|
newExample := newObj.(*tprv1.Example)
|
|
fmt.Printf("[CONTROLLER] OnUpdate oldObj: %s\n", oldExample.ObjectMeta.SelfLink)
|
|
fmt.Printf("[CONTROLLER] OnUpdate newObj: %s\n", newExample.ObjectMeta.SelfLink)
|
|
}
|
|
|
|
func (c *ExampleController) onDelete(obj interface{}) {
|
|
example := obj.(*tprv1.Example)
|
|
fmt.Printf("[CONTROLLER] OnDelete %s\n", example.ObjectMeta.SelfLink)
|
|
}
|