Merge lp:~rogpeppe/gozk/clean-up-interface into lp:~juju/gozk/trunk

[Roger Peppe]

Clean up gozk interface. Add Server function.

[Gustavo Niemeyer (niemeyer)]

This is looking fantastic. Thanks Roger.

Some details to sort out:

[1]

=== renamed file 'gozk.go' => 'zookeeper/gozk.go'

Please keep the files at the root of the branch. We'll put it in a
new series in launchpad so that the gozk/zookeeper reference is
correct.

[2]

+// Conn represents a connection to a set of Zookeeper nodes.

The project name is "ZooKeeper". Please use this casing consistently
across the code base.

[3]

+// ClientId represents an established ZooKeeper session. It can be
+// passed into New to reestablish a connection to an existing session.

There's no New function.

[4]

+ ZOK Error = C.ZOK
+ ZSYSTEMERROR Error = C.ZSYSTEMERROR
+ ZRUNTIMEINCONSISTENCY Error = C.ZRUNTIMEINCONSISTENCY

Much better!

[5]

+func (zk *Conn) RetryChange(path string, flags int, acl []ACL, changeFunc ChangeFunc) os.Error {

Very nice changes in RetryChange too, thanks!

[6]

+ path, err := zk.Create("/test-", "bababum", zookeeper.SEQUENCE|zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))

These lines make me unhappy about the length of "zookeeper". I'm thinking we
might well rename it to "zk" in a follow up branch, but please keep it like
this for now. Just for comparison:

path, err := conn.Create("/test-", "bababum", zk.SEQUENCE|zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))

[7]

+ c.Assert(stat, Equals, (*zookeeper.Stat)(nil))

c.Assert(stat, IsNil)

[8]

+// Server sets up a zookeeper server environment inside dataDir

ZooKeeper in this file as well.

[9]

+// for a server that listening on the specified TCP port, sending

s/listening/listens/

[10]

+// Server does not actually start the server. Instead it returns
+// a command line, suitable for passing to exec.Command,
+// for example.

Let's do a bit better than this. There's no reason to keep the
responsibility of creating the directory, starting, stopping,
cleaning, etc, with the caller. We need this for real, not just
due to testing, but in juju for the local deployment case.

I suggest we define a Server type as:

  type Server struct {
      runDir, installDir string
      cmd *exec.Cmd
  }

and:

  func zookeeper.NewServer(runDir) *Server

Then, we should have this as well:

  func (s *Server) Create(installDir string) os.Error
  func (s *Server) Start() os.Error
  func (s *Server) Stop() os.Error
  func (s *Server) Destroy() os.Error

Please push this in a spearate merge proposal. I'm happy to
merge the current version as is for the moment.

[11]

