How to watch events on a kubernetes service using its go client

This is the latest version client-go's usage example. According the above code.

    package main

    import (
        "fmt"
        "time"

         "github.com/golang/glog"

         "k8s.io/api/core/v1"
         "k8s.io/apimachinery/pkg/fields"
         "k8s.io/client-go/kubernetes"
         "k8s.io/client-go/tools/cache"
         "k8s.io/client-go/tools/clientcmd"
    )

    func main() {
        config, err := clientcmd.BuildConfigFromFlags("", "")
        if err != nil {
            glog.Errorln(err)
        }
        clientset, err := kubernetes.NewForConfig(config)
        if err != nil {
            glog.Errorln(err)
        }

        watchlist := cache.NewListWatchFromClient(
            clientset.CoreV1().RESTClient(),
            string(v1.ResourceServices),
            v1.NamespaceAll,
            fields.Everything(),
        )
        _, controller := cache.NewInformer( // also take a look at NewSharedIndexInformer
            watchlist,
            &v1.Service{},
            0, //Duration is int64
            cache.ResourceEventHandlerFuncs{
                AddFunc: func(obj interface{}) {
                    fmt.Printf("service added: %s \n", obj)
                },
                DeleteFunc: func(obj interface{}) {
                    fmt.Printf("service deleted: %s \n", obj)
                },
                UpdateFunc: func(oldObj, newObj interface{}) {
                    fmt.Printf("service changed \n")
                },
             },
         )
         // I found it in k8s scheduler module. Maybe it's help if you interested in.
         // serviceInformer := cache.NewSharedIndexInformer(watchlist, &v1.Service{}, 0, cache.Indexers{
         //     cache.NamespaceIndex: cache.MetaNamespaceIndexFunc,
         // })
         // go serviceInformer.Run(stop)
        stop := make(chan struct{})
        defer close(stop)
        go controller.Run(stop)
        for {
            time.Sleep(time.Second)
        }
    }

This is a simple one using SharedInformerFactory.

package main

import (
    "fmt"
    "time"

    "github.com/golang/glog"

    kubeinformers "k8s.io/client-go/informers"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/tools/clientcmd"
)

func main() {
    config, err := clientcmd.BuildConfigFromFlags("", "")
    if err != nil {
        glog.Errorln(err)
    }
    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        glog.Errorln(err)
    }

    kubeInformerFactory := kubeinformers.NewSharedInformerFactory(clientset, time.Second*30)
    svcInformer := kubeInformerFactory.Core().V1().Services().Informer()

    svcInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc: func(obj interface{}) {
            fmt.Printf("service added: %s \n", obj)
        },
        DeleteFunc: func(obj interface{}) {
            fmt.Printf("service deleted: %s \n", obj)
        },
        UpdateFunc: func(oldObj, newObj interface{}) {
            fmt.Printf("service changed: %s \n", newObj)
        },
    },)

    stop := make(chan struct{})
    defer close(stop)
    kubeInformerFactory.Start(stop)
    for {
        time.Sleep(time.Second)
    }
}

this can be done like this:

package main

import (
    "fmt"
    "flag"
    "time"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/pkg/api/v1"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/pkg/fields"
)

var (
    kubeconfig = flag.String("kubeconfig", "./config", "absolute path to the kubeconfig file")
)

func main() {
    flag.Parse()
    config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
    if err != nil {
        panic(err.Error())
    }
    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        panic(err.Error())
    }

    watchlist := cache.NewListWatchFromClient(clientset.Core().RESTClient(), "services", v1.NamespaceDefault,
        fields.Everything())
    _, controller := cache.NewInformer(
        watchlist,
        &v1.Service{},
        time.Second * 0,
        cache.ResourceEventHandlerFuncs{
            AddFunc: func(obj interface{}) {
                fmt.Printf("service added: %s \n", obj)
            },
            DeleteFunc: func(obj interface{}) {
                fmt.Printf("service deleted: %s \n", obj)
            },
            UpdateFunc:func(oldObj, newObj interface{}) {
                fmt.Printf("service changed \n")
            },
        },
    )
    stop := make(chan struct{})
    go controller.Run(stop)
    for{
        time.Sleep(time.Second)
    }
}