First

registry/consul_node.go

@@ -0,0 +1,20 @@
+package registry
+
+type ConsulNode struct {
+	Node        string
+	NodeId      string
+	NodeAddress string
+	NodePort    int
+}
+
+func (c *ConsulNode) Id() string {
+	return c.NodeId
+}
+
+func (c *ConsulNode) Address() string {
+	return c.NodeAddress
+}
+
+func (c *ConsulNode) Port() int {
+	return c.NodePort
+}

registry/consul_registry.go

@@ -0,0 +1,108 @@
+package registry
+
+import (
+	"errors"
+
+	consul "github.com/armon/consul-api"
+)
+
+type ConsulRegistry struct {
+	Client *consul.Client
+}
+
+var (
+	ConsulCheckTTL = "30s"
+)
+
+func (c *ConsulRegistry) Deregister(s Service) error {
+	if len(s.Nodes()) == 0 {
+		return errors.New("Require at least one node")
+	}
+
+	node := s.Nodes()[0]
+
+	_, err := c.Client.Catalog().Deregister(&consul.CatalogDeregistration{
+		Node:      node.Id(),
+		Address:   node.Address(),
+		ServiceID: node.Id(),
+	}, nil)
+
+	return err
+}
+
+func (c *ConsulRegistry) Register(s Service) error {
+	if len(s.Nodes()) == 0 {
+		return errors.New("Require at least one node")
+	}
+
+	node := s.Nodes()[0]
+
+	_, err := c.Client.Catalog().Register(&consul.CatalogRegistration{
+		Node:    node.Id(),
+		Address: node.Address(),
+		Service: &consul.AgentService{
+			ID:      node.Id(),
+			Service: s.Name(),
+			Port:    node.Port(),
+		},
+	}, nil)
+
+	return err
+}
+
+func (c *ConsulRegistry) GetService(name string) (Service, error) {
+	rsp, _, err := c.Client.Catalog().Service(name, "", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	cs := &ConsulService{}
+
+	for _, s := range rsp {
+		if s.ServiceName != name {
+			continue
+		}
+
+		cs.ServiceName = s.ServiceName
+		cs.ServiceNodes = append(cs.ServiceNodes, &ConsulNode{
+			Node:        s.Node,
+			NodeId:      s.ServiceID,
+			NodeAddress: s.Address,
+			NodePort:    s.ServicePort,
+		})
+	}
+
+	return cs, nil
+}
+
+func (c *ConsulRegistry) NewService(name string, nodes ...Node) Service {
+	var snodes []*ConsulNode
+
+	for _, node := range nodes {
+		if n, ok := node.(*ConsulNode); ok {
+			snodes = append(snodes, n)
+		}
+	}
+
+	return &ConsulService{
+		ServiceName:  name,
+		ServiceNodes: snodes,
+	}
+}
+
+func (c *ConsulRegistry) NewNode(id, address string, port int) Node {
+	return &ConsulNode{
+		Node:        id,
+		NodeId:      id,
+		NodeAddress: address,
+		NodePort:    port,
+	}
+}
+
+func NewConsulRegistry() Registry {
+	client, _ := consul.NewClient(&consul.Config{})
+
+	return &ConsulRegistry{
+		Client: client,
+	}
+}

registry/consul_service.go

@@ -0,0 +1,20 @@
+package registry
+
+type ConsulService struct {
+	ServiceName  string
+	ServiceNodes []*ConsulNode
+}
+
+func (c *ConsulService) Name() string {
+	return c.ServiceName
+}
+
+func (c *ConsulService) Nodes() []Node {
+	var nodes []Node
+
+	for _, node := range c.ServiceNodes {
+		nodes = append(nodes, node)
+	}
+
+	return nodes
+}

registry/kubernetes_node.go

@@ -0,0 +1,19 @@
+package registry
+
+type KubernetesNode struct {
+	NodeId      string
+	NodeAddress string
+	NodePort    int
+}
+
+func (c *KubernetesNode) Id() string {
+	return c.NodeId
+}
+
+func (c *KubernetesNode) Address() string {
+	return c.NodeAddress
+}
+
+func (c *KubernetesNode) Port() int {
+	return c.NodePort
+}

registry/kubernetes_registry.go

@@ -0,0 +1,77 @@
+package registry
+
+import (
+	"fmt"
+	"os"
+
+	k8s "github.com/GoogleCloudPlatform/kubernetes/pkg/client"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+)
+
+type KubernetesRegistry struct {
+	Client    *k8s.Client
+	Namespace string
+}
+
+func (c *KubernetesRegistry) Deregister(s Service) error {
+	return nil
+}
+
+func (c *KubernetesRegistry) Register(s Service) error {
+	return nil
+}
+
+func (c *KubernetesRegistry) GetService(name string) (Service, error) {
+	services, err := c.Client.Services(c.Namespace).List(labels.OneTermEqualSelector("name", name))
+	if err != nil {
+		return nil, err
+	}
+
+	if len(services.Items) == 0 {
+		return nil, fmt.Errorf("Service not found")
+	}
+
+	ks := &KubernetesService{ServiceName: name}
+	for _, item := range services.Items {
+		ks.ServiceNodes = append(ks.ServiceNodes, &KubernetesNode{
+			NodeAddress: item.Spec.PortalIP,
+			NodePort:    item.Spec.Port,
+		})
+	}
+
+	return ks, nil
+}
+
+func (c *KubernetesRegistry) NewService(name string, nodes ...Node) Service {
+	var snodes []*KubernetesNode
+
+	for _, node := range nodes {
+		if n, ok := node.(*KubernetesNode); ok {
+			snodes = append(snodes, n)
+		}
+	}
+
+	return &KubernetesService{
+		ServiceName:  name,
+		ServiceNodes: snodes,
+	}
+}
+
+func (c *KubernetesRegistry) NewNode(id, address string, port int) Node {
+	return &KubernetesNode{
+		NodeId:      id,
+		NodeAddress: address,
+		NodePort:    port,
+	}
+}
+
+func NewKubernetesRegistry() Registry {
+	client, _ := k8s.New(&k8s.Config{
+		Host: "http://" + os.Getenv("KUBERNETES_RO_SERVICE_HOST") + ":" + os.Getenv("KUBERNETES_RO_SERVICE_PORT"),
+	})
+
+	return &KubernetesRegistry{
+		Client:    client,
+		Namespace: "default",
+	}
+}

registry/kubernetes_service.go

@@ -0,0 +1,20 @@
+package registry
+
+type KubernetesService struct {
+	ServiceName  string
+	ServiceNodes []*KubernetesNode
+}
+
+func (c *KubernetesService) Name() string {
+	return c.ServiceName
+}
+
+func (c *KubernetesService) Nodes() []Node {
+	var nodes []Node
+
+	for _, node := range c.ServiceNodes {
+		nodes = append(nodes, node)
+	}
+
+	return nodes
+}

registry/node.go

@@ -0,0 +1,11 @@
+package registry
+
+type Node interface {
+	Id() string
+	Address() string
+	Port() int
+}
+
+func NewNode(id, address string, port int) Node {
+	return DefaultRegistry.NewNode(id, address, port)
+}

registry/registry.go

@@ -0,0 +1,25 @@
+package registry
+
+type Registry interface {
+	Register(Service) error
+	Deregister(Service) error
+	GetService(string) (Service, error)
+	NewService(string, ...Node) Service
+	NewNode(string, string, int) Node
+}
+
+var (
+	DefaultRegistry = NewConsulRegistry()
+)
+
+func Register(s Service) error {
+	return DefaultRegistry.Register(s)
+}
+
+func Deregister(s Service) error {
+	return DefaultRegistry.Deregister(s)
+}
+
+func GetService(name string) (Service, error) {
+	return DefaultRegistry.GetService(name)
+}

registry/service.go

@@ -0,0 +1,10 @@
+package registry
+
+type Service interface {
+	Name() string
+	Nodes() []Node
+}
+
+func NewService(name string, nodes ...Node) Service {
+	return DefaultRegistry.NewService(name, nodes...)
+}