@@ -20,12 +20,12 @@ clone git github.com/tchap/go-patricia v2.1.0

 clone git golang.org/x/net 3cffabab72adf04f8e3b01c5baf775361837b5fe https://github.com/golang/net.git

 #get libnetwork packages

-clone git github.com/docker/libnetwork c3a9e0d8d0c53f3db251620e5f48470e267f292b

+clone git github.com/docker/libnetwork 0521fe53fc3e7d4e7c2e463800f36662c9169f20

 clone git github.com/armon/go-metrics eb0af217e5e9747e41dd5303755356b62d28e3ec

 clone git github.com/hashicorp/go-msgpack 71c2886f5a673a35f909803f38ece5810165097b

 clone git github.com/hashicorp/memberlist 9a1e242e454d2443df330bdd51a436d5a9058fc4

 clone git github.com/hashicorp/serf 7151adcef72687bf95f451a2e0ba15cb19412bf2

-clone git github.com/docker/libkv ea7ff6ae76485ab93ac36799d3e13b1905787ffe

+clone git github.com/docker/libkv 958cd316db2bc916466bdcc632a3188d62ce6e87

 clone git github.com/vishvananda/netns 604eaf189ee867d8c147fafc28def2394e878d25

 clone git github.com/vishvananda/netlink 4b5dce31de6d42af5bb9811c6d265472199e0fec

 clone git github.com/BurntSushi/toml f706d00e3de6abe700c994cdd545a1a4915af060

