Restructure go-micro layout and plugins

registry/kubernetes/kubernetes.go

@@ -0,0 +1,139 @@
+package kubernetes
+
+import (
+	"fmt"
+	"os"
+	"sync"
+
+	"github.com/myodc/go-micro/registry"
+
+	k8s "github.com/GoogleCloudPlatform/kubernetes/pkg/client"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+)
+
+type kregistry struct {
+	client    *k8s.Client
+	namespace string
+
+	mtx      sync.RWMutex
+	services map[string]registry.Service
+}
+
+func (c *kregistry) Watch() {
+	newWatcher(c)
+}
+
+func (c *kregistry) Deregister(s registry.Service) error {
+	return nil
+}
+
+func (c *kregistry) Register(s registry.Service) error {
+	return nil
+}
+
+func (c *kregistry) GetService(name string) (registry.Service, error) {
+	c.mtx.RLock()
+	svc, ok := c.services[name]
+	c.mtx.RUnlock()
+
+	if ok {
+		return svc, nil
+	}
+
+	selector := labels.SelectorFromSet(labels.Set{"name": name})
+
+	services, err := c.client.Services(c.namespace).List(selector)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(services.Items) == 0 {
+		return nil, fmt.Errorf("Service not found")
+	}
+
+	ks := &service{name: name}
+	for _, item := range services.Items {
+		ks.nodes = append(ks.nodes, &node{
+			address: item.Spec.PortalIP,
+			port:    item.Spec.Ports[0].Port,
+		})
+	}
+
+	return ks, nil
+}
+
+func (c *kregistry) ListServices() ([]registry.Service, error) {
+	c.mtx.RLock()
+	serviceMap := c.services
+	c.mtx.RUnlock()
+
+	var services []registry.Service
+
+	if len(serviceMap) > 0 {
+		for _, service := range serviceMap {
+			services = append(services, service)
+		}
+		return services, nil
+	}
+
+	rsp, err := c.client.Services(c.namespace).List(labels.Everything())
+	if err != nil {
+		return nil, err
+	}
+
+	for _, svc := range rsp.Items {
+		if len(svc.ObjectMeta.Labels["name"]) == 0 {
+			continue
+		}
+
+		services = append(services, &service{
+			name: svc.ObjectMeta.Labels["name"],
+		})
+	}
+
+	return services, nil
+}
+
+func (c *kregistry) NewService(name string, nodes ...registry.Node) registry.Service {
+	var snodes []*node
+
+	for _, nod := range nodes {
+		if n, ok := nod.(*node); ok {
+			snodes = append(snodes, n)
+		}
+	}
+
+	return &service{
+		name:  name,
+		nodes: snodes,
+	}
+}
+
+func (c *kregistry) NewNode(id, address string, port int) registry.Node {
+	return &node{
+		id:      id,
+		address: address,
+		port:    port,
+	}
+}
+
+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 {
+		host = addrs[0]
+	}
+
+	client, _ := k8s.New(&k8s.Config{
+		Host: host,
+	})
+
+	kr := &kregistry{
+		client:    client,
+		namespace: "default",
+		services:  make(map[string]registry.Service),
+	}
+
+	kr.Watch()
+
+	return kr
+}

registry/kubernetes/node.go

@@ -0,0 +1,19 @@
+package kubernetes
+
+type node struct {
+	id      string
+	address string
+	port    int
+}
+
+func (n *node) Id() string {
+	return n.id
+}
+
+func (n *node) Address() string {
+	return n.address
+}
+
+func (n *node) Port() int {
+	return n.port
+}

registry/kubernetes/service.go

@@ -0,0 +1,24 @@
+package kubernetes
+
+import (
+	"github.com/myodc/go-micro/registry"
+)
+
+type service struct {
+	name  string
+	nodes []*node
+}
+
+func (s *service) Name() string {
+	return s.name
+}
+
+func (s *service) Nodes() []registry.Node {
+	var nodes []registry.Node
+
+	for _, node := range s.nodes {
+		nodes = append(nodes, node)
+	}
+
+	return nodes
+}

registry/kubernetes/watcher.go

@@ -0,0 +1,72 @@
+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"
+)
+
+type watcher struct {
+	registry *kregistry
+}
+
+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.PortalIP)
+
+		ks := &service{
+			name: name,
+			nodes: []*node{
+				&node{
+					address: serviceIP.String(),
+					port:    svc.Spec.Ports[0].Port,
+				},
+			},
+		}
+
+		k.registry.mtx.Lock()
+		k.registry.services[name] = ks
+		k.registry.mtx.Unlock()
+	}
+
+	k.registry.mtx.Lock()
+	defer k.registry.mtx.Unlock()
+	for name, _ := range k.registry.services {
+		if !activeServices.Has(name) {
+			delete(k.registry.services, name)
+		}
+	}
+}
+
+func newWatcher(kr *kregistry) *watcher {
+	serviceConfig := config.NewServiceConfig()
+	endpointsConfig := config.NewEndpointsConfig()
+
+	config.NewSourceAPI(
+		kr.client.Services(api.NamespaceAll),
+		kr.client.Endpoints(api.NamespaceAll),
+		time.Second*10,
+		serviceConfig.Channel("api"),
+		endpointsConfig.Channel("api"),
+	)
+
+	ks := &watcher{
+		registry: kr,
+	}
+
+	serviceConfig.RegisterHandler(ks)
+	return ks
+}