add support for streaming requests. cleanup watcher initilisation

registry/kubernetes/kubernetes.go

@@ -19,10 +19,6 @@ type kregistry struct {
 	services map[string]*registry.Service
 }
 
-func (c *kregistry) Watch() {
-	newWatcher(c)
-}
-
 func (c *kregistry) Deregister(s *registry.Service) error {
 	return nil
 }
@@ -97,6 +93,10 @@ func (c *kregistry) ListServices() ([]*registry.Service, error) {
 	return services, nil
 }
 
+func (c *kregistry) Watch() (registry.Watcher, error) {
+	return newWatcher(c)
+}
+
 func NewRegistry(addrs []string, opts ...registry.Option) registry.Registry {
 	host := "http://" + os.Getenv("KUBERNETES_RO_SERVICE_HOST") + ":" + os.Getenv("KUBERNETES_RO_SERVICE_PORT")
 	if len(addrs) > 0 {
@@ -113,7 +113,5 @@ func NewRegistry(addrs []string, opts ...registry.Option) registry.Registry {
 		services:  make(map[string]*registry.Service),
 	}
 
-	kr.Watch()
-
 	return kr
 }

registry/kubernetes/watcher.go

@@ -1,73 +1,91 @@
 package kubernetes
 
 import (
-	"fmt"
 	"net"
-	"time"
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/proxy/config"
-	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/fields"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/watch"
 	"github.com/myodc/go-micro/registry"
 )
 
 type watcher struct {
 	registry *kregistry
+	watcher  watch.Interface
 }
 
-func (k *watcher) OnUpdate(services []api.Service) {
-	fmt.Println("got update")
-	activeServices := util.StringSet{}
-	for _, svc := range services {
-		fmt.Printf("%#v\n", svc.ObjectMeta)
-		name, exists := svc.ObjectMeta.Labels["name"]
-		if !exists {
-			continue
-		}
-
-		activeServices.Insert(name)
-		serviceIP := net.ParseIP(svc.Spec.ClusterIP)
-
-		ks := &registry.Service{
-			Name: name,
-			Nodes: []*registry.Node{
-				&registry.Node{
-					Address: serviceIP.String(),
-					Port:    svc.Spec.Ports[0].Port,
-				},
-			},
-		}
-
-		k.registry.mtx.Lock()
-		k.registry.services[name] = ks
-		k.registry.mtx.Unlock()
+func (k *watcher) update(event watch.Event) {
+	if event.Object == nil {
+		return
 	}
 
+	var service *api.Service
+	switch obj := event.Object.(type) {
+	case *api.Service:
+		service = obj
+	default:
+		return
+	}
+
+	name, exists := service.ObjectMeta.Labels["name"]
+	if !exists {
+		return
+	}
+
+	switch event.Type {
+	case watch.Added, watch.Modified:
+	case watch.Deleted:
+		k.registry.mtx.Lock()
+		delete(k.registry.services, name)
+		k.registry.mtx.Unlock()
+		return
+	default:
+		return
+	}
+
+	serviceIP := net.ParseIP(service.Spec.ClusterIP)
+
 	k.registry.mtx.Lock()
-	defer k.registry.mtx.Unlock()
-	for name, _ := range k.registry.services {
-		if !activeServices.Has(name) {
-			delete(k.registry.services, name)
-		}
+	k.registry.services[name] = &registry.Service{
+		Name: name,
+		Nodes: []*registry.Node{
+			&registry.Node{
+				Address: serviceIP.String(),
+				Port:    service.Spec.Ports[0].Port,
+			},
+		},
 	}
+	k.registry.mtx.Unlock()
 }
 
-func newWatcher(kr *kregistry) *watcher {
-	serviceConfig := config.NewServiceConfig()
-	endpointsConfig := config.NewEndpointsConfig()
+func (k *watcher) Stop() {
+	k.watcher.Stop()
+}
 
-	config.NewSourceAPI(
-		kr.client.Services(api.NamespaceAll),
-		kr.client.Endpoints(api.NamespaceAll),
-		time.Second*10,
-		serviceConfig.Channel("api"),
-		endpointsConfig.Channel("api"),
-	)
+func newWatcher(kr *kregistry) (registry.Watcher, error) {
+	svi := kr.client.Services(api.NamespaceAll)
 
-	ks := &watcher{
+	services, err := svi.List(labels.Everything())
+	if err != nil {
+		return nil, err
+	}
+
+	watch, err := svi.Watch(labels.Everything(), fields.Everything(), services.ResourceVersion)
+	if err != nil {
+		return nil, err
+	}
+
+	w := &watcher{
 		registry: kr,
+		watcher:  watch,
 	}
 
-	serviceConfig.RegisterHandler(ks)
-	return ks
+	go func() {
+		for event := range watch.ResultChan() {
+			w.update(event)
+		}
+	}()
+
+	return w, nil
 }