@@ -68,9 +68,16 @@ func main() {

 You can find other usage examples for `libkv` under the `docker/swarm` or `docker/libnetwork` repositories.

+## Supported versions

+

+`libkv` supports:

+- Consul version >= `0.5.1` because it uses Sessions with `Delete` behavior for the use of `TTLs` (mimics zookeeper's Ephemeral node support), If you don't plan to use `TTLs`: you can use Consul version `0.4.0+`.

+- Etcd version >= `2.0` because it uses the `2.0.0` branch of the `coreos/go-etcd` client, this might change in the future as the support for `APIv3` comes along.

+- Zookeeper version >= `3.4.5`. Although this might work with previous version but this remains untested as of now.

+

 ## TLS

-The etcd backend supports etcd servers that require TLS Client Authentication.  Zookeeper and Consul support are planned.  This feature is somewhat experimental and the store.ClientTLSConfig struct may change to accommodate the additional backends.

+The etcd backend supports etcd servers that require TLS Client Authentication. Zookeeper and Consul support are planned. This feature is somewhat experimental and the store.ClientTLSConfig struct may change to accommodate the additional backends.

 ## Warning

@@ -6,7 +6,9 @@ import (

 	"errors"

 	"os"

 	"path/filepath"

+	"sync"

 	"sync/atomic"

+	"time"

 	"github.com/boltdb/bolt"

 	"github.com/docker/libkv"

@@ -25,15 +27,29 @@ var (

 	ErrBoltAPIUnsupported = errors.New("API not supported by BoltDB backend")

 )

+const (

+	filePerm os.FileMode = 0644

+)

+

 //BoltDB type implements the Store interface

 type BoltDB struct {

 	client     *bolt.DB

 	boltBucket []byte

 	dbIndex    uint64

+	path       string

+	timeout    time.Duration

+	// By default libkv opens and closes the bolt DB connection  for every

+	// get/put operation. This allows multiple apps to use a Bolt DB at the

+	// same time.

+	// PersistConnection flag provides an option to override ths behavior.

+	// ie: open the connection in New and use it till Close is called.

+	PersistConnection bool

+	sync.Mutex

 }

 const (

 	libkvmetadatalen = 8

+	transientTimeout = time.Duration(10) * time.Second

 )

 // Register registers boltdb to libkv

@@ -43,6 +59,12 @@ func Register() {

 // New opens a new BoltDB connection to the specified path and bucket

 func New(endpoints []string, options *store.Config) (store.Store, error) {

+	var (

+		db          *bolt.DB

+		err         error

+		boltOptions *bolt.Options

+	)

+

 	if len(endpoints) > 1 {

 		return nil, ErrMultipleEndpointsUnsupported

 	}

@@ -52,39 +74,81 @@ func New(endpoints []string, options *store.Config) (store.Store, error) {

 	}

 	dir, _ := filepath.Split(endpoints[0])

-	if err := os.MkdirAll(dir, 0750); err != nil {

+	if err = os.MkdirAll(dir, 0750); err != nil {

 		return nil, err

 	}

-	var boltOptions *bolt.Options

-	if options != nil {

+	if options.PersistConnection {

 		boltOptions = &bolt.Options{Timeout: options.ConnectionTimeout}

-	}

-	db, err := bolt.Open(endpoints[0], 0644, boltOptions)

-	if err != nil {

-		return nil, err

+		db, err = bolt.Open(endpoints[0], filePerm, boltOptions)

+		if err != nil {

+			return nil, err

+		}

 	}

-	b := &BoltDB{}

+	b := &BoltDB{

+		client:            db,

+		path:              endpoints[0],

+		boltBucket:        []byte(options.Bucket),

+		timeout:           transientTimeout,

+		PersistConnection: options.PersistConnection,

+	}

-	b.client = db

-	b.boltBucket = []byte(options.Bucket)

 	return b, nil

 }

+func (b *BoltDB) reset() {

+	b.path = ""

+	b.boltBucket = []byte{}

+}

+

+func (b *BoltDB) getDBhandle() (*bolt.DB, error) {

+	var (

+		db  *bolt.DB

+		err error

+	)

+	if !b.PersistConnection {

+		boltOptions := &bolt.Options{Timeout: b.timeout}

+		if db, err = bolt.Open(b.path, filePerm, boltOptions); err != nil {

+			return nil, err

+		}

+		b.client = db

+	}

+

+	return b.client, nil

+}

+

+func (b *BoltDB) releaseDBhandle() {

+	if !b.PersistConnection {

+		b.client.Close()

+	}

+}

+

 // Get the value at "key". BoltDB doesn't provide an inbuilt last modified index with every kv pair. Its implemented by

 // by a atomic counter maintained by the libkv and appened to the value passed by the client.

 func (b *BoltDB) Get(key string) (*store.KVPair, error) {

-	var val []byte

+	var (

+		val []byte

+		db  *bolt.DB

+		err error

+	)

+	b.Lock()

+	defer b.Unlock()

+

+	if db, err = b.getDBhandle(); err != nil {

+		return nil, err

+	}

+	defer b.releaseDBhandle()

-	db := b.client

-	err := db.View(func(tx *bolt.Tx) error {

+	err = db.View(func(tx *bolt.Tx) error {

 		bucket := tx.Bucket(b.boltBucket)

 		if bucket == nil {

-			return (ErrBoltBucketNotFound)

+			return ErrBoltBucketNotFound

 		}

-		val = bucket.Get([]byte(key))

+		v := bucket.Get([]byte(key))

+		val = make([]byte, len(v))

+		copy(val, v)

 		return nil

 	})

@@ -104,11 +168,22 @@ func (b *BoltDB) Get(key string) (*store.KVPair, error) {

 //Put the key, value pair. index number metadata is prepended to the value

 func (b *BoltDB) Put(key string, value []byte, opts *store.WriteOptions) error {

-	var dbIndex uint64

-	db := b.client

+	var (

+		dbIndex uint64

+		db      *bolt.DB

+		err     error

+	)

+	b.Lock()

+	defer b.Unlock()

+

 	dbval := make([]byte, libkvmetadatalen)

-	err := db.Update(func(tx *bolt.Tx) error {

+	if db, err = b.getDBhandle(); err != nil {

+		return err

+	}

+	defer b.releaseDBhandle()

+

+	err = db.Update(func(tx *bolt.Tx) error {

 		bucket, err := tx.CreateBucketIfNotExists(b.boltBucket)

 		if err != nil {

 			return err

@@ -129,12 +204,22 @@ func (b *BoltDB) Put(key string, value []byte, opts *store.WriteOptions) error {

 //Delete the value for the given key.

 func (b *BoltDB) Delete(key string) error {

-	db := b.client

+	var (

+		db  *bolt.DB

+		err error

+	)

+	b.Lock()

+	defer b.Unlock()

+

+	if db, err = b.getDBhandle(); err != nil {

+		return err

+	}

+	defer b.releaseDBhandle()

-	err := db.Update(func(tx *bolt.Tx) error {

+	err = db.Update(func(tx *bolt.Tx) error {

 		bucket := tx.Bucket(b.boltBucket)

 		if bucket == nil {

-			return (ErrBoltBucketNotFound)

+			return ErrBoltBucketNotFound

 		}

 		err := bucket.Delete([]byte(key))

 		return err

@@ -144,13 +229,23 @@ func (b *BoltDB) Delete(key string) error {

 // Exists checks if the key exists inside the store

 func (b *BoltDB) Exists(key string) (bool, error) {

-	var val []byte

+	var (

+		val []byte

+		db  *bolt.DB

+		err error

+	)

+	b.Lock()

+	defer b.Unlock()

+

+	if db, err = b.getDBhandle(); err != nil {

+		return false, err

+	}

+	defer b.releaseDBhandle()

-	db := b.client

-	err := db.View(func(tx *bolt.Tx) error {

+	err = db.View(func(tx *bolt.Tx) error {

 		bucket := tx.Bucket(b.boltBucket)

 		if bucket == nil {

-			return (ErrBoltBucketNotFound)

+			return ErrBoltBucketNotFound

 		}

 		val = bucket.Get([]byte(key))

@@ -166,22 +261,35 @@ func (b *BoltDB) Exists(key string) (bool, error) {

 // List returns the range of keys starting with the passed in prefix

 func (b *BoltDB) List(keyPrefix string) ([]*store.KVPair, error) {

+	var (

+		db  *bolt.DB

+		err error

+	)

+	b.Lock()

+	defer b.Unlock()

+

 	kv := []*store.KVPair{}

-	db := b.client

-	err := db.View(func(tx *bolt.Tx) error {

+	if db, err = b.getDBhandle(); err != nil {

+		return nil, err

+	}

+	defer b.releaseDBhandle()

+

+	err = db.View(func(tx *bolt.Tx) error {

 		bucket := tx.Bucket(b.boltBucket)

 		if bucket == nil {

-			return (ErrBoltBucketNotFound)

+			return ErrBoltBucketNotFound

 		}

 		cursor := bucket.Cursor()

 		prefix := []byte(keyPrefix)

-		for key, val := cursor.Seek(prefix); bytes.HasPrefix(key, prefix); key, val = cursor.Next() {

+		for key, v := cursor.Seek(prefix); bytes.HasPrefix(key, prefix); key, v = cursor.Next() {

-			dbIndex := binary.LittleEndian.Uint64(val[:libkvmetadatalen])

-			val = val[libkvmetadatalen:]

+			dbIndex := binary.LittleEndian.Uint64(v[:libkvmetadatalen])

+			v = v[libkvmetadatalen:]

+			val := make([]byte, len(v))

+			copy(val, v)

 			kv = append(kv, &store.KVPair{

 				Key:       string(key),

@@ -201,22 +309,30 @@ func (b *BoltDB) List(keyPrefix string) ([]*store.KVPair, error) {

 // has not been modified in the meantime, throws an

 // error if this is the case

 func (b *BoltDB) AtomicDelete(key string, previous *store.KVPair) (bool, error) {

-	var val []byte

-	var dbIndex uint64

+	var (

+		val []byte

+		db  *bolt.DB

+		err error

+	)

+	b.Lock()

+	defer b.Unlock()

 	if previous == nil {

 		return false, store.ErrPreviousNotSpecified

 	}

-	db := b.client

+	if db, err = b.getDBhandle(); err != nil {

+		return false, err

+	}

+	defer b.releaseDBhandle()

-	err := db.Update(func(tx *bolt.Tx) error {

+	err = db.Update(func(tx *bolt.Tx) error {

 		bucket := tx.Bucket(b.boltBucket)

 		if bucket == nil {

 			return ErrBoltBucketNotFound

 		}

 		val = bucket.Get([]byte(key))

-		dbIndex = binary.LittleEndian.Uint64(val[:libkvmetadatalen])

+		dbIndex := binary.LittleEndian.Uint64(val[:libkvmetadatalen])

 		if dbIndex != previous.LastIndex {

 			return store.ErrKeyModified

 		}

@@ -232,13 +348,23 @@ func (b *BoltDB) AtomicDelete(key string, previous *store.KVPair) (bool, error)

 // AtomicPut puts a value at "key" if the key has not been

 // modified since the last Put, throws an error if this is the case

 func (b *BoltDB) AtomicPut(key string, value []byte, previous *store.KVPair, options *store.WriteOptions) (bool, *store.KVPair, error) {

-	var val []byte

-	var dbIndex uint64

+	var (

+		val     []byte

+		dbIndex uint64

+		db      *bolt.DB

+		err     error

+	)

+	b.Lock()

+	defer b.Unlock()

+

 	dbval := make([]byte, libkvmetadatalen)

-	db := b.client

+	if db, err = b.getDBhandle(); err != nil {

+		return false, nil, err

+	}

+	defer b.releaseDBhandle()

-	err := db.Update(func(tx *bolt.Tx) error {

+	err = db.Update(func(tx *bolt.Tx) error {

 		var err error

 		bucket := tx.Bucket(b.boltBucket)

 		if bucket == nil {

@@ -285,18 +411,35 @@ func (b *BoltDB) AtomicPut(key string, value []byte, previous *store.KVPair, opt

 // Close the db connection to the BoltDB

 func (b *BoltDB) Close() {

-	db := b.client

+	b.Lock()

+	defer b.Unlock()

-	db.Close()

+	if !b.PersistConnection {

+		b.reset()

+	} else {

+		b.client.Close()

+	}

+	return

 }

 // DeleteTree deletes a range of keys with a given prefix

 func (b *BoltDB) DeleteTree(keyPrefix string) error {

-	db := b.client

-	err := db.Update(func(tx *bolt.Tx) error {

+	var (

+		db  *bolt.DB

+		err error

+	)

+	b.Lock()

+	defer b.Unlock()

+

+	if db, err = b.getDBhandle(); err != nil {

+		return err

+	}

+	defer b.releaseDBhandle()

+

+	err = db.Update(func(tx *bolt.Tx) error {

 		bucket := tx.Bucket(b.boltBucket)

 		if bucket == nil {

-			return (ErrBoltBucketNotFound)

+			return ErrBoltBucketNotFound

 		}

 		cursor := bucket.Cursor()

@@ -35,7 +35,8 @@ type Consul struct {

 }

 type consulLock struct {

-	lock *api.Lock

+	lock    *api.Lock

+	renewCh chan struct{}

 }

 // Register registers consul to libkv

@@ -87,7 +88,7 @@ func (s *Consul) setTLS(tls *tls.Config) {

 	s.config.Scheme = "https"

 }

-// SetTimeout sets the timout for connecting to Consul

+// SetTimeout sets the timeout for connecting to Consul

 func (s *Consul) setTimeout(time time.Duration) {

 	s.config.WaitTime = time

 }

@@ -360,32 +361,63 @@ func (s *Consul) WatchTree(directory string, stopCh <-chan struct{}) (<-chan []*

 // NewLock returns a handle to a lock struct which can

 // be used to provide mutual exclusion on a key

 func (s *Consul) NewLock(key string, options *store.LockOptions) (store.Locker, error) {

-	consulOpts := &api.LockOptions{

+	lockOpts := &api.LockOptions{

 		Key: s.normalize(key),

 	}

+	lock := &consulLock{}

+

 	if options != nil {

-		consulOpts.Value = options.Value

+		// Set optional TTL on Lock

+		if options.TTL != 0 {

+			entry := &api.SessionEntry{

+				Behavior:  api.SessionBehaviorRelease, // Release the lock when the session expires

+				TTL:       (options.TTL / 2).String(), // Consul multiplies the TTL by 2x

+				LockDelay: 1 * time.Millisecond,       // Virtually disable lock delay

+			}

+

+			// Create the key session

+			session, _, err := s.client.Session().Create(entry, nil)

+			if err != nil {

+				return nil, err

+			}

+

+			// Place the session on lock

+			lockOpts.Session = session

+

+			// Renew the session ttl lock periodically

+			go s.client.Session().RenewPeriodic(entry.TTL, session, nil, options.RenewLock)

+			lock.renewCh = options.RenewLock

+		}

+

+		// Set optional value on Lock

+		if options.Value != nil {

+			lockOpts.Value = options.Value

+		}

 	}

-	l, err := s.client.LockOpts(consulOpts)

+	l, err := s.client.LockOpts(lockOpts)

 	if err != nil {

 		return nil, err

 	}

-	return &consulLock{lock: l}, nil

+	lock.lock = l

+	return lock, nil

 }

 // Lock attempts to acquire the lock and blocks while

 // doing so. It returns a channel that is closed if our

 // lock is lost or if an error occurs

-func (l *consulLock) Lock() (<-chan struct{}, error) {

-	return l.lock.Lock(nil)

+func (l *consulLock) Lock(stopChan chan struct{}) (<-chan struct{}, error) {

+	return l.lock.Lock(stopChan)

 }

 // Unlock the "key". Calling unlock while

 // not holding the lock will throw an error

 func (l *consulLock) Unlock() error {

+	if l.renewCh != nil {

+		close(l.renewCh)

+	}

 	return l.lock.Unlock()

 }

@@ -2,6 +2,7 @@ package etcd

 import (

 	"crypto/tls"

+	"errors"

 	"net"

 	"net/http"

 	"strings"

@@ -12,6 +13,13 @@ import (

 	"github.com/docker/libkv/store"

 )

+var (

+	// ErrAbortTryLock is thrown when a user stops trying to seek the lock

+	// by sending a signal to the stop chan, this is used to verify if the

+	// operation succeeded

+	ErrAbortTryLock = errors.New("lock operation aborted")

+)

+

 // Etcd is the receiver type for the

 // Store interface

 type Etcd struct {

@@ -19,12 +27,13 @@ type Etcd struct {

 }

 type etcdLock struct {

-	client   *etcd.Client

-	stopLock chan struct{}

-	key      string

-	value    string

-	last     *etcd.Response

-	ttl      uint64

+	client    *etcd.Client

+	stopLock  chan struct{}

+	stopRenew chan struct{}

+	key       string

+	value     string

+	last      *etcd.Response

+	ttl       uint64

 }

 const (

@@ -395,6 +404,7 @@ func (s *Etcd) DeleteTree(directory string) error {

 func (s *Etcd) NewLock(key string, options *store.LockOptions) (lock store.Locker, err error) {

 	var value string

 	ttl := uint64(time.Duration(defaultLockTTL).Seconds())

+	renewCh := make(chan struct{})

 	// Apply options on Lock

 	if options != nil {

@@ -404,14 +414,18 @@ func (s *Etcd) NewLock(key string, options *store.LockOptions) (lock store.Locke

 		if options.TTL != 0 {

 			ttl = uint64(options.TTL.Seconds())

 		}

+		if options.RenewLock != nil {

+			renewCh = options.RenewLock

+		}

 	}

 	// Create lock object

 	lock = &etcdLock{

-		client: s.client,

-		key:    key,

-		value:  value,

-		ttl:    ttl,

+		client:    s.client,

+		stopRenew: renewCh,

+		key:       key,

+		value:     value,

+		ttl:       ttl,

 	}

 	return lock, nil

@@ -420,13 +434,13 @@ func (s *Etcd) NewLock(key string, options *store.LockOptions) (lock store.Locke

 // Lock attempts to acquire the lock and blocks while

 // doing so. It returns a channel that is closed if our

 // lock is lost or if an error occurs

-func (l *etcdLock) Lock() (<-chan struct{}, error) {

+func (l *etcdLock) Lock(stopChan chan struct{}) (<-chan struct{}, error) {

 	key := store.Normalize(l.key)

-	// Lock holder channels

+	// Lock holder channel

 	lockHeld := make(chan struct{})

-	stopLocking := make(chan struct{})

+	stopLocking := l.stopRenew

 	var lastIndex uint64

@@ -454,7 +468,18 @@ func (l *etcdLock) Lock() (<-chan struct{}, error) {

 			// Seeker section

 			chW := make(chan *etcd.Response)

 			chWStop := make(chan bool)

-			l.waitLock(key, chW, chWStop)

+			free := make(chan bool)

+

+			go l.waitLock(key, chW, chWStop, free)

+

+			// Wait for the key to be available or for

+			// a signal to stop trying to lock the key

+			select {

+			case _ = <-free:

+				break

+			case _ = <-stopChan:

+				return nil, ErrAbortTryLock

+			}

 			// Delete or Expire event occured

 			// Retry

@@ -467,10 +492,10 @@ func (l *etcdLock) Lock() (<-chan struct{}, error) {

 // Hold the lock as long as we can

 // Updates the key ttl periodically until we receive

 // an explicit stop signal from the Unlock method

-func (l *etcdLock) holdLock(key string, lockHeld chan struct{}, stopLocking chan struct{}) {

+func (l *etcdLock) holdLock(key string, lockHeld chan struct{}, stopLocking <-chan struct{}) {

 	defer close(lockHeld)

-	update := time.NewTicker(defaultUpdateTime)

+	update := time.NewTicker(time.Duration(l.ttl) * time.Second / 3)

 	defer update.Stop()

 	var err error

@@ -490,11 +515,12 @@ func (l *etcdLock) holdLock(key string, lockHeld chan struct{}, stopLocking chan

 }

 // WaitLock simply waits for the key to be available for creation

-func (l *etcdLock) waitLock(key string, eventCh chan *etcd.Response, stopWatchCh chan bool) {

+func (l *etcdLock) waitLock(key string, eventCh chan *etcd.Response, stopWatchCh chan bool, free chan<- bool) {

 	go l.client.Watch(key, 0, false, eventCh, stopWatchCh)

+

 	for event := range eventCh {

 		if event.Action == "delete" || event.Action == "expire" {

-			return

+			free <- true

 		}

 	}

 }

@@ -43,6 +43,7 @@ type Config struct {

 	TLS               *tls.Config

 	ConnectionTimeout time.Duration

 	Bucket            string

+	PersistConnection bool

 }

 // ClientTLSConfig contains data for a Client TLS configuration in the form

@@ -113,13 +114,14 @@ type WriteOptions struct {

 // LockOptions contains optional request parameters

 type LockOptions struct {

-	Value []byte        // Optional, value to associate with the lock

-	TTL   time.Duration // Optional, expiration ttl associated with the lock

+	Value     []byte        // Optional, value to associate with the lock

+	TTL       time.Duration // Optional, expiration ttl associated with the lock

+	RenewLock chan struct{} // Optional, chan used to control and stop the session ttl renewal for the lock

 }

 // Locker provides locking mechanism on top of the store.

 // Similar to `sync.Lock` except it may return errors.

 type Locker interface {

-	Lock() (<-chan struct{}, error)

+	Lock(stopChan chan struct{}) (<-chan struct{}, error)

 	Unlock() error

 }

@@ -10,6 +10,9 @@ import (

 )

 const (

+	// SOH control character

+	SOH = "\x01"

+

 	defaultTimeout = 10 * time.Second

 )

@@ -72,6 +75,12 @@ func (s *Zookeeper) Get(key string) (pair *store.KVPair, err error) {

 		return nil, err

 	}

+	// FIXME handle very rare cases where Get returns the

+	// SOH control character instead of the actual value

+	if string(resp) == SOH {

+		return s.Get(store.Normalize(key))

+	}

+

 	pair = &store.KVPair{

 		Key:       key,

 		Value:     resp,

@@ -301,7 +310,7 @@ func (s *Zookeeper) AtomicPut(key string, value []byte, previous *store.KVPair,

 			// Zookeeper will complain if the directory doesn't exist.

 			if err == zk.ErrNoNode {

 				// Create the directory

-				parts := store.SplitKey(key)

+				parts := store.SplitKey(strings.TrimSuffix(key, "/"))

 				parts = parts[:len(parts)-1]

 				if err = s.createFullPath(parts, false); err != nil {

 					// Failed to create the directory.

@@ -371,7 +380,7 @@ func (s *Zookeeper) NewLock(key string, options *store.LockOptions) (lock store.

 // Lock attempts to acquire the lock and blocks while

 // doing so. It returns a channel that is closed if our

 // lock is lost or if an error occurs

-func (l *zookeeperLock) Lock() (<-chan struct{}, error) {

+func (l *zookeeperLock) Lock(stopChan chan struct{}) (<-chan struct{}, error) {

 	err := l.lock.Lock()

 	if err == nil {

@@ -29,7 +29,8 @@ cmd/dnet/dnet

 *.tmp

 *.coverprofile

-# IDE files

+# IDE files and folders

 .project

+.settings/

 libnetwork-build.created

@@ -5,6 +5,7 @@ package bitseq

 import (

 	"encoding/binary"

+	"encoding/json"

 	"fmt"

 	"sync"

@@ -16,10 +17,10 @@ import (

 // If needed we can think of making these configurable

 const (

 	blockLen      = uint32(32)

-	blockBytes    = blockLen / 8

+	blockBytes    = uint64(blockLen / 8)

 	blockMAX      = uint32(1<<blockLen - 1)

 	blockFirstBit = uint32(1) << (blockLen - 1)

-	invalidPos    = blockMAX

+	invalidPos    = uint64(0xFFFFFFFFFFFFFFFF)

 )

 var (

@@ -28,8 +29,8 @@ var (

 // Handle contains the sequece representing the bitmask and its identifier

 type Handle struct {

-	bits       uint32

-	unselected uint32

+	bits       uint64

+	unselected uint64

 	head       *sequence

 	app        string

 	id         string

@@ -40,7 +41,7 @@ type Handle struct {

 }

 // NewHandle returns a thread-safe instance of the bitmask handler

-func NewHandle(app string, ds datastore.DataStore, id string, numElements uint32) (*Handle, error) {

+func NewHandle(app string, ds datastore.DataStore, id string, numElements uint64) (*Handle, error) {

 	h := &Handle{

 		app:        app,

 		id:         id,

@@ -57,21 +58,25 @@ func NewHandle(app string, ds datastore.DataStore, id string, numElements uint32

 		return h, nil

 	}

-	// Register for status changes

-	h.watchForChanges()

-

 	// Get the initial status from the ds if present.

 	if err := h.store.GetObject(datastore.Key(h.Key()...), h); err != nil && err != datastore.ErrKeyNotFound {

 		return nil, err

 	}

+	// If the handle is not in store, write it.

+	if !h.Exists() {

+		if err := h.writeToStore(); err != nil {

+			return nil, fmt.Errorf("failed to write bitsequence to store: %v", err)

+		}

+	}

+

 	return h, nil

 }

 // sequence represents a recurring sequence of 32 bits long bitmasks

 type sequence struct {

 	block uint32    // block is a symbol representing 4 byte long allocation bitmask

-	count uint32    // number of consecutive blocks (symbols)

+	count uint64    // number of consecutive blocks (symbols)

 	next  *sequence // next sequence

 }

@@ -87,7 +92,7 @@ func (s *sequence) toString() string {

 }

 // GetAvailableBit returns the position of the first unset bit in the bitmask represented by this sequence

-func (s *sequence) getAvailableBit(from uint32) (uint32, uint32, error) {

+func (s *sequence) getAvailableBit(from uint64) (uint64, uint64, error) {

 	if s.block == blockMAX || s.count == 0 {

 		return invalidPos, invalidPos, errNoBitAvailable

 	}

@@ -140,9 +145,9 @@ func (s *sequence) toByteArray() ([]byte, error) {

 	p := s

 	for p != nil {

-		b := make([]byte, 8)

+		b := make([]byte, 12)

 		binary.BigEndian.PutUint32(b[0:], p.block)

-		binary.BigEndian.PutUint32(b[4:], p.count)

+		binary.BigEndian.PutUint64(b[4:], p.count)

 		bb = append(bb, b...)

 		p = p.next

 	}

@@ -153,7 +158,7 @@ func (s *sequence) toByteArray() ([]byte, error) {

 // fromByteArray construct the sequence from the byte array

 func (s *sequence) fromByteArray(data []byte) error {

 	l := len(data)

-	if l%8 != 0 {

+	if l%12 != 0 {

 		return fmt.Errorf("cannot deserialize byte sequence of lenght %d (%v)", l, data)

 	}

@@ -161,8 +166,8 @@ func (s *sequence) fromByteArray(data []byte) error {

 	i := 0

 	for {

 		p.block = binary.BigEndian.Uint32(data[i : i+4])

-		p.count = binary.BigEndian.Uint32(data[i+4 : i+8])

-		i += 8

+		p.count = binary.BigEndian.Uint64(data[i+4 : i+12])

+		i += 12

 		if i == l {

 			break

 		}

@@ -187,7 +192,7 @@ func (h *Handle) getCopy() *Handle {

 }

 // SetAnyInRange atomically sets the first unset bit in the specified range in the sequence and returns the corresponding ordinal

-func (h *Handle) SetAnyInRange(start, end uint32) (uint32, error) {

+func (h *Handle) SetAnyInRange(start, end uint64) (uint64, error) {

 	if end-start <= 0 || end >= h.bits {

 		return invalidPos, fmt.Errorf("invalid bit range [%d, %d]", start, end)

 	}

@@ -198,7 +203,7 @@ func (h *Handle) SetAnyInRange(start, end uint32) (uint32, error) {

 }

 // SetAny atomically sets the first unset bit in the sequence and returns the corresponding ordinal

-func (h *Handle) SetAny() (uint32, error) {

+func (h *Handle) SetAny() (uint64, error) {

 	if h.Unselected() == 0 {

 		return invalidPos, errNoBitAvailable

 	}

@@ -206,7 +211,7 @@ func (h *Handle) SetAny() (uint32, error) {

 }

 // Set atomically sets the corresponding bit in the sequence

-func (h *Handle) Set(ordinal uint32) error {

+func (h *Handle) Set(ordinal uint64) error {

 	if err := h.validateOrdinal(ordinal); err != nil {

 		return err

 	}

@@ -215,7 +220,7 @@ func (h *Handle) Set(ordinal uint32) error {

 }

 // Unset atomically unsets the corresponding bit in the sequence

-func (h *Handle) Unset(ordinal uint32) error {

+func (h *Handle) Unset(ordinal uint64) error {

 	if err := h.validateOrdinal(ordinal); err != nil {

 		return err