@@ -114,7 +114,7 @@ type ScopeClientCfg struct {

 const (

 	// LocalScope indicates to store the KV object in local datastore such as boltdb

 	LocalScope = "local"

-	// GlobalScope indicates to store the KV object in global datastore such as consul/etcd/zookeeper

+	// GlobalScope indicates to store the KV object in global datastore such as consul/etcd

 	GlobalScope = "global"

 	// SwarmScope is not indicating a datastore location. It is defined here

 	// along with the other two scopes just for consistency.

@@ -27,7 +27,7 @@ Docker version 1.8.0-dev, build f39b9a0, experimental

 Multi-host networking uses a pluggable Key-Value store backend to distribute states using `libkv`.

-`libkv` supports multiple pluggable backends such as `consul`, `etcd` & `zookeeper` (more to come).

+`libkv` supports multiple pluggable backends such as `consul`, `etcd` (more to come).

 In this example we will use `consul`

@@ -8,13 +8,11 @@ import (

 	"github.com/docker/libkv/store/boltdb"

 	"github.com/docker/libkv/store/consul"

 	"github.com/docker/libkv/store/etcd"

-	"github.com/docker/libkv/store/zookeeper"

 	"github.com/sirupsen/logrus"

 )

 func registerKVStores() {

 	consul.Register()

-	zookeeper.Register()

 	etcd.Register()

 	boltdb.Register()

 }

@@ -149,9 +149,7 @@ function start_dnet() {

     # Try discovery URLs with or without path

     neigh_ip=""

     neighbors=""

-    if [ "$store" = "zookeeper" ]; then

-	read discovery provider address < <(parse_discovery_str zk://${bridge_ip}:2182)

-    elif [ "$store" = "etcd" ]; then

+    if [ "$store" = "etcd" ]; then

 	read discovery provider address < <(parse_discovery_str etcd://${bridge_ip}:42000/custom_prefix)

     elif [ "$store" = "consul" ]; then

 	read discovery provider address < <(parse_discovery_str consul://${bridge_ip}:8500/custom_prefix)

@@ -288,21 +286,6 @@ function stop_etcd() {

     docker rm -f dn_etcd || true

 }

-function start_zookeeper() {

-    stop_zookeeper

-    docker run -d \

-	   --name=zookeeper_server \

-	   -p 2182:2181 \

-	   -h zookeeper \

-	   dnephin/docker-zookeeper:3.4.6

-    sleep 2

-}

-

-function stop_zookeeper() {

-    echo "zookeeper started"

-    docker rm -f zookeeper_server || true

-}

-

 function test_overlay() {

     dnet_suffix=$1

deleted file mode 100644

@@ -1,8 +0,0 @@

-# -*- mode: sh -*-

-#!/usr/bin/env bats

-

-load helpers

-

-@test "Test overlay network with zookeeper" {

-    test_overlay zookeeper

-}

@@ -89,25 +89,6 @@ function run_overlay_consul_host_tests() {

 	unset _OVERLAY_HOST_MODE

 }

-function run_overlay_zk_tests() {

-	## Test overlay network with zookeeper

-	start_dnet 1 zookeeper 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	cmap[dnet - 1 - zookeeper]=dnet-1-zookeeper

-	start_dnet 2 zookeeper 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	cmap[dnet - 2 - zookeeper]=dnet-2-zookeeper

-	start_dnet 3 zookeeper 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	cmap[dnet - 3 - zookeeper]=dnet-3-zookeeper

-

-	./integration-tmp/bin/bats ./test/integration/dnet/overlay-zookeeper.bats

-

-	stop_dnet 1 zookeeper 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	unset cmap[dnet-1-zookeeper]

-	stop_dnet 2 zookeeper 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	unset cmap[dnet-2-zookeeper]

-	stop_dnet 3 zookeeper 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	unset cmap[dnet-3-zookeeper]

-}

-

 function run_overlay_etcd_tests() {

 	## Test overlay network with etcd

 	start_dnet 1 etcd 1>> ${INTEGRATION_ROOT}/test.log 2>&1

@@ -155,29 +136,6 @@ function run_multi_consul_tests() {

 	unset cmap[dnet-3-multi_consul]

 }

-function run_multi_zk_tests() {

-	# Test multi node configuration with a global scope test driver backed by zookeeper

-

-	## Setup

-	start_dnet 1 multi_zk zookeeper 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	cmap[dnet - 1 - multi_zk]=dnet-1-multi_zk

-	start_dnet 2 multi_zk zookeeper 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	cmap[dnet - 2 - multi_zk]=dnet-2-multi_zk

-	start_dnet 3 multi_zk zookeeper 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	cmap[dnet - 3 - multi_zk]=dnet-3-multi_zk

-

-	## Run the test cases

-	./integration-tmp/bin/bats ./test/integration/dnet/multi.bats

-

-	## Teardown

-	stop_dnet 1 multi_zk 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	unset cmap[dnet-1-multi_zk]

-	stop_dnet 2 multi_zk 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	unset cmap[dnet-2-multi_zk]

-	stop_dnet 3 multi_zk 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	unset cmap[dnet-3-multi_zk]

-}

-

 function run_multi_etcd_tests() {

 	# Test multi node configuration with a global scope test driver backed by etcd

@@ -220,7 +178,7 @@ fi

 # Suite setup

 if [ -z "$SUITES" ]; then

-	suites="dnet multi_consul multi_zk multi_etcd  bridge overlay_consul overlay_consul_host overlay_zk overlay_etcd"

+	suites="dnet multi_consul multi_etcd  bridge overlay_consul overlay_consul_host overlay_etcd"

 else

 	suites="$SUITES"

 fi

@@ -231,12 +189,6 @@ if [[ ("$suites" =~ .*consul.*) || ("$suites" =~ .*bridge.*) ]]; then

 	cmap[pr_consul]=pr_consul

 fi

-if [[ "$suites" =~ .*zk.* ]]; then

-	echo "Starting zookeeper ..."

-	start_zookeeper 1>> ${INTEGRATION_ROOT}/test.log 2>&1

-	cmap[zookeeper_server]=zookeeper_server

-fi

-

 if [[ "$suites" =~ .*etcd.* ]]; then

 	echo "Starting etcd ..."

 	start_etcd 1>> ${INTEGRATION_ROOT}/test.log 2>&1

@@ -60,7 +60,6 @@ github.com/vishvananda/netlink                      f049be6f391489d3f374498fe0c8

 github.com/moby/ipvs                                4566ccea0e08d68e9614c3e7a64a23b850c4bb35 # v1.0.1

 github.com/google/btree                             479b5e81b0a93ec038d201b0b33d17db599531d3 # v1.0.1

-github.com/samuel/go-zookeeper                      d0e0d8e11f318e000a8cc434616d69e329edc374

 github.com/deckarep/golang-set                      ef32fa3046d9f249d399f98ebaf9be944430fd1d

 github.com/coreos/etcd                              973882f697a8db3d59815bf132c6c506434334bd # v3.3.27

 github.com/coreos/go-semver                         8ab6407b697782a06568d4b7f1db25550ec2e4c6 # v0.2.0

deleted file mode 100644

@@ -1,429 +0,0 @@

-package zookeeper

-

-import (

-	"strings"

-	"time"

-

-	"github.com/docker/libkv"

-	"github.com/docker/libkv/store"

-	zk "github.com/samuel/go-zookeeper/zk"

-)

-

-const (

-	// SOH control character

-	SOH = "\x01"

-

-	defaultTimeout = 10 * time.Second

-)

-

-// Zookeeper is the receiver type for

-// the Store interface

-type Zookeeper struct {

-	timeout time.Duration

-	client  *zk.Conn

-}

-

-type zookeeperLock struct {

-	client *zk.Conn

-	lock   *zk.Lock

-	key    string

-	value  []byte

-}

-

-// Register registers zookeeper to libkv

-func Register() {

-	libkv.AddStore(store.ZK, New)

-}

-

-// New creates a new Zookeeper client given a

-// list of endpoints and an optional tls config

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

-	s := &Zookeeper{}

-	s.timeout = defaultTimeout

-

-	// Set options

-	if options != nil {

-		if options.ConnectionTimeout != 0 {

-			s.setTimeout(options.ConnectionTimeout)

-		}

-	}

-

-	// Connect to Zookeeper

-	conn, _, err := zk.Connect(endpoints, s.timeout)

-	if err != nil {

-		return nil, err

-	}

-	s.client = conn

-

-	return s, nil

-}

-

-// setTimeout sets the timeout for connecting to Zookeeper

-func (s *Zookeeper) setTimeout(time time.Duration) {

-	s.timeout = time

-}

-

-// Get the value at "key", returns the last modified index

-// to use in conjunction to Atomic calls

-func (s *Zookeeper) Get(key string) (pair *store.KVPair, err error) {

-	resp, meta, err := s.client.Get(s.normalize(key))

-

-	if err != nil {

-		if err == zk.ErrNoNode {

-			return nil, store.ErrKeyNotFound

-		}

-		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,

-		LastIndex: uint64(meta.Version),

-	}

-

-	return pair, nil

-}

-

-// createFullPath creates the entire path for a directory

-// that does not exist

-func (s *Zookeeper) createFullPath(path []string, ephemeral bool) error {

-	for i := 1; i <= len(path); i++ {

-		newpath := "/" + strings.Join(path[:i], "/")

-		if i == len(path) && ephemeral {

-			_, err := s.client.Create(newpath, []byte{}, zk.FlagEphemeral, zk.WorldACL(zk.PermAll))

-			return err

-		}

-		_, err := s.client.Create(newpath, []byte{}, 0, zk.WorldACL(zk.PermAll))

-		if err != nil {

-			// Skip if node already exists

-			if err != zk.ErrNodeExists {

-				return err

-			}

-		}

-	}

-	return nil

-}

-

-// Put a value at "key"

-func (s *Zookeeper) Put(key string, value []byte, opts *store.WriteOptions) error {

-	fkey := s.normalize(key)

-

-	exists, err := s.Exists(key)

-	if err != nil {

-		return err

-	}

-

-	if !exists {

-		if opts != nil && opts.TTL > 0 {

-			s.createFullPath(store.SplitKey(strings.TrimSuffix(key, "/")), true)

-		} else {

-			s.createFullPath(store.SplitKey(strings.TrimSuffix(key, "/")), false)

-		}

-	}

-

-	_, err = s.client.Set(fkey, value, -1)

-	return err

-}

-

-// Delete a value at "key"

-func (s *Zookeeper) Delete(key string) error {

-	err := s.client.Delete(s.normalize(key), -1)

-	if err == zk.ErrNoNode {

-		return store.ErrKeyNotFound

-	}

-	return err

-}

-

-// Exists checks if the key exists inside the store

-func (s *Zookeeper) Exists(key string) (bool, error) {

-	exists, _, err := s.client.Exists(s.normalize(key))

-	if err != nil {

-		return false, err

-	}

-	return exists, nil

-}

-

-// Watch for changes on a "key"

-// It returns a channel that will receive changes or pass

-// on errors. Upon creation, the current value will first

-// be sent to the channel. Providing a non-nil stopCh can

-// be used to stop watching.

-func (s *Zookeeper) Watch(key string, stopCh <-chan struct{}) (<-chan *store.KVPair, error) {

-	// Get the key first

-	pair, err := s.Get(key)

-	if err != nil {

-		return nil, err

-	}

-

-	// Catch zk notifications and fire changes into the channel.

-	watchCh := make(chan *store.KVPair)

-	go func() {

-		defer close(watchCh)

-

-		// Get returns the current value to the channel prior

-		// to listening to any event that may occur on that key

-		watchCh <- pair

-		for {

-			_, _, eventCh, err := s.client.GetW(s.normalize(key))

-			if err != nil {

-				return

-			}

-			select {

-			case e := <-eventCh:

-				if e.Type == zk.EventNodeDataChanged {

-					if entry, err := s.Get(key); err == nil {

-						watchCh <- entry

-					}

-				}

-			case <-stopCh:

-				// There is no way to stop GetW so just quit

-				return

-			}

-		}

-	}()

-

-	return watchCh, nil

-}

-

-// WatchTree watches for changes on a "directory"

-// It returns a channel that will receive changes or pass

-// on errors. Upon creating a watch, the current childs values

-// will be sent to the channel .Providing a non-nil stopCh can

-// be used to stop watching.

-func (s *Zookeeper) WatchTree(directory string, stopCh <-chan struct{}) (<-chan []*store.KVPair, error) {

-	// List the childrens first

-	entries, err := s.List(directory)

-	if err != nil {

-		return nil, err

-	}

-

-	// Catch zk notifications and fire changes into the channel.

-	watchCh := make(chan []*store.KVPair)

-	go func() {

-		defer close(watchCh)

-

-		// List returns the children values to the channel

-		// prior to listening to any events that may occur

-		// on those keys

-		watchCh <- entries

-

-		for {

-			_, _, eventCh, err := s.client.ChildrenW(s.normalize(directory))

-			if err != nil {

-				return

-			}

-			select {

-			case e := <-eventCh:

-				if e.Type == zk.EventNodeChildrenChanged {

-					if kv, err := s.List(directory); err == nil {

-						watchCh <- kv

-					}

-				}

-			case <-stopCh:

-				// There is no way to stop GetW so just quit

-				return

-			}

-		}

-	}()

-

-	return watchCh, nil

-}

-

-// List child nodes of a given directory

-func (s *Zookeeper) List(directory string) ([]*store.KVPair, error) {

-	keys, stat, err := s.client.Children(s.normalize(directory))

-	if err != nil {

-		if err == zk.ErrNoNode {

-			return nil, store.ErrKeyNotFound

-		}

-		return nil, err

-	}

-

-	kv := []*store.KVPair{}

-

-	// FIXME Costly Get request for each child key..

-	for _, key := range keys {

-		pair, err := s.Get(strings.TrimSuffix(directory, "/") + s.normalize(key))

-		if err != nil {

-			// If node is not found: List is out of date, retry

-			if err == store.ErrKeyNotFound {

-				return s.List(directory)

-			}

-			return nil, err

-		}

-

-		kv = append(kv, &store.KVPair{

-			Key:       key,

-			Value:     []byte(pair.Value),

-			LastIndex: uint64(stat.Version),

-		})

-	}

-

-	return kv, nil

-}

-

-// DeleteTree deletes a range of keys under a given directory

-func (s *Zookeeper) DeleteTree(directory string) error {

-	pairs, err := s.List(directory)

-	if err != nil {

-		return err

-	}

-

-	var reqs []interface{}

-

-	for _, pair := range pairs {

-		reqs = append(reqs, &zk.DeleteRequest{

-			Path:    s.normalize(directory + "/" + pair.Key),

-			Version: -1,

-		})

-	}

-

-	_, err = s.client.Multi(reqs...)

-	return err

-}

-

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

-// modified in the meantime, throws an error if this is the case

-func (s *Zookeeper) AtomicPut(key string, value []byte, previous *store.KVPair, _ *store.WriteOptions) (bool, *store.KVPair, error) {

-	var lastIndex uint64

-

-	if previous != nil {

-		meta, err := s.client.Set(s.normalize(key), value, int32(previous.LastIndex))

-		if err != nil {

-			// Compare Failed

-			if err == zk.ErrBadVersion {

-				return false, nil, store.ErrKeyModified

-			}

-			return false, nil, err

-		}

-		lastIndex = uint64(meta.Version)

-	} else {

-		// Interpret previous == nil as create operation.

-		_, err := s.client.Create(s.normalize(key), value, 0, zk.WorldACL(zk.PermAll))

-		if err != nil {

-			// Directory does not exist

-			if err == zk.ErrNoNode {

-

-				// Create the directory

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

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

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

-					// Failed to create the directory.

-					return false, nil, err

-				}

-

-				// Create the node

-				if _, err := s.client.Create(s.normalize(key), value, 0, zk.WorldACL(zk.PermAll)); err != nil {

-					// Node exist error (when previous nil)

-					if err == zk.ErrNodeExists {

-						return false, nil, store.ErrKeyExists

-					}

-					return false, nil, err

-				}

-

-			} else {

-				// Node Exists error (when previous nil)

-				if err == zk.ErrNodeExists {

-					return false, nil, store.ErrKeyExists

-				}

-

-				// Unhandled error

-				return false, nil, err

-			}

-		}

-		lastIndex = 0 // Newly created nodes have version 0.

-	}

-

-	pair := &store.KVPair{

-		Key:       key,

-		Value:     value,

-		LastIndex: lastIndex,

-	}

-

-	return true, pair, nil

-}

-

-// AtomicDelete deletes a value at "key" if the key

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

-// error if this is the case

-func (s *Zookeeper) AtomicDelete(key string, previous *store.KVPair) (bool, error) {

-	if previous == nil {

-		return false, store.ErrPreviousNotSpecified

-	}

-

-	err := s.client.Delete(s.normalize(key), int32(previous.LastIndex))

-	if err != nil {

-		// Key not found

-		if err == zk.ErrNoNode {

-			return false, store.ErrKeyNotFound

-		}

-		// Compare failed

-		if err == zk.ErrBadVersion {

-			return false, store.ErrKeyModified

-		}

-		// General store error

-		return false, err

-	}

-	return true, nil

-}

-

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

-// be used to provide mutual exclusion on a key

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

-	value := []byte("")

-

-	// Apply options

-	if options != nil {

-		if options.Value != nil {

-			value = options.Value

-		}

-	}

-

-	lock = &zookeeperLock{

-		client: s.client,

-		key:    s.normalize(key),

-		value:  value,

-		lock:   zk.NewLock(s.client, s.normalize(key), zk.WorldACL(zk.PermAll)),

-	}

-

-	return lock, err

-}

-

-// 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(stopChan chan struct{}) (<-chan struct{}, error) {

-	err := l.lock.Lock()

-

-	if err == nil {

-		// We hold the lock, we can set our value

-		// FIXME: The value is left behind

-		// (problematic for leader election)

-		_, err = l.client.Set(l.key, l.value, -1)

-	}

-

-	return make(chan struct{}), err

-}

-

-// Unlock the "key". Calling unlock while

-// not holding the lock will throw an error

-func (l *zookeeperLock) Unlock() error {

-	return l.lock.Unlock()

-}

-

-// Close closes the client connection

-func (s *Zookeeper) Close() {

-	s.client.Close()

-}

-

-// Normalize the key for usage in Zookeeper

-func (s *Zookeeper) normalize(key string) string {

-	key = store.Normalize(key)

-	return strings.TrimSuffix(key, "/")

-}

deleted file mode 100644

@@ -1,25 +0,0 @@

-Copyright (c) 2013, Samuel Stauffer <samuel@descolada.com>

-All rights reserved.

-

-Redistribution and use in source and binary forms, with or without

-modification, are permitted provided that the following conditions are met:

-

-* Redistributions of source code must retain the above copyright

-  notice, this list of conditions and the following disclaimer.

-* Redistributions in binary form must reproduce the above copyright

-  notice, this list of conditions and the following disclaimer in the

-  documentation and/or other materials provided with the distribution.

-* Neither the name of the author nor the

-  names of its contributors may be used to endorse or promote products

-  derived from this software without specific prior written permission.

-

-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

-DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY

-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

deleted file mode 100644

@@ -1,11 +0,0 @@

-Native Go Zookeeper Client Library

-===================================

-

-[![Build Status](https://travis-ci.org/samuel/go-zookeeper.png)](https://travis-ci.org/samuel/go-zookeeper)

-

-Documentation: http://godoc.org/github.com/samuel/go-zookeeper/zk

-

-License

-

-3-clause BSD. See LICENSE file.

deleted file mode 100644

@@ -1,844 +0,0 @@

-package zk

-

-/*

-TODO:

-* make sure a ping response comes back in a reasonable time

-

-Possible watcher events:

-* Event{Type: EventNotWatching, State: StateDisconnected, Path: path, Err: err}

-*/

-

-import (

-	"crypto/rand"

-	"encoding/binary"

-	"errors"

-	"fmt"

-	"io"

-	"log"

-	"net"

-	"strconv"

-	"strings"

-	"sync"

-	"sync/atomic"

-	"time"

-)

-

-var ErrNoServer = errors.New("zk: could not connect to a server")

-

-const (

-	bufferSize      = 1536 * 1024

-	eventChanSize   = 6

-	sendChanSize    = 16

-	protectedPrefix = "_c_"

-)

-

-type watchType int

-

-const (

-	watchTypeData  = iota

-	watchTypeExist = iota

-	watchTypeChild = iota

-)

-

-type watchPathType struct {

-	path  string

-	wType watchType

-}

-

-type Dialer func(network, address string, timeout time.Duration) (net.Conn, error)

-

-type Conn struct {

-	lastZxid  int64

-	sessionID int64

-	state     State // must be 32-bit aligned

-	xid       uint32

-	timeout   int32 // session timeout in milliseconds

-	passwd    []byte

-

-	dialer          Dialer

-	servers         []string

-	serverIndex     int // remember last server that was tried during connect to round-robin attempts to servers

-	lastServerIndex int // index of the last server that was successfully connected to and authenticated with

-	conn            net.Conn

-	eventChan       chan Event

-	shouldQuit      chan struct{}

-	pingInterval    time.Duration

-	recvTimeout     time.Duration

-	connectTimeout  time.Duration

-

-	sendChan     chan *request

-	requests     map[int32]*request // Xid -> pending request

-	requestsLock sync.Mutex

-	watchers     map[watchPathType][]chan Event

-	watchersLock sync.Mutex

-

-	// Debug (used by unit tests)

-	reconnectDelay time.Duration

-}

-

-type request struct {

-	xid        int32

-	opcode     int32

-	pkt        interface{}

-	recvStruct interface{}

-	recvChan   chan response

-

-	// Because sending and receiving happen in separate go routines, there's

-	// a possible race condition when creating watches from outside the read

-	// loop. We must ensure that a watcher gets added to the list synchronously

-	// with the response from the server on any request that creates a watch.

-	// In order to not hard code the watch logic for each opcode in the recv

-	// loop the caller can use recvFunc to insert some synchronously code

-	// after a response.

-	recvFunc func(*request, *responseHeader, error)

-}

-

-type response struct {

-	zxid int64

-	err  error

-}

-

-type Event struct {

-	Type   EventType

-	State  State

-	Path   string // For non-session events, the path of the watched node.

-	Err    error

-	Server string // For connection events

-}

-

-// Connect establishes a new connection to a pool of zookeeper servers

-// using the default net.Dialer. See ConnectWithDialer for further

-// information about session timeout.

-func Connect(servers []string, sessionTimeout time.Duration) (*Conn, <-chan Event, error) {

-	return ConnectWithDialer(servers, sessionTimeout, nil)

-}

-

-// ConnectWithDialer establishes a new connection to a pool of zookeeper

-// servers. The provided session timeout sets the amount of time for which

-// a session is considered valid after losing connection to a server. Within

-// the session timeout it's possible to reestablish a connection to a different

-// server and keep the same session. This is means any ephemeral nodes and

-// watches are maintained.

-func ConnectWithDialer(servers []string, sessionTimeout time.Duration, dialer Dialer) (*Conn, <-chan Event, error) {

-	if len(servers) == 0 {

-		return nil, nil, errors.New("zk: server list must not be empty")

-	}

-

-	recvTimeout := sessionTimeout * 2 / 3

-

-	srvs := make([]string, len(servers))

-

-	for i, addr := range servers {

-		if strings.Contains(addr, ":") {

-			srvs[i] = addr

-		} else {

-			srvs[i] = addr + ":" + strconv.Itoa(DefaultPort)

-		}

-	}

-

-	// Randomize the order of the servers to avoid creating hotspots

-	stringShuffle(srvs)

-

-	ec := make(chan Event, eventChanSize)

-	if dialer == nil {

-		dialer = net.DialTimeout

-	}

-	conn := Conn{

-		dialer:          dialer,

-		servers:         srvs,

-		serverIndex:     0,

-		lastServerIndex: -1,

-		conn:            nil,

-		state:           StateDisconnected,

-		eventChan:       ec,

-		shouldQuit:      make(chan struct{}),

-		recvTimeout:     recvTimeout,

-		pingInterval:    recvTimeout / 2,

-		connectTimeout:  1 * time.Second,

-		sendChan:        make(chan *request, sendChanSize),

-		requests:        make(map[int32]*request),

-		watchers:        make(map[watchPathType][]chan Event),

-		passwd:          emptyPassword,

-		timeout:         int32(sessionTimeout.Nanoseconds() / 1e6),

-

-		// Debug

-		reconnectDelay: 0,

-	}

-	go func() {

-		conn.loop()

-		conn.flushRequests(ErrClosing)

-		conn.invalidateWatches(ErrClosing)

-		close(conn.eventChan)

-	}()

-	return &conn, ec, nil

-}

-

-func (c *Conn) Close() {

-	close(c.shouldQuit)

-

-	select {

-	case <-c.queueRequest(opClose, &closeRequest{}, &closeResponse{}, nil):

-	case <-time.After(time.Second):

-	}

-}

-

-func (c *Conn) State() State {

-	return State(atomic.LoadInt32((*int32)(&c.state)))

-}

-

-func (c *Conn) setState(state State) {

-	atomic.StoreInt32((*int32)(&c.state), int32(state))

-	select {

-	case c.eventChan <- Event{Type: EventSession, State: state, Server: c.servers[c.serverIndex]}:

-	default:

-		// panic("zk: event channel full - it must be monitored and never allowed to be full")

-	}

-}

-

-func (c *Conn) connect() error {

-	c.setState(StateConnecting)

-	for {

-		c.serverIndex = (c.serverIndex + 1) % len(c.servers)

-		if c.serverIndex == c.lastServerIndex {

-			c.flushUnsentRequests(ErrNoServer)

-			select {

-			case <-time.After(time.Second):

-				// pass

-			case <-c.shouldQuit:

-				c.setState(StateDisconnected)

-				c.flushUnsentRequests(ErrClosing)

-				return ErrClosing

-			}

-		} else if c.lastServerIndex < 0 {

-			// lastServerIndex defaults to -1 to avoid a delay on the initial connect

-			c.lastServerIndex = 0

-		}

-

-		zkConn, err := c.dialer("tcp", c.servers[c.serverIndex], c.connectTimeout)

-		if err == nil {

-			c.conn = zkConn

-			c.setState(StateConnected)

-			return nil

-		}

-

-		log.Printf("Failed to connect to %s: %+v", c.servers[c.serverIndex], err)

-	}

-}

-

-func (c *Conn) loop() {

-	for {

-		if err := c.connect(); err != nil {

-			// c.Close() was called

-			return

-		}