Move out consul sync/lock and store. Move data/store to store

sync/lock/consul/consul.go

@@ -1,104 +0,0 @@
-// Package consul is a consul implemenation of lock
-package consul
-
-import (
-	"errors"
-	"fmt"
-	"net"
-	"sync"
-	"time"
-
-	"github.com/hashicorp/consul/api"
-	lock "github.com/micro/go-micro/sync/lock"
-)
-
-type consulLock struct {
-	sync.Mutex
-
-	locks map[string]*api.Lock
-	opts  lock.Options
-	c     *api.Client
-}
-
-func (c *consulLock) Acquire(id string, opts ...lock.AcquireOption) error {
-	var options lock.AcquireOptions
-	for _, o := range opts {
-		o(&options)
-	}
-
-	if options.Wait <= time.Duration(0) {
-		options.Wait = api.DefaultLockWaitTime
-	}
-
-	ttl := fmt.Sprintf("%v", options.TTL)
-	if options.TTL <= time.Duration(0) {
-		ttl = api.DefaultLockSessionTTL
-	}
-
-	l, err := c.c.LockOpts(&api.LockOptions{
-		Key:          c.opts.Prefix + id,
-		LockWaitTime: options.Wait,
-		SessionTTL:   ttl,
-	})
-
-	if err != nil {
-		return err
-	}
-
-	_, err = l.Lock(nil)
-	if err != nil {
-		return err
-	}
-
-	c.Lock()
-	c.locks[id] = l
-	c.Unlock()
-
-	return nil
-}
-
-func (c *consulLock) Release(id string) error {
-	c.Lock()
-	defer c.Unlock()
-	l, ok := c.locks[id]
-	if !ok {
-		return errors.New("lock not found")
-	}
-	err := l.Unlock()
-	delete(c.locks, id)
-	return err
-}
-
-func (c *consulLock) String() string {
-	return "consul"
-}
-
-func NewLock(opts ...lock.Option) lock.Lock {
-	var options lock.Options
-	for _, o := range opts {
-		o(&options)
-	}
-
-	config := api.DefaultConfig()
-
-	// set host
-	// config.Host something
-	// check if there are any addrs
-	if len(options.Nodes) > 0 {
-		addr, port, err := net.SplitHostPort(options.Nodes[0])
-		if ae, ok := err.(*net.AddrError); ok && ae.Err == "missing port in address" {
-			port = "8500"
-			config.Address = fmt.Sprintf("%s:%s", options.Nodes[0], port)
-		} else if err == nil {
-			config.Address = fmt.Sprintf("%s:%s", addr, port)
-		}
-	}
-
-	client, _ := api.NewClient(config)
-
-	return &consulLock{
-		locks: make(map[string]*api.Lock),
-		opts:  options,
-		c:     client,
-	}
-}

sync/lock/etcd/etcd.go

@@ -0,0 +1,115 @@
+// Package etcd is an etcd implementation of lock
+package etcd
+
+import (
+	"context"
+	"errors"
+	"log"
+	"path"
+	"strings"
+	"sync"
+
+	client "github.com/coreos/etcd/clientv3"
+	cc "github.com/coreos/etcd/clientv3/concurrency"
+	"github.com/micro/go-micro/sync/lock"
+)
+
+type etcdLock struct {
+	opts   lock.Options
+	path   string
+	client *client.Client
+
+	sync.Mutex
+	locks map[string]*elock
+}
+
+type elock struct {
+	s *cc.Session
+	m *cc.Mutex
+}
+
+func (e *etcdLock) Acquire(id string, opts ...lock.AcquireOption) error {
+	var options lock.AcquireOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// make path
+	path := path.Join(e.path, strings.Replace(e.opts.Prefix+id, "/", "-", -1))
+
+	var sopts []cc.SessionOption
+	if options.TTL > 0 {
+		sopts = append(sopts, cc.WithTTL(int(options.TTL.Seconds())))
+	}
+
+	s, err := cc.NewSession(e.client, sopts...)
+	if err != nil {
+		return err
+	}
+
+	m := cc.NewMutex(s, path)
+
+	ctx, _ := context.WithCancel(context.Background())
+
+	if err := m.Lock(ctx); err != nil {
+		return err
+	}
+
+	e.Lock()
+	e.locks[id] = &elock{
+		s: s,
+		m: m,
+	}
+	e.Unlock()
+	return nil
+}
+
+func (e *etcdLock) Release(id string) error {
+	e.Lock()
+	defer e.Unlock()
+	v, ok := e.locks[id]
+	if !ok {
+		return errors.New("lock not found")
+	}
+	err := v.m.Unlock(context.Background())
+	delete(e.locks, id)
+	return err
+}
+
+func (e *etcdLock) String() string {
+	return "etcd"
+}
+
+func NewLock(opts ...lock.Option) lock.Lock {
+	var options lock.Options
+	for _, o := range opts {
+		o(&options)
+	}
+
+	var endpoints []string
+
+	for _, addr := range options.Nodes {
+		if len(addr) > 0 {
+			endpoints = append(endpoints, addr)
+		}
+	}
+
+	if len(endpoints) == 0 {
+		endpoints = []string{"http://127.0.0.1:2379"}
+	}
+
+	// TODO: parse addresses
+	c, err := client.New(client.Config{
+		Endpoints: endpoints,
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return &etcdLock{
+		path:   "/micro/lock",
+		client: c,
+		opts:   options,
+		locks:  make(map[string]*elock),
+	}
+}