main.go

package main

import (
	"context"
	"log"
	"time"

	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/apimachinery/pkg/runtime"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/cache"
	ctrlruntimeclient "sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/kcp"
)

func main() {
	ctx := context.Background()

	log.Println("Hello.")

	time.Sleep(5 * time.Second)

	scheme := runtime.NewScheme()
	utilruntime.Must(corev1.AddToScheme(scheme))

	restConfig := ctrl.GetConfigOrDie()

	cacheObj, err := cache.New(restConfig, cache.Options{
		Scheme: scheme,
		DefaultNamespaces: map[string]cache.Config{
			cache.AllNamespaces: {},
		},
	})
	if err != nil {
		log.Fatalf("Failed to create cache: %v", err)
	}

	client, err := kcp.NewClusterAwareClientWithWatch(ctrl.GetConfigOrDie(), ctrlruntimeclient.Options{
		Scheme: scheme,
		Cache: &ctrlruntimeclient.CacheOptions{
			Unstructured: true,
			Reader:       cacheObj,
		},
	})
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}

	go cacheObj.Start(ctx)
	if !cacheObj.WaitForCacheSync(ctx) {
		log.Fatal("Failed to wait for caches to sync.")
	}

	log.Println("Beginning to watch.")

	secrets := &unstructured.UnstructuredList{}
	secrets.SetAPIVersion("v1")
	secrets.SetKind("Secret")

	watcher, err := client.Watch(ctx, secrets)
	if err != nil {
		log.Fatalf("Failed to watch secrets: %v", err)
	}

	for result := range watcher.ResultChan() {
		secret := result.Object.(*unstructured.Unstructured)
		log.Printf("event for %s/%s.\n", secret.GetNamespace(), secret.GetName())

		secretObj := &unstructured.Unstructured{}
		secretObj.SetAPIVersion("v1")
		secretObj.SetKind("Secret")

		if err := client.Get(ctx, ctrlruntimeclient.ObjectKeyFromObject(secret), secretObj); err != nil {
			log.Printf("Failed to get Secret: %v", err)
		}
	}

	log.Println("Done.")
}