+var log4jProperties = []byte(`

No need to have two copies of that file in memory at all times. Use a const
and []byte() it when necessary.

[12]

+ classPath, _ := filepath.Glob(filepath.Join(dir, "zookeeper-*.jar"))
+ more, _ := filepath.Glob(filepath.Join(dir, "lib/*.jar"))

Please check the errors.

[13]

+ fd, err := os.Open(zookeeperEnviron)

That's a file, or an f, not an fd.

[14]

+ line, err := r.ReadSlice('\n')

ReadLine()

[15]

+ // strip quotes
+ if path[0] == '"' {
+ path = path[1 : len(path)-1]
+ }

Please use Trim. This logic assumes it...

review: Needs Fixing

[Roger Peppe (rogpeppe)]

On 23 September 2011 18:21, Gustavo Niemeyer <email address hidden> wrote:
> Review: Needs Fixing
>
> This is looking fantastic. Thanks Roger.
>
> Some details to sort out:
>
>
> [1]
>
> === renamed file 'gozk.go' => 'zookeeper/gozk.go'
>
> Please keep the files at the root of the branch. We'll put it in a
> new series in launchpad so that the gozk/zookeeper reference is
> correct.

ok. i moved the example file into an "example" directory
so that goinstall won't get confused.

>
>
> [2]
>
> +// Conn represents a connection to a set of Zookeeper nodes.
>
> The project name is "ZooKeeper". Please use this casing consistently
> across the code base.

done. + a few original discrepancies in this respect.

> [3]
>
> +// ClientId represents an established ZooKeeper session.  It can be
> +// passed into New to reestablish a connection to an existing session.
>
> There's no New function.

i'd already fixed this.

>
> +func (zk *Conn) RetryChange(path string, flags int, acl []ACL, changeFunc ChangeFunc) os.Error {
>
> Very nice changes in RetryChange too, thanks!

good. worth the bug, i'd say!

> [6]
>
> +       path, err := zk.Create("/test-", "bababum", zookeeper.SEQUENCE|zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
>
> These lines make me unhappy about the length of "zookeeper". I'm thinking we
> might well rename it to "zk" in a follow up branch, but please keep it like
> this for now. Just for comparison:
>
> path, err := conn.Create("/test-", "bababum", zk.SEQUENCE|zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))

my inclination would be to keep the name as "zookeeper", but
people can import as zk if they want. then strangers to code that's
using it will see "launchpad.net/zookeeper" and know instantly
what the package is about.

also, people can easily define constants for this kind of thing if they wish.

> +       c.Assert(stat, Equals, (*zookeeper.Stat)(nil))
>
> c.Assert(stat, IsNil)

done.

> [8]
>
> +// Server sets up a zookeeper server environment inside dataDir
>
> ZooKeeper in this file as well.

done.

> [9]
>
> +// for a server that listening on the specified TCP port, sending
>
> s/listening/listens/

done

> [10]
>
> +// Server does not actually start the server. Instead it returns
> +// a command line, suitable for passing to exec.Command,
> +// for example.
>
> Let's do a bit better than this. There's no reason to keep the
> responsibility of creating the directory, starting, stopping,
> cleaning, etc, with the caller. We need this for real, not just
> due to testing, but in juju for the local deployment case.

i thought quite a bit about this.
the problem with doing the starting ourselves is that
there are many things the caller might wish to do
with the running executable. for example:
- logging (see the custom logging in suite_test.go)
- running as a different user
- tweaking the config file before starting
- stashing the pid for long-term killability
- starting the same server several times on the same
  directory (as is done in this test suite). ok, your proposal
  does deal with this.

-
>
> I suggest we define a Server type as:
>
>  type Server struct {
>      runDir, installDir string
>      cmd *exec.Cmd
>  }
>
> ...

[lp:~rogpeppe/gozk/clean-up-interface]

24. By Roger Peppe on 2011-09-23

fixes after code review.

[Gustavo Niemeyer (niemeyer)]

Thanks for the changes. Some additional feedback:

[10]

> i thought quite a bit about this.
> the problem with doing the starting ourselves is that
> there are many things the caller might wish to do

Yeah, we talked precisely about this on IRC. None of the
points you mention are a good reason to not provide the
suggested interface.

[12]

> the docs say that the only error that glob can return is if the
> pattern is malformed. those patterns are evidently not.

Until someone changes them by mistake and they become malformed,
and rather than being warned about that we get crazy behavior.

A panic is fine in that case, but please do not leave errors unchecked.

[14]

Sounds good.

[lp:~rogpeppe/gozk/clean-up-interface]

25. By Roger Peppe on 2011-09-24

add error checks to Glob call

[Roger Peppe (rogpeppe)]

On 23 September 2011 19:41, Gustavo Niemeyer <email address hidden> wrote:
>> the docs say that the only error that glob can return is if the
>> pattern is malformed. those patterns are evidently not.
>
> Until someone changes them by mistake and they become malformed,
> and rather than being warned about that we get crazy behavior.
>
> A panic is fine in that case, but please do not leave errors unchecked.

i will do this since you ask. but i really think this is unnecessary.
the worst thing that will happen if the pattern is bad is that we'll
get no files.
this will also happen if the file name is misspelled, a much more likely
case (and one incidentally that i think might apply currently - i can't
test it), and one which the error check won't catch. it seems ok to me
that they're
both debugged in the same way.

[the only time a pattern can be bad is if ends in a backslash
or it has a malformed character class. the former is easy to see
and we're unlikely to add a character class match here.]

i've pushed a new version. i'll leave the Server changes for a separate
merge, as suggested.

[Gustavo Niemeyer (niemeyer)]

That's merged, and pushed to a new package location, and fixed accordingly:

    http://launchpad.net/gozk/zk

Once the Server implementation is finished, we can announce the new location
and the changes performed.

The new location also enables us to wait a bit for people to migrate, instead
of removing the old location immediately.

On the next merge proposal, please remember to target lp:~juju/juju/zk instead of trunk.

review: Approve

[Roger Peppe (rogpeppe)]

thanks, but...

one last plea to have the word "zookeeper" in the package path at least,
but preferably as the pkg identifier. people can import as zk if they wish
(or even as both!). i'm not keen on acronyms and abbreviations - can you
tell? :-)

On 24 September 2011 15:08, Gustavo Niemeyer <email address hidden> wrote:
> Review: Approve
>
> That's merged, and pushed to a new package location, and fixed accordingly:
>
>    http://launchpad.net/gozk/zk
>
> Once the Server implementation is finished, we can announce the new location
> and the changes performed.
>
> The new location also enables us to wait a bit for people to migrate, instead
> of removing the old location immediately.
>
> On the next merge proposal, please remember to target lp:~juju/juju/zk instead of trunk.
> --
> https://code.launchpad.net/~rogpeppe/gozk/clean-up-interface/+merge/76766
> You are the owner of lp:~rogpeppe/gozk/clean-up-interface.
>

[Gustavo Niemeyer (niemeyer)]

> one last plea to have the word "zookeeper" in the package path at least,
> but preferably as the pkg identifier. people can import as zk if they wish
> (or even as both!). i'm not keen on acronyms and abbreviations - can you
> tell? :-)

I can tell, but I'm not keen on the very long lines that the new package name
has created, so being a matter of personal choice only I'll reserve the right
to keep the existing convention unchanged in that one case.

I do accept taking the "go" prefix out, though.

=== modified file 'Makefile'
--- Makefile	2011-08-03 01:56:58 +0000
+++ Makefile	2011-09-24 08:31:23 +0000
@@ -2,10 +2,13 @@
 
 all: package
 
-TARG=gozk
+TARG=launchpad.net/zookeeper
 
+GOFILES=\
+	server.go\
+	
 CGOFILES=\
-	gozk.go\
+	zookeeper.go\
 
 CGO_OFILES=\
 	helpers.o\

=== added directory 'example'
=== renamed file 'example.go' => 'example/example.go'
--- example.go	2011-08-03 01:47:25 +0000
+++ example/example.go	2011-09-24 08:31:23 +0000
@@ -1,30 +1,29 @@
 package main
 
 import (
-    "gozk"
+	"launchpad.net/zookeeper/zookeeper"
 )
 
 func main() {
-    zk, session, err := gozk.Init("localhost:2181", 5000)
-    if err != nil {
-        println("Couldn't connect: " + err.String())
-        return
-    }
-
-    defer zk.Close()
-
-    // Wait for connection.
-    event := <-session
-    if event.State != gozk.STATE_CONNECTED {
-        println("Couldn't connect")
-        return
-    }
-
-    _, err = zk.Create("/counter", "0", 0, gozk.WorldACL(gozk.PERM_ALL))
-    if err != nil {
-        println(err.String())
-    } else {
-        println("Created!")
-    }
+	zk, session, err := zookeeper.Init("localhost:2181", 5000)
+	if err != nil {
+		println("Couldn't connect: " + err.String())
+		return
+	}
+
+	defer zk.Close()
+
+	// Wait for connection.
+	event := <-session
+	if event.State != zookeeper.STATE_CONNECTED {
+		println("Couldn't connect")
+		return
+	}
+
+	_, err = zk.Create("/counter", "0", 0, zookeeper.WorldACL(zookeeper.PERM_ALL))
+	if err != nil {
+		println(err.String())
+	} else {
+		println("Created!")
+	}
 }
-

=== modified file 'retry_test.go'
--- retry_test.go	2011-08-19 01:51:37 +0000
+++ retry_test.go	2011-09-24 08:31:23 +0000
@@ -1,16 +1,16 @@
-package gozk_test
+package zookeeper_test
 
 import (
 	. "launchpad.net/gocheck"
-	"gozk"
+	"launchpad.net/zookeeper"
 	"os"
 )
 
 func (s *S) TestRetryChangeCreating(c *C) {
 	zk, _ := s.init(c)
 
-	err := zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err := zk.RetryChange("/test", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL),
+		func(data string, stat *zookeeper.Stat) (string, os.Error) {
 			c.Assert(data, Equals, "")
 			c.Assert(stat, IsNil)
 			return "new", nil
@@ -25,18 +25,18 @@
 
 	acl, _, err := zk.ACL("/test")
 	c.Assert(err, IsNil)
-	c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_ALL))
+	c.Assert(acl, Equals, zookeeper.WorldACL(zookeeper.PERM_ALL))
 }
 
 func (s *S) TestRetryChangeSetting(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "old", zookeeper.EPHEMERAL,
+		zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	err = zk.RetryChange("/test", gozk.EPHEMERAL, []gozk.ACL{},
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err = zk.RetryChange("/test", zookeeper.EPHEMERAL, []zookeeper.ACL{},
+		func(data string, stat *zookeeper.Stat) (string, os.Error) {
 			c.Assert(data, Equals, "old")
 			c.Assert(stat, NotNil)
 			c.Assert(stat.Version(), Equals, int32(0))
@@ -53,18 +53,18 @@
 	// ACL was unchanged by RetryChange().
 	acl, _, err := zk.ACL("/test")
 	c.Assert(err, IsNil)
-	c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_ALL))
+	c.Assert(acl, Equals, zookeeper.WorldACL(zookeeper.PERM_ALL))
 }
 
 func (s *S) TestRetryChangeUnchangedValueDoesNothing(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "old", zookeeper.EPHEMERAL,
+		zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	err = zk.RetryChange("/test", gozk.EPHEMERAL, []gozk.ACL{},
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err = zk.RetryChange("/test", zookeeper.EPHEMERAL, []zookeeper.ACL{},
+		func(data string, stat *zookeeper.Stat) (string, os.Error) {
 			c.Assert(data, Equals, "old")
 			c.Assert(stat, NotNil)
 			c.Assert(stat.Version(), Equals, int32(0))
@@ -82,12 +82,12 @@
 func (s *S) TestRetryChangeConflictOnCreate(c *C) {
 	zk, _ := s.init(c)
 
-	changeFunc := func(data string, stat gozk.Stat) (string, os.Error) {
+	changeFunc := func(data string, stat *zookeeper.Stat) (string, os.Error) {
 		switch data {
 		case "":
 			c.Assert(stat, IsNil)
-			_, err := zk.Create("/test", "conflict", gozk.EPHEMERAL,
-				gozk.WorldACL(gozk.PERM_ALL))
+			_, err := zk.Create("/test", "conflict", zookeeper.EPHEMERAL,
+				zookeeper.WorldACL(zookeeper.PERM_ALL))
 			c.Assert(err, IsNil)
 			return "<none> => conflict", nil
 		case "conflict":
@@ -100,7 +100,7 @@
 		return "can't happen", nil
 	}
 
-	err := zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
+	err := zk.RetryChange("/test", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL),
 		changeFunc)
 	c.Assert(err, IsNil)
 
@@ -114,11 +114,11 @@
 func (s *S) TestRetryChangeConflictOnSetDueToChange(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "old", zookeeper.EPHEMERAL,
+		zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	changeFunc := func(data string, stat gozk.Stat) (string, os.Error) {
+	changeFunc := func(data string, stat *zookeeper.Stat) (string, os.Error) {
 		switch data {
 		case "old":
 			c.Assert(stat, NotNil)
@@ -136,7 +136,7 @@
 		return "can't happen", nil
 	}
 
-	err = zk.RetryChange("/test", gozk.EPHEMERAL, []gozk.ACL{}, changeFunc)
+	err = zk.RetryChange("/test", zookeeper.EPHEMERAL, []zookeeper.ACL{}, changeFunc)
 	c.Assert(err, IsNil)
 
 	data, stat, err := zk.Get("/test")
@@ -149,11 +149,11 @@
 func (s *S) TestRetryChangeConflictOnSetDueToDelete(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "old", zookeeper.EPHEMERAL,
+		zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	changeFunc := func(data string, stat gozk.Stat) (string, os.Error) {
+	changeFunc := func(data string, stat *zookeeper.Stat) (string, os.Error) {
 		switch data {
 		case "old":
 			c.Assert(stat, NotNil)
@@ -170,7 +170,7 @@
 		return "can't happen", nil
 	}
 
-	err = zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_READ),
+	err = zk.RetryChange("/test", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_READ),
 		changeFunc)
 	c.Assert(err, IsNil)
 
@@ -183,18 +183,17 @@
 	// Should be the new ACL.
 	acl, _, err := zk.ACL("/test")
 	c.Assert(err, IsNil)
-	c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_READ))
+	c.Assert(acl, Equals, zookeeper.WorldACL(zookeeper.PERM_READ))
 }
 
 func (s *S) TestRetryChangeErrorInCallback(c *C) {
 	zk, _ := s.init(c)
 
-	err := zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err := zk.RetryChange("/test", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL),
+		func(data string, stat *zookeeper.Stat) (string, os.Error) {
 			return "don't use this", os.NewError("BOOM!")
 		})
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZSYSTEMERROR)
 	c.Assert(err.String(), Equals, "BOOM!")
 
 	stat, err := zk.Exists("/test")
@@ -205,18 +204,18 @@
 func (s *S) TestRetryChangeFailsReading(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_WRITE)) // Write only!
+	_, err := zk.Create("/test", "old", zookeeper.EPHEMERAL,
+		zookeeper.WorldACL(zookeeper.PERM_WRITE)) // Write only!
 	c.Assert(err, IsNil)
 
 	var called bool
-	err = zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err = zk.RetryChange("/test", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL),
+		func(data string, stat *zookeeper.Stat) (string, os.Error) {
 			called = true
 			return "", nil
 		})
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
+	c.Assert(err, Equals, zookeeper.ZNOAUTH)
 
 	stat, err := zk.Exists("/test")
 	c.Assert(err, IsNil)
@@ -229,18 +228,17 @@
 func (s *S) TestRetryChangeFailsSetting(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_READ)) // Read only!
+	_, err := zk.Create("/test", "old", zookeeper.EPHEMERAL,
+		zookeeper.WorldACL(zookeeper.PERM_READ)) // Read only!
 	c.Assert(err, IsNil)
 
 	var called bool
-	err = zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err = zk.RetryChange("/test", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL),
+		func(data string, stat *zookeeper.Stat) (string, os.Error) {
 			called = true
 			return "", nil
 		})
-	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
+	c.Assert(err, Equals, zookeeper.ZNOAUTH)
 
 	stat, err := zk.Exists("/test")
 	c.Assert(err, IsNil)
@@ -253,19 +251,19 @@
 func (s *S) TestRetryChangeFailsCreating(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_READ)) // Read only!
+	_, err := zk.Create("/test", "old", zookeeper.EPHEMERAL,
+		zookeeper.WorldACL(zookeeper.PERM_READ)) // Read only!
 	c.Assert(err, IsNil)
 
 	var called bool
-	err = zk.RetryChange("/test/sub", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_ALL),
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err = zk.RetryChange("/test/sub", zookeeper.EPHEMERAL,
+		zookeeper.WorldACL(zookeeper.PERM_ALL),
+		func(data string, stat *zookeeper.Stat) (string, os.Error) {
 			called = true
 			return "", nil
 		})
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
+	c.Assert(err, Equals, zookeeper.ZNOAUTH)
 
 	stat, err := zk.Exists("/test/sub")
 	c.Assert(err, IsNil)

=== added file 'server.go'
--- server.go	1970-01-01 00:00:00 +0000
+++ server.go	2011-09-24 08:31:23 +0000
@@ -0,0 +1,166 @@
+package zookeeper
+
+import (
+	"bufio"
+	"bytes"
+	"exec"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const zookeeperEnviron = "/etc/zookeeper/conf/environment"
+
+// Server sets up a zookeeper server environment inside dataDir
+// for a server that listens on the specified TCP port, sending
+// all log messages to standard output.
+// The dataDir directory must exist already.
+// 
+// The zookeeper installation directory is specified by installedDir.
+// If this is empty, a system default will be used.
+//
+// Server does not actually start the server. Instead it returns
+// a command line, suitable for passing to exec.Command,
+// for example.
+func Server(port int, dataDir, installedDir string) ([]string, os.Error) {
+	cp, err := classPath(installedDir)
+	if err != nil {
+		return nil, err
+	}
+	logDir := filepath.Join(dataDir, "log")
+	if err = os.Mkdir(logDir, 0777); err != nil && err.(*os.PathError).Error != os.EEXIST {
+		return nil, err
+	}
+	logConfigPath, err := writeLog4JConfig(dataDir)
+	if err != nil {
+		return nil, err
+	}
+	configPath, err := writeZooKeeperConfig(dataDir, port)
+	if err != nil {
+		return nil, err
+	}
+	exe, err := exec.LookPath("java")
+	if err != nil {
+		return nil, err
+	}
+	cmd := []string{
+		exe,
+		"-cp", strings.Join(cp, ":"),
+		"-Dzookeeper.log.dir=" + logDir,
+		"-Dzookeeper.root.logger=INFO,CONSOLE",
+		"-Dlog4j.configuration=file:" + logConfigPath,
+		"org.apache.zookeeper.server.quorum.QuorumPeerMain",
+		configPath,
+	}
+	return cmd, nil
+}
+
+var log4jProperties = `
+log4j.rootLogger=INFO, CONSOLE
+log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
+log4j.appender.CONSOLE.Threshold=INFO
+log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
+log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} - %-5p [%t:%C{1}@%L] - %m%n
+`
+
+func writeLog4JConfig(dir string) (path string, err os.Error) {
+	path = filepath.Join(dir, "log4j.properties")
+	err = ioutil.WriteFile(path, []byte(log4jProperties), 0666)
+	return
+}
+
+func writeZooKeeperConfig(dir string, port int) (path string, err os.Error) {
+	path = filepath.Join(dir, "zoo.cfg")
+	err = ioutil.WriteFile(path, []byte(fmt.Sprintf(
+		"tickTime=2000\n"+
+			"dataDir=%s\n"+
+			"clientPort=%d\n"+
+			"maxClientCnxns=500\n",
+		dir, port)), 0666)
+	return
+}
+
+func classPath(dir string) ([]string, os.Error) {
+	if dir == "" {
+		return systemClassPath()
+	}
+	if err := checkDirectory(dir); err != nil {
+		return nil, err
+	}
+	// Two possibilities, as seen in zkEnv.sh:
+	// 1) locally built binaries (jars are in build directory)
+	// 2) release binaries
+	if build := filepath.Join(dir, "build"); checkDirectory(build) == nil {
+		dir = build
+	}
+	classPath, err := filepath.Glob(filepath.Join(dir, "zookeeper-*.jar"))
+	if err != nil {
+		panic(fmt.Errorf("glob for jar files: %v", err))
+	}
+	more, err := filepath.Glob(filepath.Join(dir, "lib/*.jar"))
+	if err != nil {
+		panic(fmt.Errorf("glob for lib jar files: %v", err))
+	}
+
+	classPath = append(classPath, more...)
+	if len(classPath) == 0 {
+		return nil, fmt.Errorf("zookeeper libraries not found in %q", dir)
+	}
+	return classPath, nil
+}
+
+func systemClassPath() ([]string, os.Error) {
+	f, err := os.Open(zookeeperEnviron)
+	if f == nil {
+		return nil, err
+	}
+	r := bufio.NewReader(f)
+	for {
+		line, err := r.ReadSlice('\n')
+		if err != nil {
+			break
+		}
+		if !bytes.HasPrefix(line, []byte("CLASSPATH=")) {
+			continue
+		}
+
+		// remove variable and newline
+		path := string(line[len("CLASSPATH=") : len(line)-1])
+
+		// trim white space
+		path = strings.Trim(path, " \t\r")
+
+		// strip quotes
+		if path[0] == '"' {
+			path = path[1 : len(path)-1]
+		}
+
+		// split on :
+		classPath := strings.Split(path, ":")
+
+		// split off $ZOOCFGDIR
+		if len(classPath) > 0 && classPath[0] == "$ZOOCFGDIR" {
+			classPath = classPath[1:]
+		}
+
+		if len(classPath) == 0 {
+			return nil, fmt.Errorf("empty class path in %q", zookeeperEnviron)
+		}
+		return classPath, nil
+	}
+	return nil, fmt.Errorf("no class path found in %q", zookeeperEnviron)
+}
+
+// checkDirectory returns an error if the given path
+// does not exist or is not a directory.
+func checkDirectory(path string) os.Error {
+	if info, err := os.Stat(path); err != nil || !info.IsDirectory() {
+		if err == nil {
+			err = &os.PathError{Op: "stat", Path: path, Error: os.NewError("is not a directory")}
+		}
+		return err
+	}
+	return nil
+}

=== modified file 'suite_test.go'
--- suite_test.go	2011-08-19 01:43:37 +0000
+++ suite_test.go	2011-09-24 08:31:23 +0000
@@ -1,13 +1,13 @@
-package gozk_test
+package zookeeper_test
 
 import (
 	. "launchpad.net/gocheck"
-	"testing"
-	"io/ioutil"
-	"path"
+	"bufio"
+	"exec"
 	"fmt"
+	"launchpad.net/zookeeper"
 	"os"
-	"gozk"
+	"testing"
 	"time"
 )
 
@@ -18,48 +18,32 @@
 var _ = Suite(&S{})
 
 type S struct {
-	zkRoot      string
-	zkTestRoot  string
-	zkTestPort  int
-	zkServerSh  string
-	zkServerOut *os.File
-	zkAddr      string
+	zkArgs     []string
+	zkTestRoot string
+	zkTestPort int
+	zkProcess  *os.Process // The running ZooKeeper process
+	zkAddr     string
 
-	handles     []*gozk.ZooKeeper
-	events      []*gozk.Event
+	handles     []*zookeeper.Conn
+	events      []*zookeeper.Event
 	liveWatches int
 	deadWatches chan bool
 }
 
-var logLevel = 0 //gozk.LOG_ERROR
-
-
-var testZooCfg = ("dataDir=%s\n" +
-	"clientPort=%d\n" +
-	"tickTime=2000\n" +
-	"initLimit=10\n" +
-	"syncLimit=5\n" +
-	"")
-
-var testLog4jPrp = ("log4j.rootLogger=INFO,CONSOLE\n" +
-	"log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender\n" +
-	"log4j.appender.CONSOLE.Threshold=DEBUG\n" +
-	"log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout\n" +
-	"log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} [myid:%X{myid}] - %-5p [%t:%C{1}@%L] - %m%n" +
-	"")
-
-func (s *S) init(c *C) (*gozk.ZooKeeper, chan gozk.Event) {
-	zk, watch, err := gozk.Init(s.zkAddr, 5e9)
+var logLevel = 0 //zookeeper.LOG_ERROR
+
+func (s *S) init(c *C) (*zookeeper.Conn, chan zookeeper.Event) {
+	zk, watch, err := zookeeper.Dial(s.zkAddr, 5e9)
 	c.Assert(err, IsNil)
 
 	s.handles = append(s.handles, zk)
 
 	event := <-watch
 
-	c.Assert(event.Type, Equals, gozk.EVENT_SESSION)
-	c.Assert(event.State, Equals, gozk.STATE_CONNECTED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_SESSION)
+	c.Assert(event.State, Equals, zookeeper.STATE_CONNECTED)
 
-	bufferedWatch := make(chan gozk.Event, 256)
+	bufferedWatch := make(chan zookeeper.Event, 256)
 	bufferedWatch <- event
 
 	s.liveWatches += 1
@@ -86,9 +70,9 @@
 }
 
 func (s *S) SetUpTest(c *C) {
-	c.Assert(gozk.CountPendingWatches(), Equals, 0,
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 0,
 		Bug("Test got a dirty watch state before running!"))
-	gozk.SetLogLevel(logLevel)
+	zookeeper.SetLogLevel(logLevel)
 }
 
 func (s *S) TearDownTest(c *C) {
@@ -108,98 +92,65 @@
 	}
 
 	// Reset the list of handles.
-	s.handles = make([]*gozk.ZooKeeper, 0)
+	s.handles = make([]*zookeeper.Conn, 0)
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 0,
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 0,
 		Bug("Test left live watches behind!"))
 }
 
-// We use the suite set up and tear down to manage a custom zookeeper
+// We use the suite set up and tear down to manage a custom ZooKeeper
 //
 func (s *S) SetUpSuite(c *C) {
-
+	var err os.Error
 	s.deadWatches = make(chan bool)
 
-	var err os.Error
-
-	s.zkRoot = os.Getenv("ZKROOT")
-	if s.zkRoot == "" {
-		panic("You must define $ZKROOT ($ZKROOT/bin/zkServer.sh is needed)")
-	}
-
 	s.zkTestRoot = c.MkDir()
 	s.zkTestPort = 21812
-
-	println("ZooKeeper test server directory:", s.zkTestRoot)
-	println("ZooKeeper test server port:", s.zkTestPort)
-
-	s.zkAddr = fmt.Sprintf("localhost:%d", s.zkTestPort)
-
-	s.zkServerSh = path.Join(s.zkRoot, "bin/zkServer.sh")
-	s.zkServerOut, err = os.OpenFile(path.Join(s.zkTestRoot, "stdout.txt"),
-		os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
-	if err != nil {
-		panic("Can't open stdout.txt file for server: " + err.String())
-	}
-
-	dataDir := path.Join(s.zkTestRoot, "data")
-	confDir := path.Join(s.zkTestRoot, "conf")
-
-	os.Mkdir(dataDir, 0755)
-	os.Mkdir(confDir, 0755)
-
-	err = os.Setenv("ZOOCFGDIR", confDir)
-	if err != nil {
-		panic("Can't set $ZOOCFGDIR: " + err.String())
-	}
-
-	zooCfg := []byte(fmt.Sprintf(testZooCfg, dataDir, s.zkTestPort))
-	err = ioutil.WriteFile(path.Join(confDir, "zoo.cfg"), zooCfg, 0644)
-	if err != nil {
-		panic("Can't write zoo.cfg: " + err.String())
-	}
-
-	log4jPrp := []byte(testLog4jPrp)
-	err = ioutil.WriteFile(path.Join(confDir, "log4j.properties"), log4jPrp, 0644)
-	if err != nil {
-		panic("Can't write log4j.properties: " + err.String())
-	}
-
-	s.StartZK()
+	s.zkAddr = fmt.Sprint("localhost:", s.zkTestPort)
+
+	s.zkArgs, err = zookeeper.Server(s.zkTestPort, s.zkTestRoot, "")
+	if err != nil {
+		c.Fatal("Cannot set up server environment: ", err)
+	}
+	s.StartZK(c)
 }
 
 func (s *S) TearDownSuite(c *C) {
 	s.StopZK()
-	s.zkServerOut.Close()
-}
-
-func (s *S) StartZK() {
-	attr := os.ProcAttr{Files: []*os.File{os.Stdin, s.zkServerOut, os.Stderr}}
-	proc, err := os.StartProcess(s.zkServerSh, []string{s.zkServerSh, "start"}, &attr)
-	if err != nil {
-		panic("Problem executing zkServer.sh start: " + err.String())
-	}
-
-	result, err := proc.Wait(0)
-	if err != nil {
-		panic(err.String())
-	} else if result.ExitStatus() != 0 {
-		panic("'zkServer.sh start' exited with non-zero status")
-	}
+}
+
+func startLogger(c *C, cmd *exec.Cmd) {
+	r, err := cmd.StdoutPipe()
+	if err != nil {
+		c.Fatal("cannot make output pipe:", err)
+	}
+	cmd.Stderr = cmd.Stdout
+	bio := bufio.NewReader(r)
+	go func() {
+		for {
+			line, err := bio.ReadSlice('\n')
+			if err != nil {
+				break
+			}
+			c.Log(line[0 : len(line)-1])
+		}
+	}()
+}
+
+func (s *S) StartZK(c *C) {
+	cmd := exec.Command(s.zkArgs[0], s.zkArgs[1:]...)
+	startLogger(c, cmd)
+	err := cmd.Start()
+	if err != nil {
+		c.Fatal("Error starting zookeeper server: ", err)
+	}
+	s.zkProcess = cmd.Process
 }
 
 func (s *S) StopZK() {
-	attr := os.ProcAttr{Files: []*os.File{os.Stdin, s.zkServerOut, os.Stderr}}
-	proc, err := os.StartProcess(s.zkServerSh, []string{s.zkServerSh, "stop"}, &attr)
-	if err != nil {
-		panic("Problem executing zkServer.sh stop: " + err.String() +
-			" (look for runaway java processes!)")
-	}
-	result, err := proc.Wait(0)
-	if err != nil {
-		panic(err.String())
-	} else if result.ExitStatus() != 0 {
-		panic("'zkServer.sh stop' exited with non-zero status " +
-			"(look for runaway java processes!)")
-	}
+	if s.zkProcess != nil {
+		s.zkProcess.Kill()
+		s.zkProcess.Wait(0)
+	}
+	s.zkProcess = nil
 }

=== added directory 'zookeeper'
=== renamed file 'gozk.go' => 'zookeeper.go'
--- gozk.go	2011-08-19 01:56:39 +0000
+++ zookeeper.go	2011-09-24 08:31:23 +0000
@@ -1,4 +1,4 @@
-// gozk - Zookeeper support for the Go language
+// gozk - ZooKeeper support for the Go language
 //
 //   https://wiki.ubuntu.com/gozk
 //
@@ -6,7 +6,7 @@
 //
 // Written by Gustavo Niemeyer <[e-mail]>
 //
-package gozk
+package zookeeper
 
 /*
 #cgo CFLAGS: -I/usr/include/c-client-src
@@ -27,17 +27,16 @@
 // -----------------------------------------------------------------------
 // Main constants and data types.
 
-// The main ZooKeeper object, created through the Init function.
-// Encapsulates all communication with ZooKeeper.
-type ZooKeeper struct {
+// Conn represents a connection to a set of ZooKeeper nodes.
+type Conn struct {
 	watchChannels  map[uintptr]chan Event
 	sessionWatchId uintptr
 	handle         *C.zhandle_t
 	mutex          sync.Mutex
 }
 
-// ClientId represents the established session in ZooKeeper.  This is only
-// useful to be passed back into the ReInit function.
+// ClientId represents an established ZooKeeper session.  It can be
+// passed into Redial to reestablish a connection to an existing session.
 type ClientId struct {
 	cId C.clientid_t
 }
@@ -98,35 +97,60 @@
 	State int
 }
 
-// Error codes that may be used to verify the result of the
-// Code method from Error.
+// Error represents a ZooKeeper error.
+type Error int
+
 const (
-	ZOK                      = C.ZOK
-	ZSYSTEMERROR             = C.ZSYSTEMERROR
-	ZRUNTIMEINCONSISTENCY    = C.ZRUNTIMEINCONSISTENCY
-	ZDATAINCONSISTENCY       = C.ZDATAINCONSISTENCY
-	ZCONNECTIONLOSS          = C.ZCONNECTIONLOSS
-	ZMARSHALLINGERROR        = C.ZMARSHALLINGERROR
-	ZUNIMPLEMENTED           = C.ZUNIMPLEMENTED
-	ZOPERATIONTIMEOUT        = C.ZOPERATIONTIMEOUT
-	ZBADARGUMENTS            = C.ZBADARGUMENTS
-	ZINVALIDSTATE            = C.ZINVALIDSTATE
-	ZAPIERROR                = C.ZAPIERROR
-	ZNONODE                  = C.ZNONODE
-	ZNOAUTH                  = C.ZNOAUTH
-	ZBADVERSION              = C.ZBADVERSION
-	ZNOCHILDRENFOREPHEMERALS = C.ZNOCHILDRENFOREPHEMERALS
-	ZNODEEXISTS              = C.ZNODEEXISTS
-	ZNOTEMPTY                = C.ZNOTEMPTY
-	ZSESSIONEXPIRED          = C.ZSESSIONEXPIRED
-	ZINVALIDCALLBACK         = C.ZINVALIDCALLBACK
-	ZINVALIDACL              = C.ZINVALIDACL
-	ZAUTHFAILED              = C.ZAUTHFAILED
-	ZCLOSING                 = C.ZCLOSING
-	ZNOTHING                 = C.ZNOTHING
-	ZSESSIONMOVED            = C.ZSESSIONMOVED
+	ZOK                      Error = C.ZOK
+	ZSYSTEMERROR             Error = C.ZSYSTEMERROR
+	ZRUNTIMEINCONSISTENCY    Error = C.ZRUNTIMEINCONSISTENCY
+	ZDATAINCONSISTENCY       Error = C.ZDATAINCONSISTENCY
+	ZCONNECTIONLOSS          Error = C.ZCONNECTIONLOSS
+	ZMARSHALLINGERROR        Error = C.ZMARSHALLINGERROR
+	ZUNIMPLEMENTED           Error = C.ZUNIMPLEMENTED
+	ZOPERATIONTIMEOUT        Error = C.ZOPERATIONTIMEOUT
+	ZBADARGUMENTS            Error = C.ZBADARGUMENTS
+	ZINVALIDSTATE            Error = C.ZINVALIDSTATE
+	ZAPIERROR                Error = C.ZAPIERROR
+	ZNONODE                  Error = C.ZNONODE
+	ZNOAUTH                  Error = C.ZNOAUTH
+	ZBADVERSION              Error = C.ZBADVERSION
+	ZNOCHILDRENFOREPHEMERALS Error = C.ZNOCHILDRENFOREPHEMERALS
+	ZNODEEXISTS              Error = C.ZNODEEXISTS
+	ZNOTEMPTY                Error = C.ZNOTEMPTY
+	ZSESSIONEXPIRED          Error = C.ZSESSIONEXPIRED
+	ZINVALIDCALLBACK         Error = C.ZINVALIDCALLBACK
+	ZINVALIDACL              Error = C.ZINVALIDACL
+	ZAUTHFAILED              Error = C.ZAUTHFAILED
+	ZCLOSING                 Error = C.ZCLOSING
+	ZNOTHING                 Error = C.ZNOTHING
+	ZSESSIONMOVED            Error = C.ZSESSIONMOVED
 )
 
+func (error Error) String() string {
+	return C.GoString(C.zerror(C.int(error))) // Static, no need to free it.
+}
+
+// zkError creates an appropriate error return from
+// a ZooKeeper status and the errno return from a C API
+// call.
+func zkError(rc C.int, cerr os.Error) os.Error {
+	code := Error(rc)
+	switch code {
+	case ZOK:
+		return nil
+
+	case ZSYSTEMERROR:
+		// If a zookeeper call returns ZSYSTEMERROR, then
+		// errno becomes significant. If errno has not been
+		// set, then we will return ZSYSTEMERROR nonetheless.
+		if cerr != nil {
+			return cerr
+		}
+	}
+	return code
+}
+
 // Constants for SetLogLevel.
 const (
 	LOG_ERROR = C.ZOO_LOG_LEVEL_ERROR
@@ -273,104 +297,54 @@
 }
 
 // -----------------------------------------------------------------------
-// Error interface which maps onto the ZooKeeper error codes.
-
-type Error interface {
-	String() string
-	Code() int
-}
-
-type errorType struct {
-	zkrc C.int
-	err  os.Error
-}
-
-func newError(zkrc C.int, err os.Error) Error {
-	return &errorType{zkrc, err}
-}
-
-func (error *errorType) String() (result string) {
-	if error.zkrc == ZSYSTEMERROR && error.err != nil {
-		result = error.err.String()
-	} else {
-		result = C.GoString(C.zerror(error.zkrc)) // Static, no need to free it.
-	}
-	return
-}
-
-// Code returns the error code that may be compared against one of
-// the gozk.Z* constants.
-func (error *errorType) Code() int {
-	return int(error.zkrc)
-}
-
-// -----------------------------------------------------------------------
-// Stat interface which maps onto the ZooKeeper Stat struct.
-
-// We declare this as an interface rather than an actual struct because
-// this way we don't have to copy data around between the real C struct
-// and the Go one on every call.  Most uses will only touch a few elements,
-// or even ignore the stat entirely, so that's a win.
 
 // Stat contains detailed information about a node.
-type Stat interface {
-	Czxid() int64
-	Mzxid() int64
-	CTime() int64
-	MTime() int64
-	Version() int32
-	CVersion() int32
-	AVersion() int32
-	EphemeralOwner() int64
-	DataLength() int32
-	NumChildren() int32
-	Pzxid() int64
-}
-
-type resultStat C.struct_Stat
-
-func (stat *resultStat) Czxid() int64 {
-	return int64(stat.czxid)
-}
-
-func (stat *resultStat) Mzxid() int64 {
-	return int64(stat.mzxid)
-}
-
-func (stat *resultStat) CTime() int64 {
-	return int64(stat.ctime)
-}
-
-func (stat *resultStat) MTime() int64 {
-	return int64(stat.mtime)
-}
-
-func (stat *resultStat) Version() int32 {
-	return int32(stat.version)
-}
-
-func (stat *resultStat) CVersion() int32 {
-	return int32(stat.cversion)
-}
-
-func (stat *resultStat) AVersion() int32 {
-	return int32(stat.aversion)
-}
-
-func (stat *resultStat) EphemeralOwner() int64 {
-	return int64(stat.ephemeralOwner)
-}
-
-func (stat *resultStat) DataLength() int32 {
-	return int32(stat.dataLength)
-}
-
-func (stat *resultStat) NumChildren() int32 {
-	return int32(stat.numChildren)
-}
-
-func (stat *resultStat) Pzxid() int64 {
-	return int64(stat.pzxid)
+type Stat struct {
+	c C.struct_Stat
+}
+
+func (stat *Stat) Czxid() int64 {
+	return int64(stat.c.czxid)
+}
+
+func (stat *Stat) Mzxid() int64 {
+	return int64(stat.c.mzxid)
+}
+
+func (stat *Stat) CTime() int64 {
+	return int64(stat.c.ctime)
+}
+
+func (stat *Stat) MTime() int64 {
+	return int64(stat.c.mtime)
+}
+
+func (stat *Stat) Version() int32 {
+	return int32(stat.c.version)
+}
+
+func (stat *Stat) CVersion() int32 {
+	return int32(stat.c.cversion)
+}
+
+func (stat *Stat) AVersion() int32 {
+	return int32(stat.c.aversion)
+}
+
+func (stat *Stat) EphemeralOwner() int64 {
+	return int64(stat.c.ephemeralOwner)
+}
+
+func (stat *Stat) DataLength() int32 {
+	return int32(stat.c.dataLength)
+}
+
+func (stat *Stat) NumChildren() int32 {
+	return int32(stat.c.numChildren)
+}
+
+func (stat *Stat) Pzxid() int64 {
+	return int64(stat.c.pzxid)
 }
 
 // -----------------------------------------------------------------------
@@ -384,7 +358,7 @@
 	C.zoo_set_debug_level(C.ZooLogLevel(level))
 }
 
-// Init initializes the communication with a ZooKeeper cluster. The provided
+// Dial initializes the communication with a ZooKeeper cluster. The provided
 // servers parameter may include multiple server addresses, separated
 // by commas, so that the client will automatically attempt to connect
 // to another server if one of them stops working for whatever reason.
@@ -398,21 +372,18 @@
 // The watch channel receives events of type SESSION_EVENT when any change
 // to the state of the established connection happens.  See the documentation
 // for the Event type for more details.
-func Init(servers string, recvTimeoutNS int64) (zk *ZooKeeper, watch chan Event, err Error) {
-	zk, watch, err = internalInit(servers, recvTimeoutNS, nil)
-	return
+func Dial(servers string, recvTimeoutNS int64) (*Conn, <-chan Event, os.Error) {
+	return dial(servers, recvTimeoutNS, nil)
 }
 
-// Equivalent to Init, but attempt to reestablish an existing session
+// Redial is equivalent to Dial, but attempts to reestablish an existing session
 // identified via the clientId parameter.
-func ReInit(servers string, recvTimeoutNS int64, clientId *ClientId) (zk *ZooKeeper, watch chan Event, err Error) {
-	zk, watch, err = internalInit(servers, recvTimeoutNS, clientId)
-	return
+func Redial(servers string, recvTimeoutNS int64, clientId *ClientId) (*Conn, <-chan Event, os.Error) {
+	return dial(servers, recvTimeoutNS, clientId)
 }
 
-func internalInit(servers string, recvTimeoutNS int64, clientId *ClientId) (*ZooKeeper, chan Event, Error) {
-
-	zk := &ZooKeeper{}
+func dial(servers string, recvTimeoutNS int64, clientId *ClientId) (*Conn, <-chan Event, os.Error) {
+	zk := &Conn{}
 	zk.watchChannels = make(map[uintptr]chan Event)
 
 	var cId *C.clientid_t
@@ -424,11 +395,11 @@
 	zk.sessionWatchId = watchId
 
 	cservers := C.CString(servers)
-	handle, cerr := C.zookeeper_init(cservers, C.watch_handler, C.int(recvTimeoutNS / 1e6), cId, unsafe.Pointer(watchId), 0)
+	handle, cerr := C.zookeeper_init(cservers, C.watch_handler, C.int(recvTimeoutNS/1e6), cId, unsafe.Pointer(watchId), 0)
 	C.free(unsafe.Pointer(cservers))
 	if handle == nil {
 		zk.closeAllWatches()
-		return nil, nil, newError(ZSYSTEMERROR, cerr)
+		return nil, nil, zkError(C.int(ZSYSTEMERROR), cerr)
 	}
 	zk.handle = handle
 	runWatchLoop()
@@ -437,12 +408,12 @@
 
 // ClientId returns the client ID for the existing session with ZooKeeper.
 // This is useful to reestablish an existing session via ReInit.
-func (zk *ZooKeeper) ClientId() *ClientId {
+func (zk *Conn) ClientId() *ClientId {
 	return &ClientId{*C.zoo_client_id(zk.handle)}
 }
 
 // Close terminates the ZooKeeper interaction.
-func (zk *ZooKeeper) Close() Error {
+func (zk *Conn) Close() os.Error {
 
 	// Protect from concurrency around zk.handle change.
 	zk.mutex.Lock()
@@ -451,7 +422,7 @@
 	if zk.handle == nil {
 		// ZooKeeper may hang indefinitely if a handler is closed twice,
 		// so we get in the way and prevent it from happening.
-		return newError(ZCLOSING, nil)
+		return ZCLOSING
 	}
 	rc, cerr := C.zookeeper_close(zk.handle)
 
@@ -461,16 +432,13 @@
 	// At this point, nothing else should need zk.handle.
 	zk.handle = nil
 
-	if rc != C.ZOK {
-		return newError(rc, cerr)
-	}
-	return nil
+	return zkError(rc, cerr)
 }
 
 // Get returns the data and status from an existing node.  err will be nil,
 // unless an error is found. Attempting to retrieve data from a non-existing
 // node is an error.
-func (zk *ZooKeeper) Get(path string) (data string, stat Stat, err Error) {
+func (zk *Conn) Get(path string) (data string, stat *Stat, err os.Error) {
 
 	cpath := C.CString(path)
 	cbuffer := (*C.char)(C.malloc(bufferSize))
@@ -478,22 +446,22 @@
 	defer C.free(unsafe.Pointer(cpath))
 	defer C.free(unsafe.Pointer(cbuffer))
 
-	cstat := C.struct_Stat{}
+	var cstat Stat
 	rc, cerr := C.zoo_wget(zk.handle, cpath, nil, nil,
-		cbuffer, &cbufferLen, &cstat)
+		cbuffer, &cbufferLen, &cstat.c)
 	if rc != C.ZOK {
-		return "", nil, newError(rc, cerr)
+		return "", nil, zkError(rc, cerr)
 	}
+
 	result := C.GoStringN(cbuffer, cbufferLen)
-
-	return result, (*resultStat)(&cstat), nil
+	return result, &cstat, nil
 }
 
 // GetW works like Get but also returns a channel that will receive
 // a single Event value when the data or existence of the given ZooKeeper
 // node changes or when critical session events happen.  See the
 // documentation of the Event type for more details.
-func (zk *ZooKeeper) GetW(path string) (data string, stat Stat, watch chan Event, err Error) {
+func (zk *Conn) GetW(path string) (data string, stat *Stat, watch <-chan Event, err os.Error) {
 
 	cpath := C.CString(path)
 	cbuffer := (*C.char)(C.malloc(bufferSize))
@@ -503,40 +471,39 @@
 
 	watchId, watchChannel := zk.createWatch(true)
 
-	cstat := C.struct_Stat{}
+	var cstat Stat
 	rc, cerr := C.zoo_wget(zk.handle, cpath,
 		C.watch_handler, unsafe.Pointer(watchId),
-		cbuffer, &cbufferLen, &cstat)
+		cbuffer, &cbufferLen, &cstat.c)
 	if rc != C.ZOK {
 		zk.forgetWatch(watchId)
-		return "", nil, nil, newError(rc, cerr)
+		return "", nil, nil, zkError(rc, cerr)
 	}
 
 	result := C.GoStringN(cbuffer, cbufferLen)
-	return result, (*resultStat)(&cstat), watchChannel, nil
+	return result, &cstat, watchChannel, nil
 }
 
 // Children returns the children list and status from an existing node.
-// err will be nil, unless an error is found. Attempting to retrieve the
-// children list from a non-existent node is an error.
-func (zk *ZooKeeper) Children(path string) (children []string, stat Stat, err Error) {
+// Attempting to retrieve the children list from a non-existent node is an error.
+func (zk *Conn) Children(path string) (children []string, stat *Stat, err os.Error) {
 
 	cpath := C.CString(path)
 	defer C.free(unsafe.Pointer(cpath))
 
 	cvector := C.struct_String_vector{}
-	cstat := C.struct_Stat{}
+	var cstat Stat
 	rc, cerr := C.zoo_wget_children2(zk.handle, cpath, nil, nil,
-		&cvector, &cstat)
+		&cvector, &cstat.c)
 
 	// Can't happen if rc != 0, but avoid potential memory leaks in the future.
 	if cvector.count != 0 {
 		children = parseStringVector(&cvector)
 	}
-	if rc != C.ZOK {
-		err = newError(rc, cerr)
+	if rc == C.ZOK {
+		stat = &cstat
 	} else {
-		stat = (*resultStat)(&cstat)
+		err = zkError(rc, cerr)
 	}
 	return
 }
@@ -545,7 +512,7 @@
 // receive a single Event value when a node is added or removed under the
 // provided path or when critical session events happen.  See the documentation
 // of the Event type for more details.
-func (zk *ZooKeeper) ChildrenW(path string) (children []string, stat Stat, watch chan Event, err Error) {
+func (zk *Conn) ChildrenW(path string) (children []string, stat *Stat, watch <-chan Event, err os.Error) {
 
 	cpath := C.CString(path)
 	defer C.free(unsafe.Pointer(cpath))
@@ -553,21 +520,21 @@
 	watchId, watchChannel := zk.createWatch(true)
 
 	cvector := C.struct_String_vector{}
-	cstat := C.struct_Stat{}
+	var cstat Stat
 	rc, cerr := C.zoo_wget_children2(zk.handle, cpath,
 		C.watch_handler, unsafe.Pointer(watchId),
-		&cvector, &cstat)
+		&cvector, &cstat.c)
 
 	// Can't happen if rc != 0, but avoid potential memory leaks in the future.
 	if cvector.count != 0 {
 		children = parseStringVector(&cvector)
 	}
-	if rc != C.ZOK {
+	if rc == C.ZOK {
+		stat = &cstat
+		watch = watchChannel
+	} else {
 		zk.forgetWatch(watchId)
-		err = newError(rc, cerr)
-	} else {
-		stat = (*resultStat)(&cstat)
-		watch = watchChannel
+		err = zkError(rc, cerr)
 	}
 	return
 }
@@ -588,20 +555,20 @@
 // Exists checks if a node exists at the given path.  If it does,
 // stat will contain meta information on the existing node, otherwise
 // it will be nil.
-func (zk *ZooKeeper) Exists(path string) (stat Stat, err Error) {
+func (zk *Conn) Exists(path string) (stat *Stat, err os.Error) {
 	cpath := C.CString(path)
 	defer C.free(unsafe.Pointer(cpath))
 
-	cstat := C.struct_Stat{}
-	rc, cerr := C.zoo_wexists(zk.handle, cpath, nil, nil, &cstat)
+	var cstat Stat
+	rc, cerr := C.zoo_wexists(zk.handle, cpath, nil, nil, &stat.c)
 
 	// We diverge a bit from the usual here: a ZNONODE is not an error
 	// for an exists call, otherwise every Exists call would have to check
 	// for err != nil and err.Code() != ZNONODE.
 	if rc == C.ZOK {
-		stat = (*resultStat)(&cstat)
+		stat = &cstat
 	} else if rc != C.ZNONODE {
-		err = newError(rc, cerr)
+		err = zkError(rc, cerr)
 	}
 	return
 }
@@ -611,28 +578,28 @@
 // stat is nil and the node didn't exist, or when the existing node
 // is removed. It will also receive critical session events. See the
 // documentation of the Event type for more details.
-func (zk *ZooKeeper) ExistsW(path string) (stat Stat, watch chan Event, err Error) {
+func (zk *Conn) ExistsW(path string) (stat *Stat, watch <-chan Event, err os.Error) {
 	cpath := C.CString(path)
 	defer C.free(unsafe.Pointer(cpath))
 
 	watchId, watchChannel := zk.createWatch(true)
 
-	cstat := C.struct_Stat{}
+	var cstat Stat
 	rc, cerr := C.zoo_wexists(zk.handle, cpath,
-		C.watch_handler, unsafe.Pointer(watchId), &cstat)
+		C.watch_handler, unsafe.Pointer(watchId), &cstat.c)
 
 	// We diverge a bit from the usual here: a ZNONODE is not an error
 	// for an exists call, otherwise every Exists call would have to check
 	// for err != nil and err.Code() != ZNONODE.
-	switch rc {
+	switch Error(rc) {
 	case ZOK:
-		stat = (*resultStat)(&cstat)
+		stat = &cstat
 		watch = watchChannel
 	case ZNONODE:
 		watch = watchChannel
 	default:
 		zk.forgetWatch(watchId)
-		err = newError(rc, cerr)
+		err = zkError(rc, cerr)
 	}
 	return
 }
@@ -646,7 +613,7 @@
 // The returned path is useful in cases where the created path may differ
 // from the requested one, such as when a sequence number is appended
 // to it due to the use of the gozk.SEQUENCE flag.
-func (zk *ZooKeeper) Create(path, value string, flags int, aclv []ACL) (pathCreated string, err Error) {
+func (zk *Conn) Create(path, value string, flags int, aclv []ACL) (pathCreated string, err os.Error) {
 	cpath := C.CString(path)
 	cvalue := C.CString(value)
 	defer C.free(unsafe.Pointer(cpath))
@@ -662,11 +629,12 @@
 
 	rc, cerr := C.zoo_create(zk.handle, cpath, cvalue, C.int(len(value)),
 		caclv, C.int(flags), cpathCreated, C.int(cpathLen))
-	if rc != C.ZOK {
-		return "", newError(rc, cerr)
+	if rc == C.ZOK {
+		pathCreated = C.GoString(cpathCreated)
+	} else {
+		err = zkError(rc, cerr)
 	}
-
-	return C.GoString(cpathCreated), nil
+	return
 }
 
 // Set modifies the data for the existing node at the given path, replacing it
@@ -677,35 +645,32 @@
 //
 // It is an error to attempt to set the data of a non-existing node with
 // this function. In these cases, use Create instead.
-func (zk *ZooKeeper) Set(path, value string, version int32) (stat Stat, err Error) {
+func (zk *Conn) Set(path, value string, version int32) (stat *Stat, err os.Error) {
 
 	cpath := C.CString(path)
 	cvalue := C.CString(value)
 	defer C.free(unsafe.Pointer(cpath))
 	defer C.free(unsafe.Pointer(cvalue))
 
-	cstat := C.struct_Stat{}
-
+	var cstat Stat
 	rc, cerr := C.zoo_set2(zk.handle, cpath, cvalue, C.int(len(value)),
-		C.int(version), &cstat)
-	if rc != C.ZOK {
-		return nil, newError(rc, cerr)
+		C.int(version), &cstat.c)
+	if rc == C.ZOK {
+		stat = &cstat
+	} else {
+		err = zkError(rc, cerr)
 	}
-
-	return (*resultStat)(&cstat), nil
+	return
 }
 
 // Delete removes the node at path. If version is not -1, the operation
 // will only succeed if the node is still at this version when the
 // node is deleted as an atomic operation.
-func (zk *ZooKeeper) Delete(path string, version int32) (err Error) {
+func (zk *Conn) Delete(path string, version int32) (err os.Error) {
 	cpath := C.CString(path)
 	defer C.free(unsafe.Pointer(cpath))
 	rc, cerr := C.zoo_delete(zk.handle, cpath, C.int(version))
-	if rc != C.ZOK {
-		return newError(rc, cerr)
-	}
-	return nil
+	return zkError(rc, cerr)
 }
 
 // AddAuth adds a new authentication certificate to the ZooKeeper
@@ -713,7 +678,7 @@
 // authentication information, while the cert parameter provides the
 // identity data itself. For instance, the "digest" scheme requires
 // a pair like "username:password" to be provided as the certificate.
-func (zk *ZooKeeper) AddAuth(scheme, cert string) Error {
+func (zk *Conn) AddAuth(scheme, cert string) os.Error {
 	cscheme := C.CString(scheme)
 	ccert := C.CString(cert)
 	defer C.free(unsafe.Pointer(cscheme))
@@ -728,40 +693,36 @@
 	rc, cerr := C.zoo_add_auth(zk.handle, cscheme, ccert, C.int(len(cert)),
 		C.handle_void_completion, unsafe.Pointer(data))
 	if rc != C.ZOK {
-		return newError(rc, cerr)
+		return zkError(rc, cerr)
 	}
 
 	C.wait_for_completion(data)
 
 	rc = C.int(uintptr(data.data))
-	if rc != C.ZOK {
-		return newError(rc, nil)
-	}
-
-	return nil
+	return zkError(rc, nil)
 }
 
 // ACL returns the access control list for path.
-func (zk *ZooKeeper) ACL(path string) ([]ACL, Stat, Error) {
+func (zk *Conn) ACL(path string) ([]ACL, *Stat, os.Error) {
 
 	cpath := C.CString(path)
 	defer C.free(unsafe.Pointer(cpath))
 
 	caclv := C.struct_ACL_vector{}
-	cstat := C.struct_Stat{}
 
-	rc, cerr := C.zoo_get_acl(zk.handle, cpath, &caclv, &cstat)
+	var cstat Stat
+	rc, cerr := C.zoo_get_acl(zk.handle, cpath, &caclv, &cstat.c)
 	if rc != C.ZOK {
-		return nil, nil, newError(rc, cerr)
+		return nil, nil, zkError(rc, cerr)
 	}
 
 	aclv := parseACLVector(&caclv)
 
-	return aclv, (*resultStat)(&cstat), nil
+	return aclv, &cstat, nil
 }
 
 // SetACL changes the access control list for path.
-func (zk *ZooKeeper) SetACL(path string, aclv []ACL, version int32) Error {
+func (zk *Conn) SetACL(path string, aclv []ACL, version int32) os.Error {
 
 	cpath := C.CString(path)
 	defer C.free(unsafe.Pointer(cpath))
@@ -770,11 +731,7 @@
 	defer C.deallocate_ACL_vector(caclv)
 
 	rc, cerr := C.zoo_set_acl(zk.handle, cpath, C.int(version), caclv)
-	if rc != C.ZOK {
-		return newError(rc, cerr)
-	}
-
-	return nil
+	return zkError(rc, cerr)
 }
 
 func parseACLVector(caclv *C.struct_ACL_vector) []ACL {
@@ -822,7 +779,7 @@
 // -----------------------------------------------------------------------
 // RetryChange utility method.
 
-type ChangeFunc func(oldValue string, oldStat Stat) (newValue string, err os.Error)
+type ChangeFunc func(oldValue string, oldStat *Stat) (newValue string, err os.Error)
 
 // RetryChange runs changeFunc to attempt to atomically change path
 // in a lock free manner, and retries in case there was another
@@ -831,8 +788,7 @@
 // changeFunc must work correctly if called multiple times in case
 // the modification fails due to concurrent changes, and it may return
 // an error that will cause the the RetryChange function to stop and
-// return an Error with code ZSYSTEMERROR and the same .String() result
-// as the provided error.
+// return the same error.
 //
 // This mechanism is not suitable for a node that is frequently modified
 // concurrently. For those cases, consider using a pessimistic locking
@@ -845,8 +801,7 @@
 //
 // 2. Call the changeFunc with the current node value and stat,
 // or with an empty string and nil stat, if the node doesn't yet exist.
-// If the changeFunc returns an error, stop and return an Error with
-// ZSYSTEMERROR Code() and the same String() as the changeFunc error.
+// If the changeFunc returns an error, stop and return the same error.
 //
 // 3. If the changeFunc returns no errors, use the string returned as
 // the new candidate value for the node, and attempt to either create
@@ -855,36 +810,32 @@
 // in the same node), repeat from step 1.  If this procedure fails with any
 // other error, stop and return the error found.
 //
-func (zk *ZooKeeper) RetryChange(path string, flags int, acl []ACL, changeFunc ChangeFunc) (err Error) {
+func (zk *Conn) RetryChange(path string, flags int, acl []ACL, changeFunc ChangeFunc) os.Error {
 	for {
-		oldValue, oldStat, getErr := zk.Get(path)
-		if getErr != nil && getErr.Code() != ZNONODE {
-			err = getErr
-			break
-		}
-		newValue, osErr := changeFunc(oldValue, oldStat)
-		if osErr != nil {
-			return newError(ZSYSTEMERROR, osErr)
-		} else if oldStat == nil {
-			_, err = zk.Create(path, newValue, flags, acl)
-			if err == nil || err.Code() != ZNODEEXISTS {
-				break
+		oldValue, oldStat, err := zk.Get(path)
+		if err != nil && err != ZNONODE {
+			return err
+		}
+		newValue, err := changeFunc(oldValue, oldStat)
+		if err != nil {
+			return err
+		}
+		if oldStat == nil {
+			_, err := zk.Create(path, newValue, flags, acl)
+			if err == nil || err != ZNODEEXISTS {
+				return err
 			}
-		} else if newValue == oldValue {
+			continue
+		}
+		if newValue == oldValue {
 			return nil // Nothing to do.
-		} else {
-			_, err = zk.Set(path, newValue, oldStat.Version())
-			if err == nil {
-				break
-			} else {
-				code := err.Code()
-				if code != ZBADVERSION && code != ZNONODE {
-					break
-				}
-			}
+		}
+		_, err = zk.Set(path, newValue, oldStat.Version())
+		if err == nil || (err != ZBADVERSION && err != ZNONODE) {
+			return err
 		}
 	}
-	return err
+	panic("not reached")
 }
 
 // -----------------------------------------------------------------------
@@ -897,7 +848,7 @@
 // Whenever a *W method is called, it will return a channel which
 // outputs Event values.  Internally, a map is used to maintain references
 // between an unique integer key (the watchId), and the event channel. The
-// watchId is then handed to the C zookeeper library as the watch context,
+// watchId is then handed to the C ZooKeeper library as the watch context,
 // so that we get it back when events happen.  Using an integer key as the
 // watch context rather than a pointer is needed because there's no guarantee
 // that in the future the GC will not move objects around, and also because
@@ -910,13 +861,13 @@
 // Since Cgo doesn't allow calling back into Go, we actually fire a new
 // goroutine the very first time Init is called, and allow it to block
 // in a pthread condition variable within a C function. This condition
-// will only be notified once a zookeeper watch callback appends new
+// will only be notified once a ZooKeeper watch callback appends new
 // entries to the event list.  When this happens, the C function returns
 // and we get back into Go land with the pointer to the watch data,
 // including the watchId and other event details such as type and path.
 
 var watchMutex sync.Mutex
-var watchZooKeepers = make(map[uintptr]*ZooKeeper)
+var watchConns = make(map[uintptr]*Conn)
 var watchCounter uintptr
 var watchLoopCounter int
 
@@ -925,14 +876,14 @@
 // mostly as a debugging and testing aid.
 func CountPendingWatches() int {
 	watchMutex.Lock()
-	count := len(watchZooKeepers)
+	count := len(watchConns)
 	watchMutex.Unlock()
 	return count
 }
 
 // createWatch creates and registers a watch, returning the watch id
 // and channel.
-func (zk *ZooKeeper) createWatch(session bool) (watchId uintptr, watchChannel chan Event) {
+func (zk *Conn) createWatch(session bool) (watchId uintptr, watchChannel chan Event) {
 	buf := 1 // session/watch event
 	if session {
 		buf = 32
@@ -943,7 +894,7 @@
 	watchId = watchCounter
 	watchCounter += 1
 	zk.watchChannels[watchId] = watchChannel
-	watchZooKeepers[watchId] = zk
+	watchConns[watchId] = zk
 	return
 }
 
@@ -951,21 +902,21 @@
 // from ever getting delivered. It shouldn't be used if there's any
 // chance the watch channel is still visible and not closed, since
 // it might mean a goroutine would be blocked forever.
-func (zk *ZooKeeper) forgetWatch(watchId uintptr) {
+func (zk *Conn) forgetWatch(watchId uintptr) {
 	watchMutex.Lock()
 	defer watchMutex.Unlock()
 	zk.watchChannels[watchId] = nil, false
-	watchZooKeepers[watchId] = nil, false
+	watchConns[watchId] = nil, false
 }
 
 // closeAllWatches closes all watch channels for zk.
-func (zk *ZooKeeper) closeAllWatches() {
+func (zk *Conn) closeAllWatches() {
 	watchMutex.Lock()
 	defer watchMutex.Unlock()
 	for watchId, ch := range zk.watchChannels {
 		close(ch)
 		zk.watchChannels[watchId] = nil, false
-		watchZooKeepers[watchId] = nil, false
+		watchConns[watchId] = nil, false
 	}
 }
 
@@ -978,7 +929,7 @@
 	}
 	watchMutex.Lock()
 	defer watchMutex.Unlock()
-	zk, ok := watchZooKeepers[watchId]
+	zk, ok := watchConns[watchId]
 	if !ok {
 		return
 	}
@@ -1010,7 +961,7 @@
 	}
 	if watchId != zk.sessionWatchId {
 		zk.watchChannels[watchId] = nil, false
-		watchZooKeepers[watchId] = nil, false
+		watchConns[watchId] = nil, false
 		close(ch)
 	}
 }

=== renamed file 'gozk_test.go' => 'zookeeper_test.go'
--- gozk_test.go	2011-08-19 01:51:37 +0000
+++ zookeeper_test.go	2011-09-24 08:31:23 +0000
@@ -1,15 +1,15 @@
-package gozk_test
+package zookeeper_test
 
 import (
 	. "launchpad.net/gocheck"
-	"gozk"
+	"launchpad.net/zookeeper"
 	"time"
 )
 
 // This error will be delivered via C errno, since ZK unfortunately
 // only provides the handler back from zookeeper_init().
 func (s *S) TestInitErrorThroughErrno(c *C) {
-	zk, watch, err := gozk.Init("bad-domain-without-port", 5e9)
+	zk, watch, err := zookeeper.Dial("bad-domain-without-port", 5e9)
 	if zk != nil {
 		zk.Close()
 	}
@@ -29,7 +29,7 @@
 }
 
 func (s *S) TestRecvTimeoutInitParameter(c *C) {
-	zk, watch, err := gozk.Init(s.zkAddr, 0)
+	zk, watch, err := zookeeper.Dial(s.zkAddr, 0)
 	c.Assert(err, IsNil)
 	defer zk.Close()
 
@@ -51,38 +51,38 @@
 }
 
 func (s *S) TestSessionWatches(c *C) {
-	c.Assert(gozk.CountPendingWatches(), Equals, 0)
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 0)
 
 	zk1, watch1 := s.init(c)
 	zk2, watch2 := s.init(c)
 	zk3, watch3 := s.init(c)
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 3)
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 3)
 
 	event1 := <-watch1
-	c.Assert(event1.Type, Equals, gozk.EVENT_SESSION)
-	c.Assert(event1.State, Equals, gozk.STATE_CONNECTED)
+	c.Assert(event1.Type, Equals, zookeeper.EVENT_SESSION)
+	c.Assert(event1.State, Equals, zookeeper.STATE_CONNECTED)
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 3)
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 3)
 
 	event2 := <-watch2
-	c.Assert(event2.Type, Equals, gozk.EVENT_SESSION)
-	c.Assert(event2.State, Equals, gozk.STATE_CONNECTED)
+	c.Assert(event2.Type, Equals, zookeeper.EVENT_SESSION)
+	c.Assert(event2.State, Equals, zookeeper.STATE_CONNECTED)
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 3)
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 3)
 
 	event3 := <-watch3
-	c.Assert(event3.Type, Equals, gozk.EVENT_SESSION)
-	c.Assert(event3.State, Equals, gozk.STATE_CONNECTED)
+	c.Assert(event3.Type, Equals, zookeeper.EVENT_SESSION)
+	c.Assert(event3.State, Equals, zookeeper.STATE_CONNECTED)
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 3)
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 3)
 
 	zk1.Close()
-	c.Assert(gozk.CountPendingWatches(), Equals, 2)
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 2)
 	zk2.Close()
-	c.Assert(gozk.CountPendingWatches(), Equals, 1)
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 1)
 	zk3.Close()
-	c.Assert(gozk.CountPendingWatches(), Equals, 0)
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 0)
 }
 
 // Gozk injects a STATE_CLOSED event when zk.Close() is called, right
@@ -95,32 +95,35 @@
 	zk, watch := s.init(c)
 
 	event := <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_SESSION)
-	c.Assert(event.State, Equals, gozk.STATE_CONNECTED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_SESSION)
+	c.Assert(event.State, Equals, zookeeper.STATE_CONNECTED)
 
 	zk.Close()
 	event, ok := <-watch
 	c.Assert(ok, Equals, false)
-	c.Assert(event.Type, Equals, gozk.EVENT_CLOSED)
-	c.Assert(event.State, Equals, gozk.STATE_CLOSED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_CLOSED)
+	c.Assert(event.State, Equals, zookeeper.STATE_CLOSED)
 }
 
 func (s *S) TestEventString(c *C) {
-	var event gozk.Event
-	event = gozk.Event{gozk.EVENT_SESSION, "/path", gozk.STATE_CONNECTED}
+	var event zookeeper.Event
+	event = zookeeper.Event{zookeeper.EVENT_SESSION, "/path", zookeeper.STATE_CONNECTED}
 	c.Assert(event, Matches, "ZooKeeper connected")
-	event = gozk.Event{gozk.EVENT_CREATED, "/path", gozk.STATE_CONNECTED}
+	event = zookeeper.Event{zookeeper.EVENT_CREATED, "/path", zookeeper.STATE_CONNECTED}
 	c.Assert(event, Matches, "ZooKeeper connected; path created: /path")
-	event = gozk.Event{-1, "/path", gozk.STATE_CLOSED}
+	event = zookeeper.Event{-1, "/path", zookeeper.STATE_CLOSED}
 	c.Assert(event, Matches, "ZooKeeper connection closed")
 }
 
-var okTests = []struct{gozk.Event; Ok bool}{
-	{gozk.Event{gozk.EVENT_SESSION, "", gozk.STATE_CONNECTED}, true},
-	{gozk.Event{gozk.EVENT_CREATED, "", gozk.STATE_CONNECTED}, true},
-	{gozk.Event{0, "", gozk.STATE_CLOSED}, false},
-	{gozk.Event{0, "", gozk.STATE_EXPIRED_SESSION}, false},
-	{gozk.Event{0, "", gozk.STATE_AUTH_FAILED}, false},
+var okTests = []struct {
+	zookeeper.Event
+	Ok bool
+}{
+	{zookeeper.Event{zookeeper.EVENT_SESSION, "", zookeeper.STATE_CONNECTED}, true},
+	{zookeeper.Event{zookeeper.EVENT_CREATED, "", zookeeper.STATE_CONNECTED}, true},
+	{zookeeper.Event{0, "", zookeeper.STATE_CLOSED}, false},
+	{zookeeper.Event{0, "", zookeeper.STATE_EXPIRED_SESSION}, false},
+	{zookeeper.Event{0, "", zookeeper.STATE_AUTH_FAILED}, false},
 }
 
 func (s *S) TestEventOk(c *C) {
@@ -156,18 +159,18 @@
 	c.Assert(data, Equals, "")
 	c.Assert(stat, IsNil)
 	c.Assert(err, Matches, "no node")
-	c.Assert(err.Code(), Equals, gozk.ZNONODE)
+	c.Assert(err, Equals, zookeeper.ZNONODE)
 }
 
 func (s *S) TestCreateAndGet(c *C) {
 	zk, _ := s.init(c)
 
-	path, err := zk.Create("/test-", "bababum", gozk.SEQUENCE|gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	path, err := zk.Create("/test-", "bababum", zookeeper.SEQUENCE|zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 	c.Assert(path, Matches, "/test-[0-9]+")
 
 	// Check the error condition from Create().
-	_, err = zk.Create(path, "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err = zk.Create(path, "", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, Matches, "node exists")
 
 	data, _, err := zk.Get(path)
@@ -178,7 +181,7 @@
 func (s *S) TestCreateSetAndGet(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	stat, err := zk.Set("/test", "bababum", -1) // Any version.
@@ -191,13 +194,13 @@
 }
 
 func (s *S) TestGetAndWatch(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 0)
 
 	zk, _ := s.init(c)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
-	_, err := zk.Create("/test", "one", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "one", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	data, stat, watch, err := zk.GetW("/test")
@@ -211,15 +214,15 @@
 	default:
 	}
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 2)
 
 	_, err = zk.Set("/test", "two", -1)
 	c.Assert(err, IsNil)
 
 	event := <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CHANGED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_CHANGED)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
 	data, _, watch, err = zk.GetW("/test")
 	c.Assert(err, IsNil)
@@ -231,50 +234,50 @@
 	default:
 	}
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 2)
 
 	_, err = zk.Set("/test", "three", -1)
 	c.Assert(err, IsNil)
 
 	event = <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CHANGED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_CHANGED)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestGetAndWatchWithError(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 0)
 
 	zk, _ := s.init(c)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
 	_, _, watch, err := zk.GetW("/test")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNONODE)
+	c.Assert(err, Equals, zookeeper.ZNONODE)
 	c.Assert(watch, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestCloseReleasesWatches(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 0)
 
 	zk, _ := s.init(c)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
-	_, err := zk.Create("/test", "one", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "one", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	_, _, _, err = zk.GetW("/test")
 	c.Assert(err, IsNil)
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 2)
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 2)
 
 	zk.Close()
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 0)
+	c.Assert(zookeeper.CountPendingWatches(), Equals, 0)
 }
 
 // By default, the ZooKeeper C client will hang indefinitely if a
@@ -285,7 +288,7 @@
 	c.Assert(err, IsNil)
 	err = zk.Close()
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZCLOSING)
+	c.Assert(err, Equals, zookeeper.ZCLOSING)
 }
 
 func (s *S) TestChildren(c *C) {
@@ -298,17 +301,17 @@
 
 	children, stat, err = zk.Children("/non-existent")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNONODE)
+	c.Assert(err, Equals, zookeeper.ZNONODE)
 	c.Assert(children, Equals, []string{})
-	c.Assert(stat, Equals, nil)
+	c.Assert(stat, IsNil)
 }
 
 func (s *S) TestChildrenAndWatch(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 0)
 
 	zk, _ := s.init(c)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
 	children, stat, watch, err := zk.ChildrenW("/")
 	c.Assert(err, IsNil)
@@ -321,16 +324,16 @@
 	default:
 	}
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 2)
 
-	_, err = zk.Create("/test1", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err = zk.Create("/test1", "", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	event := <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CHILD)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_CHILD)
 	c.Assert(event.Path, Equals, "/")
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
 	children, stat, watch, err = zk.ChildrenW("/")
 	c.Assert(err, IsNil)
@@ -345,57 +348,56 @@
 	default:
 	}
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 2)
 
-	_, err = zk.Create("/test2", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err = zk.Create("/test2", "", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	event = <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CHILD)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_CHILD)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestChildrenAndWatchWithError(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 0)
 
 	zk, _ := s.init(c)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
 	_, stat, watch, err := zk.ChildrenW("/test")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNONODE)
+	c.Assert(err, Equals, zookeeper.ZNONODE)
 	c.Assert(watch, IsNil)
 	c.Assert(stat, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestExists(c *C) {
 	zk, _ := s.init(c)
 
-	stat, err := zk.Exists("/zookeeper")
-	c.Assert(err, IsNil)
-	c.Assert(stat.NumChildren(), Equals, int32(1))
-
-	stat, err = zk.Exists("/non-existent")
+	stat, err := zk.Exists("/non-existent")
 	c.Assert(err, IsNil)
 	c.Assert(stat, IsNil)
+
+	stat, err = zk.Exists("/zookeeper")
+	c.Assert(err, IsNil)
 }
 
 func (s *S) TestExistsAndWatch(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 0)
 
 	zk, _ := s.init(c)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
 	stat, watch, err := zk.ExistsW("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 2)
 
 	select {
 	case <-watch:
@@ -403,62 +405,62 @@
 	default:
 	}
 
-	_, err = zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err = zk.Create("/test", "", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	event := <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CREATED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_CREATED)
 	c.Assert(event.Path, Equals, "/test")
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
 	stat, watch, err = zk.ExistsW("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, NotNil)
 	c.Assert(stat.NumChildren(), Equals, int32(0))
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 2)
 }
 
 func (s *S) TestExistsAndWatchWithError(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 0)
 
 	zk, _ := s.init(c)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
 	stat, watch, err := zk.ExistsW("///")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZBADARGUMENTS)
+	c.Assert(err, Equals, zookeeper.ZBADARGUMENTS)
 	c.Assert(stat, IsNil)
 	c.Assert(watch, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestDelete(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	err = zk.Delete("/test", 5)
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZBADVERSION)
+	c.Assert(err, Equals, zookeeper.ZBADVERSION)
 
 	err = zk.Delete("/test", -1)
 	c.Assert(err, IsNil)
 
 	err = zk.Delete("/test", -1)
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNONODE)
+	c.Assert(err, Equals, zookeeper.ZNONODE)
 }
 
 func (s *S) TestClientIdAndReInit(c *C) {
 	zk1, _ := s.init(c)
 	clientId1 := zk1.ClientId()
 
-	zk2, _, err := gozk.ReInit(s.zkAddr, 5e9, clientId1)
+	zk2, _, err := zookeeper.Redial(s.zkAddr, 5e9, clientId1)
 	c.Assert(err, IsNil)
 	defer zk2.Close()
 	clientId2 := zk2.ClientId()
@@ -471,7 +473,7 @@
 func (s *S) TestExistsWatchOnDataChange(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	_, watch, err := zk.ExistsW("/test")
@@ -483,24 +485,24 @@
 	event := <-watch
 
 	c.Assert(event.Path, Equals, "/test")
-	c.Assert(event.Type, Equals, gozk.EVENT_CHANGED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_CHANGED)
 }
 
 func (s *S) TestACL(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	acl, stat, err := zk.ACL("/test")
 	c.Assert(err, IsNil)
-	c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_ALL))
+	c.Assert(acl, Equals, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(stat, NotNil)
 	c.Assert(stat.Version(), Equals, int32(0))
 
 	acl, stat, err = zk.ACL("/non-existent")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNONODE)
+	c.Assert(err, Equals, zookeeper.ZNONODE)
 	c.Assert(acl, IsNil)
 	c.Assert(stat, IsNil)
 }
@@ -508,32 +510,32 @@
 func (s *S) TestSetACL(c *C) {
 	zk, _ := s.init(c)
 
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err := zk.Create("/test", "", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	err = zk.SetACL("/test", gozk.WorldACL(gozk.PERM_ALL), 5)
+	err = zk.SetACL("/test", zookeeper.WorldACL(zookeeper.PERM_ALL), 5)
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZBADVERSION)
+	c.Assert(err, Equals, zookeeper.ZBADVERSION)
 
-	err = zk.SetACL("/test", gozk.WorldACL(gozk.PERM_READ), -1)
+	err = zk.SetACL("/test", zookeeper.WorldACL(zookeeper.PERM_READ), -1)
 	c.Assert(err, IsNil)
 
 	acl, _, err := zk.ACL("/test")
 	c.Assert(err, IsNil)
-	c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_READ))
+	c.Assert(acl, Equals, zookeeper.WorldACL(zookeeper.PERM_READ))
 }
 
 func (s *S) TestAddAuth(c *C) {
 	zk, _ := s.init(c)
 
-	acl := []gozk.ACL{{gozk.PERM_READ, "digest", "joe:enQcM3mIEHQx7IrPNStYBc0qfs8="}}
+	acl := []zookeeper.ACL{{zookeeper.PERM_READ, "digest", "joe:enQcM3mIEHQx7IrPNStYBc0qfs8="}}
 
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, acl)
+	_, err := zk.Create("/test", "", zookeeper.EPHEMERAL, acl)
 	c.Assert(err, IsNil)
 
 	_, _, err = zk.Get("/test")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
+	c.Assert(err, Equals, zookeeper.ZNOAUTH)
 
 	err = zk.AddAuth("digest", "joe:passwd")
 	c.Assert(err, IsNil)
@@ -543,36 +545,36 @@
 }
 
 func (s *S) TestWatchOnReconnection(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 0)
 
 	zk, session := s.init(c)
 
 	event := <-session
-	c.Assert(event.Type, Equals, gozk.EVENT_SESSION)
-	c.Assert(event.State, Equals, gozk.STATE_CONNECTED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_SESSION)
+	c.Assert(event.State, Equals, zookeeper.STATE_CONNECTED)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
 	stat, watch, err := zk.ExistsW("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 2)
 
 	s.StopZK()
 	time.Sleep(2e9)
-	s.StartZK()
+	s.StartZK(c)
 
 	// The session channel should receive the reconnection notification,
 	select {
 	case event := <-session:
-		c.Assert(event.State, Equals, gozk.STATE_CONNECTING)
+		c.Assert(event.State, Equals, zookeeper.STATE_CONNECTING)
 	case <-time.After(3e9):
 		c.Fatal("Session watch didn't fire")
 	}
 	select {
 	case event := <-session:
-		c.Assert(event.State, Equals, gozk.STATE_CONNECTED)
+		c.Assert(event.State, Equals, zookeeper.STATE_CONNECTED)
 	case <-time.After(3e9):
 		c.Fatal("Session watch didn't fire")
 	}
@@ -585,40 +587,40 @@
 	}
 
 	// And it should still work.
-	_, err = zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err = zk.Create("/test", "", zookeeper.EPHEMERAL, zookeeper.WorldACL(zookeeper.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	event = <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CREATED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_CREATED)
 	c.Assert(event.Path, Equals, "/test")
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestWatchOnSessionExpiration(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 0)
 
 	zk, session := s.init(c)
 
 	event := <-session
-	c.Assert(event.Type, Equals, gozk.EVENT_SESSION)
-	c.Assert(event.State, Equals, gozk.STATE_CONNECTED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_SESSION)
+	c.Assert(event.State, Equals, zookeeper.STATE_CONNECTED)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 
 	stat, watch, err := zk.ExistsW("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 2)
 
 	// Use expiration trick described in the FAQ.
 	clientId := zk.ClientId()
-	zk2, session2, err := gozk.ReInit(s.zkAddr, 5e9, clientId)
+	zk2, session2, err := zookeeper.Redial(s.zkAddr, 5e9, clientId)
 
 	for event := range session2 {
 		c.Log("Event from overlapping session: ", event)
-		if event.State == gozk.STATE_CONNECTED {
+		if event.State == zookeeper.STATE_CONNECTED {
 			// Wait for zk to process the connection.
 			// Not reliable without this. :-(
 			time.Sleep(1e9)
@@ -627,21 +629,21 @@
 	}
 	for event := range session {
 		c.Log("Event from primary session: ", event)
-		if event.State == gozk.STATE_EXPIRED_SESSION {
+		if event.State == zookeeper.STATE_EXPIRED_SESSION {
 			break
 		}
 	}
 
 	select {
 	case event := <-watch:
-		c.Assert(event.State, Equals, gozk.STATE_EXPIRED_SESSION)
+		c.Assert(event.State, Equals, zookeeper.STATE_EXPIRED_SESSION)
 	case <-time.After(3e9):
 		c.Fatal("Watch event didn't fire")
 	}
 
 	event = <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CLOSED)
-	c.Assert(event.State, Equals, gozk.STATE_CLOSED)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_CLOSED)
+	c.Assert(event.State, Equals, zookeeper.STATE_CLOSED)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zookeeper.CountPendingWatches(), Equals, 1)
 }