Move plugins to go-plugins

registry/consul/consul.go

@@ -1,11 +0,0 @@
-package consul
-
-// This is a hack
-
-import (
-	"github.com/micro/go-micro/registry"
-)
-
-func NewRegistry(addrs []string, opt ...registry.Option) registry.Registry {
-	return registry.NewRegistry(addrs, opt...)
-}

registry/etcd/etcd.go

@@ -1,193 +0,0 @@
-package etcd
-
-import (
-	"encoding/json"
-	"errors"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	etcd "github.com/coreos/etcd/client"
-	"github.com/micro/go-micro/registry"
-	"golang.org/x/net/context"
-)
-
-var (
-	prefix = "/micro-registry"
-)
-
-type etcdRegistry struct {
-	client etcd.KeysAPI
-
-	sync.RWMutex
-	services map[string][]*registry.Service
-}
-
-func encode(s *registry.Service) string {
-	b, _ := json.Marshal(s)
-	return string(b)
-}
-
-func decode(ds string) *registry.Service {
-	var s *registry.Service
-	json.Unmarshal([]byte(ds), &s)
-	return s
-}
-
-func nodePath(s, id string) string {
-	service := strings.Replace(s, "/", "-", -1)
-	node := strings.Replace(id, "/", "-", -1)
-	return filepath.Join(prefix, service, node)
-}
-
-func servicePath(s string) string {
-	return filepath.Join(prefix, strings.Replace(s, "/", "-", -1))
-}
-
-func (e *etcdRegistry) Deregister(s *registry.Service) error {
-	if len(s.Nodes) == 0 {
-		return errors.New("Require at least one node")
-	}
-
-	for _, node := range s.Nodes {
-		_, err := e.client.Delete(context.Background(), nodePath(s.Name, node.Id), &etcd.DeleteOptions{Recursive: false})
-		if err != nil {
-			return err
-		}
-	}
-
-	e.client.Delete(context.Background(), servicePath(s.Name), &etcd.DeleteOptions{Dir: true})
-	return nil
-}
-
-func (e *etcdRegistry) Register(s *registry.Service) error {
-	if len(s.Nodes) == 0 {
-		return errors.New("Require at least one node")
-	}
-
-	service := &registry.Service{
-		Name:      s.Name,
-		Version:   s.Version,
-		Metadata:  s.Metadata,
-		Endpoints: s.Endpoints,
-	}
-
-	e.client.Set(context.Background(), servicePath(s.Name), "", &etcd.SetOptions{Dir: true})
-
-	for _, node := range s.Nodes {
-		service.Nodes = []*registry.Node{node}
-		_, err := e.client.Set(context.Background(), nodePath(service.Name, node.Id), encode(service), &etcd.SetOptions{})
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (e *etcdRegistry) GetService(name string) ([]*registry.Service, error) {
-	e.RLock()
-	service, ok := e.services[name]
-	e.RUnlock()
-
-	if ok {
-		return service, nil
-	}
-
-	rsp, err := e.client.Get(context.Background(), servicePath(name), &etcd.GetOptions{})
-	if err != nil && !strings.HasPrefix(err.Error(), "100: Key not found") {
-		return nil, err
-	}
-
-	serviceMap := map[string]*registry.Service{}
-
-	for _, n := range rsp.Node.Nodes {
-		if n.Dir {
-			continue
-		}
-		sn := decode(n.Value)
-
-		s, ok := serviceMap[sn.Version]
-		if !ok {
-			s = &registry.Service{
-				Name:      sn.Name,
-				Version:   sn.Version,
-				Metadata:  sn.Metadata,
-				Endpoints: sn.Endpoints,
-			}
-			serviceMap[s.Version] = s
-		}
-
-		for _, node := range sn.Nodes {
-			s.Nodes = append(s.Nodes, node)
-		}
-	}
-
-	var services []*registry.Service
-	for _, service := range serviceMap {
-		services = append(services, service)
-	}
-	return services, nil
-}
-
-func (e *etcdRegistry) ListServices() ([]*registry.Service, error) {
-	e.RLock()
-	serviceMap := e.services
-	e.RUnlock()
-
-	var services []*registry.Service
-
-	if len(serviceMap) > 0 {
-		for _, service := range serviceMap {
-			services = append(services, service...)
-		}
-		return services, nil
-	}
-
-	rsp, err := e.client.Get(context.Background(), prefix, &etcd.GetOptions{Recursive: true, Sort: true})
-	if err != nil && !strings.HasPrefix(err.Error(), "100: Key not found") {
-		return nil, err
-	}
-
-	for _, node := range rsp.Node.Nodes {
-		service := &registry.Service{}
-		for _, n := range node.Nodes {
-			i := decode(n.Value)
-			service.Name = i.Name
-		}
-		services = append(services, service)
-	}
-
-	return services, nil
-}
-
-func (e *etcdRegistry) Watch() (registry.Watcher, error) {
-	// todo: fix watcher
-	return newEtcdWatcher(e)
-}
-
-func NewRegistry(addrs []string, opt ...registry.Option) registry.Registry {
-	var cAddrs []string
-
-	for _, addr := range addrs {
-		if len(addr) == 0 {
-			continue
-		}
-		cAddrs = append(cAddrs, addr)
-	}
-
-	if len(cAddrs) == 0 {
-		cAddrs = []string{"http://127.0.0.1:2379"}
-	}
-
-	c, _ := etcd.New(etcd.Config{
-		Endpoints: cAddrs,
-	})
-
-	e := &etcdRegistry{
-		client:   etcd.NewKeysAPI(c),
-		services: make(map[string][]*registry.Service),
-	}
-
-	return e
-}

registry/etcd/watcher.go

@@ -1,151 +0,0 @@
-package etcd
-
-import (
-	etcd "github.com/coreos/etcd/client"
-	"github.com/micro/go-micro/registry"
-	"golang.org/x/net/context"
-)
-
-type etcdWatcher struct {
-	registry *etcdRegistry
-	stop     chan bool
-}
-
-func addNodes(old, neu []*registry.Node) []*registry.Node {
-	for _, n := range neu {
-		var seen bool
-		for i, o := range old {
-			if o.Id == n.Id {
-				seen = true
-				old[i] = n
-				break
-			}
-		}
-		if !seen {
-			old = append(old, n)
-		}
-	}
-	return old
-}
-
-func addServices(old, neu []*registry.Service) []*registry.Service {
-	for _, s := range neu {
-		var seen bool
-		for i, o := range old {
-			if o.Version == s.Version {
-				s.Nodes = addNodes(o.Nodes, s.Nodes)
-				seen = true
-				old[i] = s
-				break
-			}
-		}
-		if !seen {
-			old = append(old, s)
-		}
-	}
-	return old
-}
-
-func delNodes(old, del []*registry.Node) []*registry.Node {
-	var nodes []*registry.Node
-	for _, o := range old {
-		var rem bool
-		for _, n := range del {
-			if o.Id == n.Id {
-				rem = true
-				break
-			}
-		}
-		if !rem {
-			nodes = append(nodes, o)
-		}
-	}
-	return nodes
-}
-
-func delServices(old, del []*registry.Service) []*registry.Service {
-	var services []*registry.Service
-	for i, o := range old {
-		var rem bool
-		for _, s := range del {
-			if o.Version == s.Version {
-				old[i].Nodes = delNodes(o.Nodes, s.Nodes)
-				if len(old[i].Nodes) == 0 {
-					rem = true
-				}
-			}
-		}
-		if !rem {
-			services = append(services, o)
-		}
-	}
-	return services
-}
-
-func newEtcdWatcher(r *etcdRegistry) (registry.Watcher, error) {
-	ew := &etcdWatcher{
-		registry: r,
-		stop:     make(chan bool),
-	}
-
-	w := r.client.Watcher(prefix, &etcd.WatcherOptions{AfterIndex: 0, Recursive: true})
-
-	c := context.Background()
-	ctx, cancel := context.WithCancel(c)
-
-	go func() {
-		<-ew.stop
-		cancel()
-	}()
-
-	go ew.watch(ctx, w)
-
-	return ew, nil
-}
-
-func (e *etcdWatcher) watch(ctx context.Context, w etcd.Watcher) {
-	for {
-		rsp, err := w.Next(ctx)
-		if err != nil && ctx.Err() != nil {
-			return
-		}
-
-		if rsp.Node.Dir {
-			continue
-		}
-
-		s := decode(rsp.Node.Value)
-		if s == nil {
-			continue
-		}
-
-		e.registry.Lock()
-
-		service, ok := e.registry.services[s.Name]
-		if !ok {
-			if rsp.Action == "create" {
-				e.registry.services[s.Name] = []*registry.Service{s}
-			}
-			e.registry.Unlock()
-			continue
-		}
-
-		switch rsp.Action {
-		case "delete":
-			services := delServices(service, []*registry.Service{s})
-			if len(services) > 0 {
-				e.registry.services[s.Name] = services
-			} else {
-				delete(e.registry.services, s.Name)
-			}
-		case "create":
-			e.registry.services[s.Name] = addServices(service, []*registry.Service{s})
-		}
-
-		e.registry.Unlock()
-	}
-}
-
-func (ew *etcdWatcher) Stop() {
-	ew.stop <- true
-}

registry/memory/memory.go

@@ -1,372 +0,0 @@
-package memory
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"sync"
-
-	log "github.com/golang/glog"
-	"github.com/hashicorp/memberlist"
-	"github.com/micro/go-micro/registry"
-	"github.com/pborman/uuid"
-)
-
-type action int
-
-const (
-	addAction action = iota
-	delAction
-	syncAction
-)
-
-type broadcast struct {
-	msg    []byte
-	notify chan<- struct{}
-}
-
-type delegate struct {
-	broadcasts *memberlist.TransmitLimitedQueue
-	updates    chan *update
-}
-
-type memoryRegistry struct {
-	broadcasts *memberlist.TransmitLimitedQueue
-	updates    chan *update
-
-	sync.RWMutex
-	services map[string][]*registry.Service
-}
-
-type update struct {
-	Action  action
-	Service *registry.Service
-	sync    chan *registry.Service
-}
-
-type watcher struct{}
-
-func (b *broadcast) Invalidates(other memberlist.Broadcast) bool {
-	return false
-}
-
-func (b *broadcast) Message() []byte {
-	return b.msg
-}
-
-func (b *broadcast) Finished() {
-	if b.notify != nil {
-		close(b.notify)
-	}
-}
-
-func (d *delegate) NodeMeta(limit int) []byte {
-	return []byte{}
-}
-
-func (d *delegate) NotifyMsg(b []byte) {
-	if len(b) == 0 {
-		return
-	}
-
-	buf := make([]byte, len(b))
-	copy(buf, b)
-
-	go func() {
-		switch buf[0] {
-		case 'd': // data
-			var updates []*update
-			if err := json.Unmarshal(buf[1:], &updates); err != nil {
-				return
-			}
-			for _, u := range updates {
-				d.updates <- u
-			}
-		}
-	}()
-}
-
-func (d *delegate) GetBroadcasts(overhead, limit int) [][]byte {
-	return d.broadcasts.GetBroadcasts(overhead, limit)
-}
-
-func (d *delegate) LocalState(join bool) []byte {
-	if !join {
-		return []byte{}
-	}
-
-	syncCh := make(chan *registry.Service, 1)
-	m := map[string][]*registry.Service{}
-
-	d.updates <- &update{
-		Action: syncAction,
-		sync:   syncCh,
-	}
-
-	for s := range syncCh {
-		m[s.Name] = append(m[s.Name], s)
-	}
-
-	b, _ := json.Marshal(m)
-	return b
-}
-
-func (d *delegate) MergeRemoteState(buf []byte, join bool) {
-	if len(buf) == 0 {
-		return
-	}
-	if !join {
-		return
-	}
-
-	var m map[string][]*registry.Service
-	if err := json.Unmarshal(buf, &m); err != nil {
-		return
-	}
-
-	for _, services := range m {
-		for _, service := range services {
-			d.updates <- &update{
-				Action:  addAction,
-				Service: service,
-				sync:    nil,
-			}
-		}
-	}
-}
-
-func (m *memoryRegistry) run() {
-	for u := range m.updates {
-		switch u.Action {
-		case addAction:
-			m.Lock()
-			if service, ok := m.services[u.Service.Name]; !ok {
-				m.services[u.Service.Name] = []*registry.Service{u.Service}
-			} else {
-				m.services[u.Service.Name] = addServices(service, []*registry.Service{u.Service})
-			}
-			m.Unlock()
-		case delAction:
-			m.Lock()
-			if service, ok := m.services[u.Service.Name]; ok {
-				if services := delServices(service, []*registry.Service{u.Service}); len(services) == 0 {
-					delete(m.services, u.Service.Name)
-				} else {
-					m.services[u.Service.Name] = services
-				}
-			}
-			m.Unlock()
-		case syncAction:
-			if u.sync == nil {
-				continue
-			}
-			m.RLock()
-			for _, services := range m.services {
-				for _, service := range services {
-					u.sync <- service
-				}
-			}
-			m.RUnlock()
-			close(u.sync)
-		}
-	}
-}
-
-func (m *memoryRegistry) Register(s *registry.Service) error {
-	m.Lock()
-	if service, ok := m.services[s.Name]; !ok {
-		m.services[s.Name] = []*registry.Service{s}
-	} else {
-		m.services[s.Name] = addServices(service, []*registry.Service{s})
-	}
-	m.Unlock()
-
-	b, _ := json.Marshal([]*update{
-		&update{
-			Action:  addAction,
-			Service: s,
-		},
-	})
-
-	m.broadcasts.QueueBroadcast(&broadcast{
-		msg:    append([]byte("d"), b...),
-		notify: nil,
-	})
-
-	return nil
-}
-
-func (m *memoryRegistry) Deregister(s *registry.Service) error {
-	m.Lock()
-	if service, ok := m.services[s.Name]; ok {
-		if services := delServices(service, []*registry.Service{s}); len(services) == 0 {
-			delete(m.services, s.Name)
-		} else {
-			m.services[s.Name] = services
-		}
-	}
-	m.Unlock()
-
-	b, _ := json.Marshal([]*update{
-		&update{
-			Action:  delAction,
-			Service: s,
-		},
-	})
-
-	m.broadcasts.QueueBroadcast(&broadcast{
-		msg:    append([]byte("d"), b...),
-		notify: nil,
-	})
-
-	return nil
-}
-
-func (m *memoryRegistry) GetService(name string) ([]*registry.Service, error) {
-	m.RLock()
-	service, ok := m.services[name]
-	m.RUnlock()
-	if !ok {
-		return nil, fmt.Errorf("Service %s not found", name)
-	}
-	return service, nil
-}
-
-func (m *memoryRegistry) ListServices() ([]*registry.Service, error) {
-	var services []*registry.Service
-	m.RLock()
-	for _, service := range m.services {
-		services = append(services, service...)
-	}
-	m.RUnlock()
-	return services, nil
-}
-
-func (m *memoryRegistry) Watch() (registry.Watcher, error) {
-	return &watcher{}, nil
-}
-
-func (w *watcher) Stop() {
-	return
-}
-
-func addNodes(old, neu []*registry.Node) []*registry.Node {
-	for _, n := range neu {
-		var seen bool
-		for i, o := range old {
-			if o.Id == n.Id {
-				seen = true
-				old[i] = n
-				break
-			}
-		}
-		if !seen {
-			old = append(old, n)
-		}
-	}
-	return old
-}
-
-func addServices(old, neu []*registry.Service) []*registry.Service {
-	for _, s := range neu {
-		var seen bool
-		for i, o := range old {
-			if o.Version == s.Version {
-				s.Nodes = addNodes(o.Nodes, s.Nodes)
-				seen = true
-				old[i] = s
-				break
-			}
-		}
-		if !seen {
-			old = append(old, s)
-		}
-	}
-	return old
-}
-
-func delNodes(old, del []*registry.Node) []*registry.Node {
-	var nodes []*registry.Node
-	for _, o := range old {
-		var rem bool
-		for _, n := range del {
-			if o.Id == n.Id {
-				rem = true
-				break
-			}
-		}
-		if !rem {
-			nodes = append(nodes, o)
-		}
-	}
-	return nodes
-}
-
-func delServices(old, del []*registry.Service) []*registry.Service {
-	var services []*registry.Service
-	for i, o := range old {
-		var rem bool
-		for _, s := range del {
-			if o.Version == s.Version {
-				old[i].Nodes = delNodes(o.Nodes, s.Nodes)
-				if len(old[i].Nodes) == 0 {
-					rem = true
-				}
-			}
-		}
-		if !rem {
-			services = append(services, o)
-		}
-	}
-	return services
-}
-
-func NewRegistry(addrs []string, opt ...registry.Option) registry.Registry {
-	cAddrs := []string{}
-	hostname, _ := os.Hostname()
-	updates := make(chan *update, 100)
-
-	for _, addr := range addrs {
-		if len(addr) > 0 {
-			cAddrs = append(cAddrs, addr)
-		}
-	}
-
-	broadcasts := &memberlist.TransmitLimitedQueue{
-		NumNodes: func() int {
-			return len(cAddrs)
-		},
-		RetransmitMult: 3,
-	}
-
-	mr := &memoryRegistry{
-		broadcasts: broadcasts,
-		services:   make(map[string][]*registry.Service),
-		updates:    updates,
-	}
-
-	go mr.run()
-
-	c := memberlist.DefaultLocalConfig()
-	c.BindPort = 0
-	c.Name = hostname + "-" + uuid.NewUUID().String()
-	c.Delegate = &delegate{
-		updates:    updates,
-		broadcasts: broadcasts,
-	}
-
-	m, err := memberlist.Create(c)
-	if err != nil {
-		log.Fatalf("Error creating memberlist: %v", err)
-	}
-
-	if len(cAddrs) > 0 {
-		_, err := m.Join(cAddrs)
-		if err != nil {
-			log.Fatalf("Error joining members: %v", err)
-		}
-	}
-
-	log.Infof("Local memberlist node %s:%d\n", m.LocalNode().Addr, m.LocalNode().Port)
-	return mr
-}

registry/memory/memory_test.go

@@ -1,78 +0,0 @@
-package memory
-
-import (
-	"testing"
-
-	"github.com/micro/go-micro/registry"
-)
-
-func TestDelServices(t *testing.T) {
-	services := []*registry.Service{
-		{
-			Name:    "foo",
-			Version: "1.0.0",
-			Nodes: []*registry.Node{
-				{
-					Id:      "foo-123",
-					Address: "localhost",
-					Port:    9999,
-				},
-			},
-		},
-		{
-			Name:    "foo",
-			Version: "1.0.0",
-			Nodes: []*registry.Node{
-				{
-					Id:      "foo-123",
-					Address: "localhost",
-					Port:    6666,
-				},
-			},
-		},
-	}
-
-	servs := delServices([]*registry.Service{services[0]}, []*registry.Service{services[1]})
-	if i := len(servs); i > 0 {
-		t.Errorf("Expected 0 nodes, got %d: %+v", i, servs)
-	}
-	t.Logf("Services %+v", servs)
-}
-
-func TestDelNodes(t *testing.T) {
-	services := []*registry.Service{
-		{
-			Name:    "foo",
-			Version: "1.0.0",
-			Nodes: []*registry.Node{
-				{
-					Id:      "foo-123",
-					Address: "localhost",
-					Port:    9999,
-				},
-				{
-					Id:      "foo-321",
-					Address: "localhost",
-					Port:    6666,
-				},
-			},
-		},
-		{
-			Name:    "foo",
-			Version: "1.0.0",
-			Nodes: []*registry.Node{
-				{
-					Id:      "foo-123",
-					Address: "localhost",
-					Port:    6666,
-				},
-			},
-		},
-	}
-
-	nodes := delNodes(services[0].Nodes, services[1].Nodes)
-	if i := len(nodes); i != 1 {
-		t.Errorf("Expected only 1 node, got %d: %+v", i, nodes)
-	}
-	t.Logf("Nodes %+v", nodes)
-}