Merge lp:~rogpeppe/gozk/update-server-interface into lp:~juju/gozk/trunk

[Roger Peppe]

Updated server API.

[lp:~rogpeppe/gozk/update-server-interface]

24. By Roger Peppe on 2011-09-26

Fix zookeeper spelling

[Gustavo Niemeyer (niemeyer)]

Great stuff here Rog, thanks!

Some comments:

[1]

-// The ZooKepeer installation directory is specified by installedDir.
+// The ZooKeeper installation directory is specified by installDir.

installDir feels like a strange name in this context. I agree installedDir
isn't great either, but the new one gives a wrong impression about what
it means.. we're not installing anything there.

Let's use something like zkDir instead.

[2]

+func CreateServer(port int, runDir, installDir string) (*Server, os.Error) {
(...)
+func AttachServer(runDir string) (*Server, os.Error) {

The organization inside these is looking very nice.

[3]

+func (srv *Server) getServerProcess() (*os.Process, os.Error) {
(...)
+ return os.FindProcess(pid)

FindProcess does nothing on Unix. We can run at least a Signal 0 against
the pid to tell if it exists or not.

[4]

+ if p != nil {
+ p.Release()
+ }
+ return fmt.Errorf("ZooKeeper server may already be running (remove %q to clear)", srv.path("pid.txt"))

The recommendation here is a bit strange. If the process is actually running,
removing the pid file will allow a second server to be started in parallel,
which is not nice.

I suggest just saying "ZooKeeper server seems to be running already", which
is a bit more true given that we'll be checking the pid as per the point above.
Then, the developer can run Stop() on it if he feels like stopping it, or
do whatever else out of band if he doesn't want to use the interface, but
then it's his responsibility to check for background processes, etc.

[5]

+// Stop kills the ZooKeeper server. It is a no-op if it is already running.

The second part is reversed, and reads a bit hard.

Suggestion: It does nothing if not running.

Also, please mention that the data is preserved, and that the server can
be restarted. "kill" may feel like otherwise.

[6]

+// Destroy stops the ZooKeeper server, and then removes its run
+// directory and all its contents.

s/and all its contents././

Removing the directory means removing its contents necessarily.

[7]

+func (srv *Server) writeInstallDir() os.Error {
+ return ioutil.WriteFile(srv.path("installdir.txt"), []byte(srv.installDir+"\n"), 0666)

These functions and filename should be renamed in sync to the first point.

[8]

+ if data[len(data)-1] == '\n' {
+ data = data[0 : len(data)-1]
+ }
+ srv.installDir = string(data)

srv.zkDir = string(bytes.TrimSpace(data))

[9]

+ s.zkTestRoot = c.MkDir() + "/zk"
+ port := 21812
+ s.zkAddr = fmt.Sprint("localhost:", port)
+
+ s.zkServer, err = zk.CreateServer(port, s.zkTestRoot, "")
  if err != nil {
   c.Fatal("Cannot set up server environment: ", err)
  }
- s.StartZK(c)
+ err = s.zkServer.Start()
+ if err != nil {
+ c.Fatal("Cannot start ZooKeeper server: ", err)
+ }

This is awesome! Thanks!

review: Approve

[Gustavo Niemeyer (niemeyer)]

[10]

+// exist, it assumes the server is not running and returns (nil, nil).

This interface is strange, and can easily lead to bugs since it's not an idiom in Go.
I'd never assume p is nil if err == nil. Please return an error if p == nil.

[Roger Peppe (rogpeppe)]

On 5 October 2011 15:34, Gustavo Niemeyer <email address hidden> wrote:
> Review: Approve
>
> Great stuff here Rog, thanks!
>
> Some comments:
>
>
> [1]
>
> -// The ZooKepeer installation directory is specified by installedDir.
> +// The ZooKeeper installation directory is specified by installDir.
>
> installDir feels like a strange name in this context. I agree installedDir
> isn't great either, but the new one gives a wrong impression about what
> it means.. we're not installing anything there.
>
> Let's use something like zkDir instead.

done.

> +func (srv *Server) getServerProcess() (*os.Process, os.Error) {
> (...)
> +       return os.FindProcess(pid)
>
> FindProcess does nothing on Unix.  We can run at least a Signal 0 against
> the pid to tell if it exists or not.

ok, as discussed i'll just not bother about the race.

> [5]
>
> +// Stop kills the ZooKeeper server. It is a no-op if it is already running.
>
> The second part is reversed, and reads a bit hard.
>
> Suggestion: It does nothing if not running.

better. my text was just wrong. done.
>
> Also, please mention that the data is preserved, and that the server can
> be restarted. "kill" may feel like otherwise.

done.

>
>
> [6]
>
> +// Destroy stops the ZooKeeper server, and then removes its run
> +// directory and all its contents.
>
> s/and all its contents././
>
> Removing the directory means removing its contents necessarily.

done.

> [7]
>
> +func (srv *Server) writeInstallDir() os.Error {
> +       return ioutil.WriteFile(srv.path("installdir.txt"), []byte(srv.installDir+"\n"), 0666)
>
> These functions and filename should be renamed in sync to the first point.

i'm not sure what you mean here.

> +       if data[len(data)-1] == '\n' {
> +               data = data[0 : len(data)-1]
> +       }
> +       srv.installDir = string(data)
>
> srv.zkDir = string(bytes.TrimSpace(data))

really? this code will have written the data inside the file, so there
should be no
extra space added. it's legal (ok it's pretty unusual) for a file name to
end in a space, and calling TrimSpace would break that.

[lp:~rogpeppe/gozk/update-server-interface]

25. By Roger Peppe on 2011-10-06

Added reattach_test.go to test server reattaching.
Service-related methods now get their own file.

[Roger Peppe (rogpeppe)]

On 5 October 2011 15:49, Gustavo Niemeyer <email address hidden> wrote:
> [10]
>
>
> +// exist, it assumes the server is not running and returns (nil, nil).
>
> This interface is strange, and can easily lead to bugs since it's not an idiom in Go.
> I'd never assume p is nil if err == nil. Please return an error if p == nil.

i've changed this, but for reference, i've just noticed a similar example
in your code, in Exists:

 // 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.

it's for a very similar reason that i returned a nil process and nil error from
Process when there was no process to be found.

[Gustavo Niemeyer (niemeyer)]

Good changes overall, thanks. Some follow ups:

[7]

You've renamed installDir to zkDir. Let's rename functions and filenames
to match that as well (zkdir.txt, writeZkDir, etc)

[8]

Ok, but this logic is wrong because it doesn't check the length and could
panic.

Alright, so instead of doing either of those things, please just don't append
a '\n' at the end, so we can just string(data) straight. This is already
being done for pid.txt, and sounds like a sane approach.

[10]

Indeed, but that feels like a slightly different case because the method
is already a question (does it exist?), so the fact it doesn't exist
is an answer to that question rather than an error.

If the method was named something like Stat, it should definitely be an
error rather than simply an empty stat.

[11]

+// ServerCommand returns the command used to start the
+// ZooKeeper server. It is provided for debugging and testing
+// purposes only.
+func (srv *Server) command() ([]string, os.Error) {

s/ServerCommand/command/
s/It is provided.*//

[12]

+// NetworkPort returns the TCP port number that
+// the server is configured for.

s/NetworkPort/networkPort/

[13]

+// This file defines methods on Server that deal with starting
+// and stopping the ZooKeeper service. They are independent of ZooKeeper
+// itself, and may be factored out at a later date.

Please merge this on server.go. As pointed out in the other review and obvious
through out the code, this is really specific to ZooKeeper. If/when we do
refactor this out to generalize, we'll have to reorganize anyway.

[14]

+var ErrNotRunning = os.NewError("process not running")

I'm not a big fan of the Err* convention. Makes for an ugly name with typing
information embedded on it. Some packages do use it, but thankfully it's
also not strictly followed in the Go standard library either.

I'd appreciate renaming this to NotRunning instead. zk.NotRunning seems
pretty good.

[15]

+// Process returns a Process referring to the running server from
+// where it's been stored in pid.txt. If the file does not
+// exist, or it cannot find the process, it returns the error
+// ErrNotRunning.

Where the pid is stored is an implementation detail that can
change. We don't have to document that for now.

[16]

+// getProcess gets a Process from a pid and check that the

s/check/checks/

[17]

+ if e, ok := err.(*os.SyscallError); ok && e.Errno == os.ECHILD || err == os.ECHILD {

Ugh. I hope we get that cleaned in Go itself with the suggested changes for 1.

[18]

+ // is to poll until it exits. If the process has taken longer than
+ // a second to exit, then it's probably not going to.

This is very optimistic. A process can easily take more than a second to exit. If
this is an edge case and there's a reason to wait at all (dir content, etc), then
let's wait a bit longer, like 10 seconds for instance.

[19]

+// cases to test:
+// child server, stopped normally; reattach, start
+// non-direct child server, killed abnormally; reattach, start (->error), remove pid.txt; start
+// non-direct child server, still running; reattach, start (->error), stop, start
+// child server, still running; reattach,...

review: Needs Fixing

[Roger Peppe (rogpeppe)]

PTAL

On 7 October 2011 16:58, Gustavo Niemeyer <email address hidden> wrote:
> [7]
>
> You've renamed installDir to zkDir. Let's rename functions and filenames
> to match that as well (zkdir.txt, writeZkDir, etc)

done

>
> [8]
>
> Ok, but this logic is wrong because it doesn't check the length and could
> panic.
>
> Alright, so instead of doing either of those things, please just don't append
> a '\n' at the end, so we can just string(data) straight. This is already
> being done for pid.txt, and sounds like a sane approach.

done

> [11]
>
> +// ServerCommand returns the command used to start the
> +// ZooKeeper server. It is provided for debugging and testing
> +// purposes only.
> +func (srv *Server) command() ([]string, os.Error) {
>
> s/ServerCommand/command/
> s/It is provided.*//

given that it's not external any more, that "debugging and testing"
remark isn't necessary now.

> [12]
>
> +// NetworkPort returns the TCP port number that
> +// the server is configured for.
>
> s/NetworkPort/networkPort/
>
> [13]
>
> +// This file defines methods on Server that deal with starting
> +// and stopping the ZooKeeper service. They are independent of ZooKeeper
> +// itself, and may be factored out at a later date.
>
> Please merge this on server.go. As pointed out in the other review and obvious
> through out the code, this is really specific to ZooKeeper. If/when we do
> refactor this out to generalize, we'll have to reorganize anyway.

i can do this, but given that the dependencies of the two files
are mostly different (only fmt, ioutil and os in common), and there's
very little interlink between the two, i think it makes sense to keep
them as two different files - i think it makes the code easier to read.
perhaps "runserver.go" might be a better name than "service.go" though.
i've done that for the time being. that said, it's no big deal.

> [14]
>
> +var ErrNotRunning = os.NewError("process not running")
>
> I'm not a big fan of the Err* convention. Makes for an ugly name with typing
> information embedded on it. Some packages do use it, but thankfully it's
> also not strictly followed in the Go standard library either.
>
> I'd appreciate renaming this to NotRunning instead. zk.NotRunning seems
> pretty good.

ok.

>
> [15]
>
> +// Process returns a Process referring to the running server from
> +// where it's been stored in pid.txt. If the file does not
> +// exist, or it cannot find the process, it returns the error
> +// ErrNotRunning.
>
> Where the pid is stored is an implementation detail that can
> change. We don't have to document that for now.
>
> [16]
>
> +// getProcess gets a Process from a pid and check that the
>
> s/check/checks/

done

> [18]
>
> +               // is to poll until it exits. If the process has taken longer than
> +               // a second to exit, then it's probably not going to.
>
> This is very optimistic. A process can easily take more than a second to exit. If
> this is an edge case and there's a reason to wait at all (dir content, etc), then
> let's wait a bit longer, like 10 seconds for instance.

ok. given that we're killing the server with SIGKILL, it's not going to
have any chance to take ages to c...

[lp:~rogpeppe/gozk/update-server-interface]

26. By Roger Peppe on 2011-10-10

Fixes as per review.

=== modified file 'Makefile'
--- Makefile	2011-08-03 01:56:58 +0000
+++ Makefile	2011-10-10 13:55:28 +0000
@@ -2,10 +2,14 @@
 
 all: package
 
-TARG=gozk
+TARG=launchpad.net/gozk/zk
 
+GOFILES=\
+	server.go\
+	runserver.go\
+	
 CGOFILES=\
-	gozk.go\
+	zk.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-10-10 13:55:28 +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!")
+	}
 }
-

=== added file 'reattach_test.go'
--- reattach_test.go	1970-01-01 00:00:00 +0000
+++ reattach_test.go	2011-10-10 13:55:28 +0000
@@ -0,0 +1,198 @@
+package zk_test
+
+import (
+	"bufio"
+	. "launchpad.net/gocheck"
+	"launchpad.net/gozk/zk"
+	"exec"
+	"flag"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+var reattach = flag.Bool("zktest.reattach", false, "internal flag used for testing")
+var reattachRunDir = flag.String("zktest.rundir", "", "internal flag used for testing")
+var reattachAbnormalStop = flag.Bool("zktest.stop", false, "internal flag used for testing")
+
+// This is the reentrancy point for testing ZooKeeper servers
+// started by processes that are not direct children of the
+// testing process. This test always succeeds - the status
+// will be written to stdout and read by indirectServer.
+func TestStartNonChildServer(t *testing.T) {
+	if !*reattach {
+		// not re-entrant, so ignore this test.
+		return
+	}
+	err := startServer(*reattachRunDir, *reattachAbnormalStop)
+	if err != nil {
+		fmt.Printf("error:%v\n", err)
+		return
+	}
+	fmt.Printf("done\n")
+}
+
+func (s *S) startServer(c *C, abort bool) {
+	err := startServer(s.zkTestRoot, abort)
+	c.Assert(err, IsNil)
+}
+
+// startServerIndirect starts a ZooKeeper server that is not
+// a direct child of the current process. If abort is true,
+// the server will be started and then terminated abnormally.
+func (s *S) startServerIndirect(c *C, abort bool) {
+	if len(os.Args) == 0 {
+		c.Fatal("Cannot find self executable name")
+	}
+	cmd := exec.Command(
+		os.Args[0],
+		"-zktest.reattach",
+		"-zktest.rundir", s.zkTestRoot,
+		"-zktest.stop=", fmt.Sprint(abort),
+		"-test.run", "StartNonChildServer",
+	)
+	r, err := cmd.StdoutPipe()
+	c.Assert(err, IsNil)
+	defer r.Close()
+	if err := cmd.Start(); err != nil {
+		c.Fatalf("cannot start re-entrant gotest process: %v", err)
+	}
+	defer cmd.Wait()
+	bio := bufio.NewReader(r)
+	for {
+		line, err := bio.ReadSlice('\n')
+		if err != nil {
+			c.Fatalf("indirect server status line not found: %v", err)
+		}
+		s := string(line)
+		if strings.HasPrefix(s, "error:") {
+			c.Fatalf("indirect server error: %s", s[len("error:"):])
+		}
+		if s == "done\n" {
+			return
+		}
+	}
+	panic("not reached")
+}
+
+// startServer starts a ZooKeeper server, and terminates it abnormally
+// if abort is true.
+func startServer(runDir string, abort bool) os.Error {
+	srv, err := zk.AttachServer(runDir)
+	if err != nil {
+		return fmt.Errorf("cannot attach to server at %q: %v", runDir, err)
+	}
+	if err := srv.Start(); err != nil {
+		return fmt.Errorf("cannot start server: %v", err)
+	}
+	if abort {
+		// Give it time to start up, then kill the server process abnormally,
+		// leaving the pid.txt file behind.
+		time.Sleep(0.5e9)
+		p, err := srv.Process()
+		if err != nil {
+			return fmt.Errorf("cannot get server process: %v", err)
+		}
+		defer p.Release()
+		if err := p.Kill(); err != nil {
+			return fmt.Errorf("cannot kill server process: %v", err)
+		}
+	}
+	return nil
+}
+
+func (s *S) checkCookie(c *C) {
+	conn, watch, err := zk.Dial(s.zkAddr, 5e9)
+	c.Assert(err, IsNil)
+
+	e, ok := <-watch
+	c.Assert(ok, Equals, true)
+	c.Assert(e.Ok(), Equals, true)
+
+	c.Assert(err, IsNil)
+	cookie, _, err := conn.Get("/testAttachCookie")
+	c.Assert(err, IsNil)
+	c.Assert(cookie, Equals, "testAttachCookie")
+	conn.Close()
+}
+
+// cases to test:
+// child server, stopped normally; reattach, start
+// non-direct child server, killed abnormally; reattach, start (->error), remove pid.txt; start
+// non-direct child server, still running; reattach, start (->error), stop, start
+// child server, still running; reattach, start (-> error)
+// child server, still running; reattach, stop, start.
+// non-direct child server, still running; reattach, stop, start.
+func (s *S) TestAttachServer(c *C) {
+	// Create a cookie so that we know we are reattaching to the same instance.
+	conn, _ := s.init(c)
+	_, err := conn.Create("/testAttachCookie", "testAttachCookie", 0, zk.WorldACL(zk.PERM_ALL))
+	c.Assert(err, IsNil)
+	s.checkCookie(c)
+	s.zkServer.Stop()
+	s.zkServer = nil
+
+	s.testAttachServer(c, (*S).startServer)
+	s.testAttachServer(c, (*S).startServerIndirect)
+	s.testAttachServerAbnormalTerminate(c, (*S).startServer)
+	s.testAttachServerAbnormalTerminate(c, (*S).startServerIndirect)
+
+	srv, err := zk.AttachServer(s.zkTestRoot)
+	c.Assert(err, IsNil)
+
+	s.zkServer = srv
+	err = s.zkServer.Start()
+	c.Assert(err, IsNil)
+
+	conn, _ = s.init(c)
+	err = conn.Delete("/testAttachCookie", -1)
+	c.Assert(err, IsNil)
+}
+
+func (s *S) testAttachServer(c *C, start func(*S, *C, bool)) {
+	start(s, c, false)
+
+	s.checkCookie(c)
+
+	// try attaching to it while it is still running - it should fail.
+	srv, err := zk.AttachServer(s.zkTestRoot)
+	c.Assert(err, IsNil)
+
+	err = srv.Start()
+	c.Assert(err, NotNil)
+
+	// stop it and then start it again - it should succeed.
+	err = srv.Stop()
+	c.Assert(err, IsNil)
+
+	err = srv.Start()
+	c.Assert(err, IsNil)
+
+	s.checkCookie(c)
+
+	err = srv.Stop()
+	c.Assert(err, IsNil)
+}
+
+func (s *S) testAttachServerAbnormalTerminate(c *C, start func(*S, *C, bool)) {
+	start(s, c, true)
+
+	// try attaching to it and starting - it should fail, because pid.txt
+	// won't have been removed.
+	srv, err := zk.AttachServer(s.zkTestRoot)
+	c.Assert(err, IsNil)
+	err = srv.Start()
+	c.Assert(err, NotNil)
+
+	// stopping it should bring things back to normal.
+	err = srv.Stop()
+	c.Assert(err, IsNil)
+	err = srv.Start()
+	c.Assert(err, IsNil)
+
+	s.checkCookie(c)
+	err = srv.Stop()
+	c.Assert(err, IsNil)
+}

=== modified file 'retry_test.go'
--- retry_test.go	2011-08-19 01:51:37 +0000
+++ retry_test.go	2011-10-10 13:55:28 +0000
@@ -1,42 +1,41 @@
-package gozk_test
+package zk_test
 
 import (
 	. "launchpad.net/gocheck"
-	"gozk"
+	"launchpad.net/gozk/zk"
 	"os"
 )
 
 func (s *S) TestRetryChangeCreating(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	err := zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err := conn.RetryChange("/test", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL),
+		func(data string, stat *zk.Stat) (string, os.Error) {
 			c.Assert(data, Equals, "")
 			c.Assert(stat, IsNil)
 			return "new", nil
 		})
 	c.Assert(err, IsNil)
 
-	data, stat, err := zk.Get("/test")
+	data, stat, err := conn.Get("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, NotNil)
 	c.Assert(stat.Version(), Equals, int32(0))
 	c.Assert(data, Equals, "new")
 
-	acl, _, err := zk.ACL("/test")
+	acl, _, err := conn.ACL("/test")
 	c.Assert(err, IsNil)
-	c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_ALL))
+	c.Assert(acl, Equals, zk.WorldACL(zk.PERM_ALL))
 }
 
 func (s *S) TestRetryChangeSetting(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_ALL))
+	_, err := conn.Create("/test", "old", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	err = zk.RetryChange("/test", gozk.EPHEMERAL, []gozk.ACL{},
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err = conn.RetryChange("/test", zk.EPHEMERAL, []zk.ACL{},
+		func(data string, stat *zk.Stat) (string, os.Error) {
 			c.Assert(data, Equals, "old")
 			c.Assert(stat, NotNil)
 			c.Assert(stat.Version(), Equals, int32(0))
@@ -44,27 +43,26 @@
 		})
 	c.Assert(err, IsNil)
 
-	data, stat, err := zk.Get("/test")
+	data, stat, err := conn.Get("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, NotNil)
 	c.Assert(stat.Version(), Equals, int32(1))
 	c.Assert(data, Equals, "brand new")
 
 	// ACL was unchanged by RetryChange().
-	acl, _, err := zk.ACL("/test")
+	acl, _, err := conn.ACL("/test")
 	c.Assert(err, IsNil)
-	c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_ALL))
+	c.Assert(acl, Equals, zk.WorldACL(zk.PERM_ALL))
 }
 
 func (s *S) TestRetryChangeUnchangedValueDoesNothing(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_ALL))
+	_, err := conn.Create("/test", "old", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	err = zk.RetryChange("/test", gozk.EPHEMERAL, []gozk.ACL{},
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err = conn.RetryChange("/test", zk.EPHEMERAL, []zk.ACL{},
+		func(data string, stat *zk.Stat) (string, os.Error) {
 			c.Assert(data, Equals, "old")
 			c.Assert(stat, NotNil)
 			c.Assert(stat.Version(), Equals, int32(0))
@@ -72,7 +70,7 @@
 		})
 	c.Assert(err, IsNil)
 
-	data, stat, err := zk.Get("/test")
+	data, stat, err := conn.Get("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, NotNil)
 	c.Assert(stat.Version(), Equals, int32(0)) // Unchanged!
@@ -80,14 +78,14 @@
 }
 
 func (s *S) TestRetryChangeConflictOnCreate(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	changeFunc := func(data string, stat gozk.Stat) (string, os.Error) {
+	changeFunc := func(data string, stat *zk.Stat) (string, os.Error) {
 		switch data {
 		case "":
 			c.Assert(stat, IsNil)
-			_, err := zk.Create("/test", "conflict", gozk.EPHEMERAL,
-				gozk.WorldACL(gozk.PERM_ALL))
+			_, err := conn.Create("/test", "conflict", zk.EPHEMERAL,
+				zk.WorldACL(zk.PERM_ALL))
 			c.Assert(err, IsNil)
 			return "<none> => conflict", nil
 		case "conflict":
@@ -100,11 +98,10 @@
 		return "can't happen", nil
 	}
 
-	err := zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
-		changeFunc)
+	err := conn.RetryChange("/test", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL), changeFunc)
 	c.Assert(err, IsNil)
 
-	data, stat, err := zk.Get("/test")
+	data, stat, err := conn.Get("/test")
 	c.Assert(err, IsNil)
 	c.Assert(data, Equals, "conflict => new")
 	c.Assert(stat, NotNil)
@@ -112,18 +109,17 @@
 }
 
 func (s *S) TestRetryChangeConflictOnSetDueToChange(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_ALL))
+	_, err := conn.Create("/test", "old", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	changeFunc := func(data string, stat gozk.Stat) (string, os.Error) {
+	changeFunc := func(data string, stat *zk.Stat) (string, os.Error) {
 		switch data {
 		case "old":
 			c.Assert(stat, NotNil)
 			c.Assert(stat.Version(), Equals, int32(0))
-			_, err := zk.Set("/test", "conflict", 0)
+			_, err := conn.Set("/test", "conflict", 0)
 			c.Assert(err, IsNil)
 			return "old => new", nil
 		case "conflict":
@@ -136,10 +132,10 @@
 		return "can't happen", nil
 	}
 
-	err = zk.RetryChange("/test", gozk.EPHEMERAL, []gozk.ACL{}, changeFunc)
+	err = conn.RetryChange("/test", zk.EPHEMERAL, []zk.ACL{}, changeFunc)
 	c.Assert(err, IsNil)
 
-	data, stat, err := zk.Get("/test")
+	data, stat, err := conn.Get("/test")
 	c.Assert(err, IsNil)
 	c.Assert(data, Equals, "conflict => new")
 	c.Assert(stat, NotNil)
@@ -147,18 +143,17 @@
 }
 
 func (s *S) TestRetryChangeConflictOnSetDueToDelete(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_ALL))
+	_, err := conn.Create("/test", "old", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	changeFunc := func(data string, stat gozk.Stat) (string, os.Error) {
+	changeFunc := func(data string, stat *zk.Stat) (string, os.Error) {
 		switch data {
 		case "old":
 			c.Assert(stat, NotNil)
 			c.Assert(stat.Version(), Equals, int32(0))
-			err := zk.Delete("/test", 0)
+			err := conn.Delete("/test", 0)
 			c.Assert(err, IsNil)
 			return "old => <deleted>", nil
 		case "":
@@ -170,55 +165,53 @@
 		return "can't happen", nil
 	}
 
-	err = zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_READ),
-		changeFunc)
+	err = conn.RetryChange("/test", zk.EPHEMERAL, zk.WorldACL(zk.PERM_READ), changeFunc)
 	c.Assert(err, IsNil)
 
-	data, stat, err := zk.Get("/test")
+	data, stat, err := conn.Get("/test")
 	c.Assert(err, IsNil)
 	c.Assert(data, Equals, "<deleted> => new")
 	c.Assert(stat, NotNil)
 	c.Assert(stat.Version(), Equals, int32(0))
 
 	// Should be the new ACL.
-	acl, _, err := zk.ACL("/test")
+	acl, _, err := conn.ACL("/test")
 	c.Assert(err, IsNil)
-	c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_READ))
+	c.Assert(acl, Equals, zk.WorldACL(zk.PERM_READ))
 }
 
 func (s *S) TestRetryChangeErrorInCallback(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	err := zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
-		func(data string, stat gozk.Stat) (string, os.Error) {
+	err := conn.RetryChange("/test", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL),
+		func(data string, stat *zk.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")
+	stat, err := conn.Exists("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, IsNil)
 }
 
 func (s *S) TestRetryChangeFailsReading(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_WRITE)) // Write only!
+	// Write only!
+	_, err := conn.Create("/test", "old", zk.EPHEMERAL, zk.WorldACL(zk.PERM_WRITE))
 	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 = conn.RetryChange("/test", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL),
+		func(data string, stat *zk.Stat) (string, os.Error) {
 			called = true
 			return "", nil
 		})
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
+	c.Assert(err, Equals, zk.ZNOAUTH)
 
-	stat, err := zk.Exists("/test")
+	stat, err := conn.Exists("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, NotNil)
 	c.Assert(stat.Version(), Equals, int32(0))
@@ -227,22 +220,21 @@
 }
 
 func (s *S) TestRetryChangeFailsSetting(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_READ)) // Read only!
+	// Read only!
+	_, err := conn.Create("/test", "old", zk.EPHEMERAL, zk.WorldACL(zk.PERM_READ))
 	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 = conn.RetryChange("/test", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL),
+		func(data string, stat *zk.Stat) (string, os.Error) {
 			called = true
 			return "", nil
 		})
-	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
+	c.Assert(err, Equals, zk.ZNOAUTH)
 
-	stat, err := zk.Exists("/test")
+	stat, err := conn.Exists("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, NotNil)
 	c.Assert(stat.Version(), Equals, int32(0))
@@ -251,23 +243,22 @@
 }
 
 func (s *S) TestRetryChangeFailsCreating(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	_, err := zk.Create("/test", "old", gozk.EPHEMERAL,
-		gozk.WorldACL(gozk.PERM_READ)) // Read only!
+	// Read only!
+	_, err := conn.Create("/test", "old", zk.EPHEMERAL, zk.WorldACL(zk.PERM_READ))
 	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 = conn.RetryChange("/test/sub", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL),
+		func(data string, stat *zk.Stat) (string, os.Error) {
 			called = true
 			return "", nil
 		})
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
+	c.Assert(err, Equals, zk.ZNOAUTH)
 
-	stat, err := zk.Exists("/test/sub")
+	stat, err := conn.Exists("/test/sub")
 	c.Assert(err, IsNil)
 	c.Assert(stat, IsNil)
 

=== added file 'runserver.go'
--- runserver.go	1970-01-01 00:00:00 +0000
+++ runserver.go	2011-10-10 13:55:28 +0000
@@ -0,0 +1,168 @@
+package zk
+
+// This file defines methods on Server that deal with starting
+// and stopping the ZooKeeper service. They are independent of ZooKeeper
+// itself, and may be factored out at a later date.
+
+import (
+	"exec"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strconv"
+	"time"
+)
+
+var NotRunning = os.NewError("process not running")
+
+// Process returns a Process referring to the running server from
+// where it's been stored in pid.txt. If the file does not
+// exist, or it cannot find the process, it returns the error
+// NotRunning.
+func (srv *Server) Process() (*os.Process, os.Error) {
+	data, err := ioutil.ReadFile(srv.path("pid.txt"))
+	if err != nil {
+		if err, ok := err.(*os.PathError); ok && err.Error == os.ENOENT {
+			return nil, NotRunning
+		}
+		return nil, err
+	}
+	pid, err := strconv.Atoi(string(data))
+	if err != nil {
+		return nil, os.NewError("bad process id found in pid.txt")
+	}
+	return getProcess(pid)
+}
+
+// getProcess gets a Process from a pid and checks that the
+// process is actually running. If the process
+// is not running, then getProcess returns a nil
+// Process and the error NotRunning.
+func getProcess(pid int) (*os.Process, os.Error) {
+	p, err := os.FindProcess(pid)
+	if err != nil {
+		return nil, err
+	}
+
+	// try to check if the process is actually running by sending
+	// it signal 0.
+	err = p.Signal(os.UnixSignal(0))
+	if err == nil {
+		return p, nil
+	}
+	if err, ok := err.(os.Errno); ok && err == os.ESRCH {
+		return nil, NotRunning
+	}
+	return nil, os.NewError("server running but inaccessible")
+}
+
+// Start starts the ZooKeeper server.
+// It returns an error if the server is already running.
+func (srv *Server) Start() os.Error {
+	if err := srv.checkAvailability(); err != nil {
+		return err
+	}
+	p, err := srv.Process()
+	if err == nil || err != NotRunning {
+		if p != nil {
+			p.Release()
+		}
+		return os.NewError("server is already running")
+	}
+
+	if _, err := os.Stat(srv.path("pid.txt")); err == nil {
+		// Thre pid.txt file still exists although server is not running.
+		// Remove it so it can be re-created.
+		// This leads to a race: if two processes are both
+		// calling Start, one might remove the file the other
+		// has just created, leading to a situation where
+		// pid.txt describes the wrong server process.
+		// We ignore that possibility for now.
+		// TODO use syscall.Flock?
+		if err := os.Remove(srv.path("pid.txt")); err != nil {
+			return fmt.Errorf("cannot remove pid.txt: %v", err)
+		}
+	}
+
+	// Open the pid file before starting the process so that if we get two
+	// programs trying to concurrently start a server on the same directory
+	// at the same time, only one should succeed.
+	pidf, err := os.OpenFile(srv.path("pid.txt"), os.O_EXCL|os.O_CREATE|os.O_WRONLY, 0666)
+	if err != nil {
+		return fmt.Errorf("cannot create pid.txt: %v", err)
+	}
+	defer pidf.Close()
+	args, err := srv.command()
+	if err != nil {
+		return fmt.Errorf("cannot determine command: %v", err)
+	}
+	cmd := exec.Command(args[0], args[1:]...)
+
+	logf, err := os.OpenFile(srv.path("log.txt"), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
+	if err != nil {
+		return fmt.Errorf("cannot create log file: %v", err)
+	}
+	defer logf.Close()
+	cmd.Stdout = logf
+	cmd.Stderr = logf
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("cannot start server: %v", err)
+	}
+	if _, err := fmt.Fprint(pidf, cmd.Process.Pid); err != nil {
+		return fmt.Errorf("cannot write pid file: %v", err)
+	}
+	return nil
+}
+
+// Stop kills the ZooKeeper server. It does nothing if it is not running.
+// Note that Stop does not remove any data from the run directory,
+// so Start may be called later on the same directory.
+func (srv *Server) Stop() os.Error {
+	p, err := srv.Process()
+	if p == nil {
+		if err != nil {
+			return fmt.Errorf("cannot read process ID of server: %v", err)
+		}
+		return nil
+	}
+	defer p.Release()
+	if err := p.Kill(); err != nil {
+		return fmt.Errorf("cannot kill server process: %v", err)
+	}
+	// ignore the error returned from Wait because there's little
+	// we can do about it - it either means that the process has just exited
+	// anyway or that we can't wait for it for some other reason,
+	// for example because it was originally started by some other process.
+	_, err = p.Wait(0)
+	if e, ok := err.(*os.SyscallError); ok && e.Errno == os.ECHILD || err == os.ECHILD {
+		// If we can't wait for the server, it's possible that it was running
+		// but not as a child of this process, so the only thing we can do
+		// is to poll until it exits. If the process has taken longer than
+		// a second to exit, then it's probably not going to.
+		for i := 0; i < 5*4; i++ {
+			time.Sleep(1e9 / 4)
+			if np, err := getProcess(p.Pid); err != nil {
+				break
+			} else {
+				np.Release()
+			}
+		}
+	}
+
+	if err := os.Remove(srv.path("pid.txt")); err != nil {
+		return fmt.Errorf("cannot remove server process ID file: %v", err)
+	}
+	return nil
+}
+
+// Destroy stops the ZooKeeper server, and then removes its run
+// directory. Warning: this will destroy all data associated with the server.
+func (srv *Server) Destroy() os.Error {
+	if err := srv.Stop(); err != nil {
+		return err
+	}
+	if err := os.RemoveAll(srv.runDir); err != nil {
+		return err
+	}
+	return nil
+}

=== added file 'server.go'
--- server.go	1970-01-01 00:00:00 +0000
+++ server.go	2011-10-10 13:55:28 +0000
@@ -0,0 +1,229 @@
+package zk
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Server represents a ZooKeeper server, its data and configuration files.
+type Server struct {
+	runDir string
+	zkDir  string
+}
+
+// CreateServer creates the directory runDir and sets up a ZooKeeper server
+// environment inside it. It is an error if runDir already exists.
+// The server will listen on the specified TCP port.
+// 
+// The ZooKeeper installation directory is specified by zkDir.
+// If this is empty, a system default will be used.
+//
+// CreateServer does not start the server.
+func CreateServer(port int, runDir, zkDir string) (*Server, os.Error) {
+	if err := os.Mkdir(runDir, 0777); err != nil {
+		return nil, err
+	}
+	srv := &Server{runDir: runDir, zkDir: zkDir}
+	if err := srv.writeLog4JConfig(); err != nil {
+		return nil, err
+	}
+	if err := srv.writeZooKeeperConfig(port); err != nil {
+		return nil, err
+	}
+	if err := srv.writeZkDir(); err != nil {
+		return nil, err
+	}
+	return srv, nil
+}
+
+// AttachServer creates a new ZooKeeper Server instance
+// to operate inside an existing run directory, runDir.
+// The directory must have been created with CreateServer.
+func AttachServer(runDir string) (*Server, os.Error) {
+	srv := &Server{runDir: runDir}
+	if err := srv.readZkDir(); err != nil {
+		return nil, fmt.Errorf("cannot read server install directory: %v", err)
+	}
+	return srv, nil
+}
+
+func (srv *Server) checkAvailability() os.Error {
+	port, err := srv.networkPort()
+	if err != nil {
+		return fmt.Errorf("cannot get network port: %v", err)
+	}
+	l, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", port))
+	if err != nil {
+		return fmt.Errorf("cannot listen on port %v: %v", port, err)
+	}
+	l.Close()
+	return nil
+}
+
+// networkPort returns the TCP port number that
+// the server is configured for.
+func (srv *Server) networkPort() (int, os.Error) {
+	f, err := os.Open(srv.path("zoo.cfg"))
+	if err != nil {
+		return 0, err
+	}
+	r := bufio.NewReader(f)
+	for {
+		line, err := r.ReadSlice('\n')
+		if err != nil {
+			return 0, fmt.Errorf("cannot get port from %q", srv.path("zoo.cfg"))
+		}
+		var port int
+		if n, _ := fmt.Sscanf(string(line), "clientPort=%d\n", &port); n == 1 {
+			return port, nil
+		}
+	}
+	panic("not reached")
+}
+
+// command returns the command used to start the
+// ZooKeeper server.
+func (srv *Server) command() ([]string, os.Error) {
+	cp, err := srv.classPath()
+	if err != nil {
+		return nil, fmt.Errorf("cannot get class path: %v", err)
+	}
+	return []string{
+		"java",
+		"-cp", strings.Join(cp, ":"),
+		"-Dzookeeper.root.logger=INFO,CONSOLE",
+		"-Dlog4j.configuration=file:" + srv.path("log4j.properties"),
+		"org.apache.zookeeper.server.quorum.QuorumPeerMain",
+		srv.path("zoo.cfg"),
+	}, 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 (srv *Server) writeLog4JConfig() (err os.Error) {
+	return ioutil.WriteFile(srv.path("log4j.properties"), []byte(log4jProperties), 0666)
+}
+
+func (srv *Server) writeZooKeeperConfig(port int) (err os.Error) {
+	return ioutil.WriteFile(srv.path("zoo.cfg"), []byte(fmt.Sprintf(
+		"tickTime=2000\n"+
+			"dataDir=%s\n"+
+			"clientPort=%d\n"+
+			"maxClientCnxns=500\n",
+		srv.runDir, port)), 0666)
+}
+
+func (srv *Server) writeZkDir() os.Error {
+	return ioutil.WriteFile(srv.path("zkdir.txt"), []byte(srv.zkDir), 0666)
+}
+
+func (srv *Server) readZkDir() os.Error {
+	data, err := ioutil.ReadFile(srv.path("zkdir.txt"))
+	if err != nil {
+		return err
+	}
+	srv.zkDir = string(data)
+	return nil
+}
+
+func (srv *Server) classPath() ([]string, os.Error) {
+	dir := srv.zkDir
+	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
+}
+
+const zookeeperEnviron = "/etc/zookeeper/conf/environment"
+
+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
+}
+
+func (srv *Server) path(name string) string {
+	return filepath.Join(srv.runDir, name)
+}

=== modified file 'suite_test.go'
--- suite_test.go	2011-08-19 01:43:37 +0000
+++ suite_test.go	2011-10-10 13:55:28 +0000
@@ -1,13 +1,11 @@
-package gozk_test
+package zk_test
 
 import (
 	. "launchpad.net/gocheck"
-	"testing"
-	"io/ioutil"
-	"path"
 	"fmt"
+	"launchpad.net/gozk/zk"
 	"os"
-	"gozk"
+	"testing"
 	"time"
 )
 
@@ -18,48 +16,32 @@
 var _ = Suite(&S{})
 
 type S struct {
-	zkRoot      string
-	zkTestRoot  string
-	zkTestPort  int
-	zkServerSh  string
-	zkServerOut *os.File
-	zkAddr      string
+	zkServer   *zk.Server
+	zkTestRoot string
+	zkTestPort int
+	zkProcess  *os.Process // The running ZooKeeper process
+	zkAddr     string
 
-	handles     []*gozk.ZooKeeper
-	events      []*gozk.Event
+	handles     []*zk.Conn
+	events      []*zk.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 //zk.LOG_ERROR
+
+func (s *S) init(c *C) (*zk.Conn, chan zk.Event) {
+	conn, watch, err := zk.Dial(s.zkAddr, 5e9)
 	c.Assert(err, IsNil)
 
-	s.handles = append(s.handles, zk)
+	s.handles = append(s.handles, conn)
 
 	event := <-watch
 
-	c.Assert(event.Type, Equals, gozk.EVENT_SESSION)
-	c.Assert(event.State, Equals, gozk.STATE_CONNECTED)
+	c.Assert(event.Type, Equals, zk.EVENT_SESSION)
+	c.Assert(event.State, Equals, zk.STATE_CONNECTED)
 
-	bufferedWatch := make(chan gozk.Event, 256)
+	bufferedWatch := make(chan zk.Event, 256)
 	bufferedWatch <- event
 
 	s.liveWatches += 1
@@ -82,13 +64,13 @@
 		s.deadWatches <- true
 	}()
 
-	return zk, bufferedWatch
+	return conn, bufferedWatch
 }
 
 func (s *S) SetUpTest(c *C) {
-	c.Assert(gozk.CountPendingWatches(), Equals, 0,
+	c.Assert(zk.CountPendingWatches(), Equals, 0,
 		Bug("Test got a dirty watch state before running!"))
-	gozk.SetLogLevel(logLevel)
+	zk.SetLogLevel(logLevel)
 }
 
 func (s *S) TearDownTest(c *C) {
@@ -108,98 +90,37 @@
 	}
 
 	// Reset the list of handles.
-	s.handles = make([]*gozk.ZooKeeper, 0)
+	s.handles = make([]*zk.Conn, 0)
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 0,
+	c.Assert(zk.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()
+	// N.B. We meed to create a subdirectory because zk.CreateServer
+	// insists on creating its own directory.
+
+	s.zkTestRoot = c.MkDir() + "/zk"
+	port := 21812
+	s.zkAddr = fmt.Sprint("localhost:", port)
+
+	s.zkServer, err = zk.CreateServer(port, s.zkTestRoot, "")
+	if err != nil {
+		c.Fatal("Cannot set up server environment: ", err)
+	}
+	err = s.zkServer.Start()
+	if err != nil {
+		c.Fatal("Cannot start ZooKeeper server: ", err)
+	}
 }
 
 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 (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.zkServer != nil {
+		s.zkServer.Destroy()
 	}
 }

=== renamed file 'gozk.go' => 'zk.go'
--- gozk.go	2011-08-19 01:56:39 +0000
+++ zk.go	2011-10-10 13:55:28 +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 zk
 
 /*
 #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,79 +372,73 @@
 // 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{}
-	zk.watchChannels = make(map[uintptr]chan Event)
+func dial(servers string, recvTimeoutNS int64, clientId *ClientId) (*Conn, <-chan Event, os.Error) {
+	conn := &Conn{}
+	conn.watchChannels = make(map[uintptr]chan Event)
 
 	var cId *C.clientid_t
 	if clientId != nil {
 		cId = &clientId.cId
 	}
 
-	watchId, watchChannel := zk.createWatch(true)
-	zk.sessionWatchId = watchId
+	watchId, watchChannel := conn.createWatch(true)
+	conn.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)
+		conn.closeAllWatches()
+		return nil, nil, zkError(C.int(ZSYSTEMERROR), cerr)
 	}
-	zk.handle = handle
+	conn.handle = handle
 	runWatchLoop()
-	return zk, watchChannel, nil
+	return conn, watchChannel, nil
 }
 
 // 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 {
-	return &ClientId{*C.zoo_client_id(zk.handle)}
+func (conn *Conn) ClientId() *ClientId {
+	return &ClientId{*C.zoo_client_id(conn.handle)}
 }
 
 // Close terminates the ZooKeeper interaction.
-func (zk *ZooKeeper) Close() Error {
-
-	// Protect from concurrency around zk.handle change.
-	zk.mutex.Lock()
-	defer zk.mutex.Unlock()
-
-	if zk.handle == nil {
+func (conn *Conn) Close() os.Error {
+
+	// Protect from concurrency around conn.handle change.
+	conn.mutex.Lock()
+	defer conn.mutex.Unlock()
+
+	if conn.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)
+	rc, cerr := C.zookeeper_close(conn.handle)
 
-	zk.closeAllWatches()
+	conn.closeAllWatches()
 	stopWatchLoop()
 
-	// At this point, nothing else should need zk.handle.
-	zk.handle = nil
+	// At this point, nothing else should need conn.handle.
+	conn.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 (conn *Conn) Get(path string) (data string, stat *Stat, err os.Error) {
 
 	cpath := C.CString(path)
 	cbuffer := (*C.char)(C.malloc(bufferSize))
@@ -478,22 +446,21 @@
 	defer C.free(unsafe.Pointer(cpath))
 	defer C.free(unsafe.Pointer(cbuffer))
 
-	cstat := C.struct_Stat{}
-	rc, cerr := C.zoo_wget(zk.handle, cpath, nil, nil,
-		cbuffer, &cbufferLen, &cstat)
+	var cstat Stat
+	rc, cerr := C.zoo_wget(conn.handle, cpath, nil, nil, 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 (conn *Conn) GetW(path string) (data string, stat *Stat, watch <-chan Event, err os.Error) {
 
 	cpath := C.CString(path)
 	cbuffer := (*C.char)(C.malloc(bufferSize))
@@ -501,42 +468,38 @@
 	defer C.free(unsafe.Pointer(cpath))
 	defer C.free(unsafe.Pointer(cbuffer))
 
-	watchId, watchChannel := zk.createWatch(true)
+	watchId, watchChannel := conn.createWatch(true)
 
-	cstat := C.struct_Stat{}
-	rc, cerr := C.zoo_wget(zk.handle, cpath,
-		C.watch_handler, unsafe.Pointer(watchId),
-		cbuffer, &cbufferLen, &cstat)
+	var cstat Stat
+	rc, cerr := C.zoo_wget(conn.handle, cpath, C.watch_handler, unsafe.Pointer(watchId), cbuffer, &cbufferLen, &cstat.c)
 	if rc != C.ZOK {
-		zk.forgetWatch(watchId)
-		return "", nil, nil, newError(rc, cerr)
+		conn.forgetWatch(watchId)
+		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 (conn *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{}
-	rc, cerr := C.zoo_wget_children2(zk.handle, cpath, nil, nil,
-		&cvector, &cstat)
+	var cstat Stat
+	rc, cerr := C.zoo_wget_children2(conn.handle, cpath, nil, nil, &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,29 +508,27 @@
 // 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 (conn *Conn) ChildrenW(path string) (children []string, stat *Stat, watch <-chan Event, err os.Error) {
 
 	cpath := C.CString(path)
 	defer C.free(unsafe.Pointer(cpath))
 
-	watchId, watchChannel := zk.createWatch(true)
+	watchId, watchChannel := conn.createWatch(true)
 
 	cvector := C.struct_String_vector{}
-	cstat := C.struct_Stat{}
-	rc, cerr := C.zoo_wget_children2(zk.handle, cpath,
-		C.watch_handler, unsafe.Pointer(watchId),
-		&cvector, &cstat)
+	var cstat Stat
+	rc, cerr := C.zoo_wget_children2(conn.handle, cpath, C.watch_handler, unsafe.Pointer(watchId), &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 {
-		zk.forgetWatch(watchId)
-		err = newError(rc, cerr)
+	if rc == C.ZOK {
+		stat = &cstat
+		watch = watchChannel
 	} else {
-		stat = (*resultStat)(&cstat)
-		watch = watchChannel
+		conn.forgetWatch(watchId)
+		err = zkError(rc, cerr)
 	}
 	return
 }
@@ -588,20 +549,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 (conn *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(conn.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 +572,27 @@
 // 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 (conn *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)
+	watchId, watchChannel := conn.createWatch(true)
 
-	cstat := C.struct_Stat{}
-	rc, cerr := C.zoo_wexists(zk.handle, cpath,
-		C.watch_handler, unsafe.Pointer(watchId), &cstat)
+	var cstat Stat
+	rc, cerr := C.zoo_wexists(conn.handle, cpath, 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)
+		conn.forgetWatch(watchId)
+		err = zkError(rc, cerr)
 	}
 	return
 }
@@ -646,7 +606,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 (conn *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))
@@ -660,13 +620,13 @@
 	cpathCreated := (*C.char)(C.malloc(cpathLen))
 	defer C.free(unsafe.Pointer(cpathCreated))
 
-	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)
+	rc, cerr := C.zoo_create(conn.handle, cpath, cvalue, C.int(len(value)), caclv, C.int(flags), cpathCreated, C.int(cpathLen))
+	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 +637,31 @@
 //
 // 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 (conn *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{}
-
-	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)
+	var cstat Stat
+	rc, cerr := C.zoo_set2(conn.handle, cpath, cvalue, C.int(len(value)), 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 (conn *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
+	rc, cerr := C.zoo_delete(conn.handle, cpath, C.int(version))
+	return zkError(rc, cerr)
 }
 
 // AddAuth adds a new authentication certificate to the ZooKeeper
@@ -713,7 +669,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 (conn *Conn) AddAuth(scheme, cert string) os.Error {
 	cscheme := C.CString(scheme)
 	ccert := C.CString(cert)
 	defer C.free(unsafe.Pointer(cscheme))
@@ -725,43 +681,38 @@
 	}
 	defer C.destroy_completion_data(data)
 
-	rc, cerr := C.zoo_add_auth(zk.handle, cscheme, ccert, C.int(len(cert)),
-		C.handle_void_completion, unsafe.Pointer(data))
+	rc, cerr := C.zoo_add_auth(conn.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 (conn *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(conn.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 (conn *Conn) SetACL(path string, aclv []ACL, version int32) os.Error {
 
 	cpath := C.CString(path)
 	defer C.free(unsafe.Pointer(cpath))
@@ -769,12 +720,8 @@
 	caclv := buildACLVector(aclv)
 	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
+	rc, cerr := C.zoo_set_acl(conn.handle, cpath, C.int(version), caclv)
+	return zkError(rc, cerr)
 }
 
 func parseACLVector(caclv *C.struct_ACL_vector) []ACL {
@@ -822,7 +769,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 +778,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 +791,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 +800,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 (conn *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 := conn.Get(path)
+		if err != nil && err != ZNONODE {
+			return err
+		}
+		newValue, err := changeFunc(oldValue, oldStat)
+		if err != nil {
+			return err
+		}
+		if oldStat == nil {
+			_, err := conn.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 = conn.Set(path, newValue, oldStat.Version())
+		if err == nil || (err != ZBADVERSION && err != ZNONODE) {
+			return err
 		}
 	}
-	return err
+	panic("not reached")
 }
 
 // -----------------------------------------------------------------------
@@ -897,7 +838,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 +851,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 +866,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 (conn *Conn) createWatch(session bool) (watchId uintptr, watchChannel chan Event) {
 	buf := 1 // session/watch event
 	if session {
 		buf = 32
@@ -942,8 +883,8 @@
 	defer watchMutex.Unlock()
 	watchId = watchCounter
 	watchCounter += 1
-	zk.watchChannels[watchId] = watchChannel
-	watchZooKeepers[watchId] = zk
+	conn.watchChannels[watchId] = watchChannel
+	watchConns[watchId] = conn
 	return
 }
 
@@ -951,21 +892,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 (conn *Conn) forgetWatch(watchId uintptr) {
 	watchMutex.Lock()
 	defer watchMutex.Unlock()
-	zk.watchChannels[watchId] = nil, false
-	watchZooKeepers[watchId] = nil, false
+	conn.watchChannels[watchId] = nil, false
+	watchConns[watchId] = nil, false
 }
 
-// closeAllWatches closes all watch channels for zk.
-func (zk *ZooKeeper) closeAllWatches() {
+// closeAllWatches closes all watch channels for conn.
+func (conn *Conn) closeAllWatches() {
 	watchMutex.Lock()
 	defer watchMutex.Unlock()
-	for watchId, ch := range zk.watchChannels {
+	for watchId, ch := range conn.watchChannels {
 		close(ch)
-		zk.watchChannels[watchId] = nil, false
-		watchZooKeepers[watchId] = nil, false
+		conn.watchChannels[watchId] = nil, false
+		watchConns[watchId] = nil, false
 	}
 }
 
@@ -978,11 +919,11 @@
 	}
 	watchMutex.Lock()
 	defer watchMutex.Unlock()
-	zk, ok := watchZooKeepers[watchId]
+	conn, ok := watchConns[watchId]
 	if !ok {
 		return
 	}
-	if event.Type == EVENT_SESSION && watchId != zk.sessionWatchId {
+	if event.Type == EVENT_SESSION && watchId != conn.sessionWatchId {
 		switch event.State {
 		case STATE_EXPIRED_SESSION, STATE_AUTH_FAILED:
 		default:
@@ -990,7 +931,7 @@
 			return
 		}
 	}
-	ch := zk.watchChannels[watchId]
+	ch := conn.watchChannels[watchId]
 	if ch == nil {
 		return
 	}
@@ -1002,15 +943,15 @@
 		// straight to the buffer), and the application isn't paying
 		// attention for long enough to have the buffer filled up.
 		// Break down now rather than leaking forever.
-		if watchId == zk.sessionWatchId {
+		if watchId == conn.sessionWatchId {
 			panic("Session event channel buffer is full")
 		} else {
 			panic("Watch event channel buffer is full")
 		}
 	}
-	if watchId != zk.sessionWatchId {
-		zk.watchChannels[watchId] = nil, false
-		watchZooKeepers[watchId] = nil, false
+	if watchId != conn.sessionWatchId {
+		conn.watchChannels[watchId] = nil, false
+		watchConns[watchId] = nil, false
 		close(ch)
 	}
 }

=== renamed file 'gozk_test.go' => 'zk_test.go'
--- gozk_test.go	2011-08-19 01:51:37 +0000
+++ zk_test.go	2011-10-10 13:55:28 +0000
@@ -1,17 +1,17 @@
-package gozk_test
+package zk_test
 
 import (
 	. "launchpad.net/gocheck"
-	"gozk"
+	"launchpad.net/gozk/zk"
 	"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)
-	if zk != nil {
-		zk.Close()
+	conn, watch, err := zk.Dial("bad-domain-without-port", 5e9)
+	if conn != nil {
+		conn.Close()
 	}
 	if watch != nil {
 		go func() {
@@ -23,15 +23,15 @@
 			}
 		}()
 	}
-	c.Assert(zk, IsNil)
+	c.Assert(conn, IsNil)
 	c.Assert(watch, IsNil)
 	c.Assert(err, Matches, "invalid argument")
 }
 
 func (s *S) TestRecvTimeoutInitParameter(c *C) {
-	zk, watch, err := gozk.Init(s.zkAddr, 0)
+	conn, watch, err := zk.Dial(s.zkAddr, 0)
 	c.Assert(err, IsNil)
-	defer zk.Close()
+	defer conn.Close()
 
 	select {
 	case <-watch:
@@ -40,7 +40,7 @@
 	}
 
 	for i := 0; i != 1000; i++ {
-		_, _, err := zk.Get("/zookeeper")
+		_, _, err := conn.Get("/zookeeper")
 		if err != nil {
 			c.Assert(err, Matches, "operation timeout")
 			c.SucceedNow()
@@ -51,76 +51,79 @@
 }
 
 func (s *S) TestSessionWatches(c *C) {
-	c.Assert(gozk.CountPendingWatches(), Equals, 0)
+	c.Assert(zk.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(zk.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, zk.EVENT_SESSION)
+	c.Assert(event1.State, Equals, zk.STATE_CONNECTED)
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 3)
+	c.Assert(zk.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, zk.EVENT_SESSION)
+	c.Assert(event2.State, Equals, zk.STATE_CONNECTED)
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 3)
+	c.Assert(zk.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, zk.EVENT_SESSION)
+	c.Assert(event3.State, Equals, zk.STATE_CONNECTED)
 
-	c.Assert(gozk.CountPendingWatches(), Equals, 3)
+	c.Assert(zk.CountPendingWatches(), Equals, 3)
 
 	zk1.Close()
-	c.Assert(gozk.CountPendingWatches(), Equals, 2)
+	c.Assert(zk.CountPendingWatches(), Equals, 2)
 	zk2.Close()
-	c.Assert(gozk.CountPendingWatches(), Equals, 1)
+	c.Assert(zk.CountPendingWatches(), Equals, 1)
 	zk3.Close()
-	c.Assert(gozk.CountPendingWatches(), Equals, 0)
+	c.Assert(zk.CountPendingWatches(), Equals, 0)
 }
 
-// Gozk injects a STATE_CLOSED event when zk.Close() is called, right
+// Gozk injects a STATE_CLOSED event when conn.Close() is called, right
 // before the channel is closed.  Closing the channel injects a nil
 // pointer, as usual for Go, so the STATE_CLOSED gives a chance to
 // know that a nil pointer is coming, and to stop the procedure.
 // Hopefully this procedure will avoid some nil-pointer references by
 // mistake.
 func (s *S) TestClosingStateInSessionWatch(c *C) {
-	zk, watch := s.init(c)
+	conn, 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, zk.EVENT_SESSION)
+	c.Assert(event.State, Equals, zk.STATE_CONNECTED)
 
-	zk.Close()
+	conn.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, zk.EVENT_CLOSED)
+	c.Assert(event.State, Equals, zk.STATE_CLOSED)
 }
 
 func (s *S) TestEventString(c *C) {
-	var event gozk.Event
-	event = gozk.Event{gozk.EVENT_SESSION, "/path", gozk.STATE_CONNECTED}
+	var event zk.Event
+	event = zk.Event{zk.EVENT_SESSION, "/path", zk.STATE_CONNECTED}
 	c.Assert(event, Matches, "ZooKeeper connected")
-	event = gozk.Event{gozk.EVENT_CREATED, "/path", gozk.STATE_CONNECTED}
+	event = zk.Event{zk.EVENT_CREATED, "/path", zk.STATE_CONNECTED}
 	c.Assert(event, Matches, "ZooKeeper connected; path created: /path")
-	event = gozk.Event{-1, "/path", gozk.STATE_CLOSED}
+	event = zk.Event{-1, "/path", zk.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 {
+	zk.Event
+	Ok bool
+}{
+	{zk.Event{zk.EVENT_SESSION, "", zk.STATE_CONNECTED}, true},
+	{zk.Event{zk.EVENT_CREATED, "", zk.STATE_CONNECTED}, true},
+	{zk.Event{0, "", zk.STATE_CLOSED}, false},
+	{zk.Event{0, "", zk.STATE_EXPIRED_SESSION}, false},
+	{zk.Event{0, "", zk.STATE_AUTH_FAILED}, false},
 }
 
 func (s *S) TestEventOk(c *C) {
@@ -130,9 +133,9 @@
 }
 
 func (s *S) TestGetAndStat(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	data, stat, err := zk.Get("/zookeeper")
+	data, stat, err := conn.Get("/zookeeper")
 	c.Assert(err, IsNil)
 	c.Assert(data, Equals, "")
 	c.Assert(stat.Czxid(), Equals, int64(0))
@@ -149,58 +152,58 @@
 }
 
 func (s *S) TestGetAndError(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	data, stat, err := zk.Get("/non-existent")
+	data, stat, err := conn.Get("/non-existent")
 
 	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, zk.ZNONODE)
 }
 
 func (s *S) TestCreateAndGet(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	path, err := zk.Create("/test-", "bababum", gozk.SEQUENCE|gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	path, err := conn.Create("/test-", "bababum", zk.SEQUENCE|zk.EPHEMERAL, zk.WorldACL(zk.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 = conn.Create(path, "", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, Matches, "node exists")
 
-	data, _, err := zk.Get(path)
+	data, _, err := conn.Get(path)
 	c.Assert(err, IsNil)
 	c.Assert(data, Equals, "bababum")
 }
 
 func (s *S) TestCreateSetAndGet(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err := conn.Create("/test", "", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	stat, err := zk.Set("/test", "bababum", -1) // Any version.
+	stat, err := conn.Set("/test", "bababum", -1) // Any version.
 	c.Assert(err, IsNil)
 	c.Assert(stat.Version(), Equals, int32(1))
 
-	data, _, err := zk.Get("/test")
+	data, _, err := conn.Get("/test")
 	c.Assert(err, IsNil)
 	c.Assert(data, Equals, "bababum")
 }
 
 func (s *S) TestGetAndWatch(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
-
-	zk, _ := s.init(c)
-
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
-
-	_, err := zk.Create("/test", "one", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	c.Check(zk.CountPendingWatches(), Equals, 0)
+
+	conn, _ := s.init(c)
+
+	c.Check(zk.CountPendingWatches(), Equals, 1)
+
+	_, err := conn.Create("/test", "one", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	data, stat, watch, err := zk.GetW("/test")
+	data, stat, watch, err := conn.GetW("/test")
 	c.Assert(err, IsNil)
 	c.Assert(data, Equals, "one")
 	c.Assert(stat.Version(), Equals, int32(0))
@@ -211,17 +214,17 @@
 	default:
 	}
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zk.CountPendingWatches(), Equals, 2)
 
-	_, err = zk.Set("/test", "two", -1)
+	_, err = conn.Set("/test", "two", -1)
 	c.Assert(err, IsNil)
 
 	event := <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CHANGED)
-
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
-
-	data, _, watch, err = zk.GetW("/test")
+	c.Assert(event.Type, Equals, zk.EVENT_CHANGED)
+
+	c.Check(zk.CountPendingWatches(), Equals, 1)
+
+	data, _, watch, err = conn.GetW("/test")
 	c.Assert(err, IsNil)
 	c.Assert(data, Equals, "two")
 
@@ -231,86 +234,86 @@
 	default:
 	}
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zk.CountPendingWatches(), Equals, 2)
 
-	_, err = zk.Set("/test", "three", -1)
+	_, err = conn.Set("/test", "three", -1)
 	c.Assert(err, IsNil)
 
 	event = <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CHANGED)
+	c.Assert(event.Type, Equals, zk.EVENT_CHANGED)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zk.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestGetAndWatchWithError(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
-
-	zk, _ := s.init(c)
-
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
-
-	_, _, watch, err := zk.GetW("/test")
+	c.Check(zk.CountPendingWatches(), Equals, 0)
+
+	conn, _ := s.init(c)
+
+	c.Check(zk.CountPendingWatches(), Equals, 1)
+
+	_, _, watch, err := conn.GetW("/test")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNONODE)
+	c.Assert(err, Equals, zk.ZNONODE)
 	c.Assert(watch, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zk.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestCloseReleasesWatches(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
-
-	zk, _ := s.init(c)
-
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
-
-	_, err := zk.Create("/test", "one", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
-	c.Assert(err, IsNil)
-
-	_, _, _, err = zk.GetW("/test")
-	c.Assert(err, IsNil)
-
-	c.Assert(gozk.CountPendingWatches(), Equals, 2)
-
-	zk.Close()
-
-	c.Assert(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zk.CountPendingWatches(), Equals, 0)
+
+	conn, _ := s.init(c)
+
+	c.Check(zk.CountPendingWatches(), Equals, 1)
+
+	_, err := conn.Create("/test", "one", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
+	c.Assert(err, IsNil)
+
+	_, _, _, err = conn.GetW("/test")
+	c.Assert(err, IsNil)
+
+	c.Assert(zk.CountPendingWatches(), Equals, 2)
+
+	conn.Close()
+
+	c.Assert(zk.CountPendingWatches(), Equals, 0)
 }
 
 // By default, the ZooKeeper C client will hang indefinitely if a
 // handler is closed twice.  We get in the way and prevent it.
 func (s *S) TestClosingTwiceDoesntHang(c *C) {
-	zk, _ := s.init(c)
-	err := zk.Close()
+	conn, _ := s.init(c)
+	err := conn.Close()
 	c.Assert(err, IsNil)
-	err = zk.Close()
+	err = conn.Close()
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZCLOSING)
+	c.Assert(err, Equals, zk.ZCLOSING)
 }
 
 func (s *S) TestChildren(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	children, stat, err := zk.Children("/")
+	children, stat, err := conn.Children("/")
 	c.Assert(err, IsNil)
 	c.Assert(children, Equals, []string{"zookeeper"})
 	c.Assert(stat.NumChildren(), Equals, int32(1))
 
-	children, stat, err = zk.Children("/non-existent")
+	children, stat, err = conn.Children("/non-existent")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNONODE)
+	c.Assert(err, Equals, zk.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)
-
-	zk, _ := s.init(c)
-
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
-
-	children, stat, watch, err := zk.ChildrenW("/")
+	c.Check(zk.CountPendingWatches(), Equals, 0)
+
+	conn, _ := s.init(c)
+
+	c.Check(zk.CountPendingWatches(), Equals, 1)
+
+	children, stat, watch, err := conn.ChildrenW("/")
 	c.Assert(err, IsNil)
 	c.Assert(children, Equals, []string{"zookeeper"})
 	c.Assert(stat.NumChildren(), Equals, int32(1))
@@ -321,18 +324,18 @@
 	default:
 	}
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zk.CountPendingWatches(), Equals, 2)
 
-	_, err = zk.Create("/test1", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err = conn.Create("/test1", "", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	event := <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CHILD)
+	c.Assert(event.Type, Equals, zk.EVENT_CHILD)
 	c.Assert(event.Path, Equals, "/")
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zk.CountPendingWatches(), Equals, 1)
 
-	children, stat, watch, err = zk.ChildrenW("/")
+	children, stat, watch, err = conn.ChildrenW("/")
 	c.Assert(err, IsNil)
 	c.Assert(stat.NumChildren(), Equals, int32(2))
 
@@ -345,57 +348,56 @@
 	default:
 	}
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zk.CountPendingWatches(), Equals, 2)
 
-	_, err = zk.Create("/test2", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err = conn.Create("/test2", "", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	event = <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CHILD)
+	c.Assert(event.Type, Equals, zk.EVENT_CHILD)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zk.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestChildrenAndWatchWithError(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
-
-	zk, _ := s.init(c)
-
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
-
-	_, stat, watch, err := zk.ChildrenW("/test")
+	c.Check(zk.CountPendingWatches(), Equals, 0)
+
+	conn, _ := s.init(c)
+
+	c.Check(zk.CountPendingWatches(), Equals, 1)
+
+	_, stat, watch, err := conn.ChildrenW("/test")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNONODE)
+	c.Assert(err, Equals, zk.ZNONODE)
 	c.Assert(watch, IsNil)
 	c.Assert(stat, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zk.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")
+	conn, _ := s.init(c)
+
+	stat, err := conn.Exists("/non-existent")
 	c.Assert(err, IsNil)
 	c.Assert(stat, IsNil)
+
+	stat, err = conn.Exists("/zookeeper")
+	c.Assert(err, IsNil)
 }
 
 func (s *S) TestExistsAndWatch(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
-
-	zk, _ := s.init(c)
-
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
-
-	stat, watch, err := zk.ExistsW("/test")
+	c.Check(zk.CountPendingWatches(), Equals, 0)
+
+	conn, _ := s.init(c)
+
+	c.Check(zk.CountPendingWatches(), Equals, 1)
+
+	stat, watch, err := conn.ExistsW("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zk.CountPendingWatches(), Equals, 2)
 
 	select {
 	case <-watch:
@@ -403,62 +405,62 @@
 	default:
 	}
 
-	_, err = zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err = conn.Create("/test", "", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	event := <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CREATED)
+	c.Assert(event.Type, Equals, zk.EVENT_CREATED)
 	c.Assert(event.Path, Equals, "/test")
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zk.CountPendingWatches(), Equals, 1)
 
-	stat, watch, err = zk.ExistsW("/test")
+	stat, watch, err = conn.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(zk.CountPendingWatches(), Equals, 2)
 }
 
 func (s *S) TestExistsAndWatchWithError(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
-
-	zk, _ := s.init(c)
-
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
-
-	stat, watch, err := zk.ExistsW("///")
+	c.Check(zk.CountPendingWatches(), Equals, 0)
+
+	conn, _ := s.init(c)
+
+	c.Check(zk.CountPendingWatches(), Equals, 1)
+
+	stat, watch, err := conn.ExistsW("///")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZBADARGUMENTS)
+	c.Assert(err, Equals, zk.ZBADARGUMENTS)
 	c.Assert(stat, IsNil)
 	c.Assert(watch, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zk.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestDelete(c *C) {
-	zk, _ := s.init(c)
-
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
-	c.Assert(err, IsNil)
-
-	err = zk.Delete("/test", 5)
-	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.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)
+	conn, _ := s.init(c)
+
+	_, err := conn.Create("/test", "", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
+	c.Assert(err, IsNil)
+
+	err = conn.Delete("/test", 5)
+	c.Assert(err, NotNil)
+	c.Assert(err, Equals, zk.ZBADVERSION)
+
+	err = conn.Delete("/test", -1)
+	c.Assert(err, IsNil)
+
+	err = conn.Delete("/test", -1)
+	c.Assert(err, NotNil)
+	c.Assert(err, Equals, zk.ZNONODE)
 }
 
 func (s *S) TestClientIdAndReInit(c *C) {
 	zk1, _ := s.init(c)
 	clientId1 := zk1.ClientId()
 
-	zk2, _, err := gozk.ReInit(s.zkAddr, 5e9, clientId1)
+	zk2, _, err := zk.Redial(s.zkAddr, 5e9, clientId1)
 	c.Assert(err, IsNil)
 	defer zk2.Close()
 	clientId2 := zk2.ClientId()
@@ -469,110 +471,110 @@
 // Surprisingly for some (including myself, initially), the watch
 // returned by the exists method actually fires on data changes too.
 func (s *S) TestExistsWatchOnDataChange(c *C) {
-	zk, _ := s.init(c)
-
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
-	c.Assert(err, IsNil)
-
-	_, watch, err := zk.ExistsW("/test")
-	c.Assert(err, IsNil)
-
-	_, err = zk.Set("/test", "new", -1)
+	conn, _ := s.init(c)
+
+	_, err := conn.Create("/test", "", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
+	c.Assert(err, IsNil)
+
+	_, watch, err := conn.ExistsW("/test")
+	c.Assert(err, IsNil)
+
+	_, err = conn.Set("/test", "new", -1)
 	c.Assert(err, IsNil)
 
 	event := <-watch
 
 	c.Assert(event.Path, Equals, "/test")
-	c.Assert(event.Type, Equals, gozk.EVENT_CHANGED)
+	c.Assert(event.Type, Equals, zk.EVENT_CHANGED)
 }
 
 func (s *S) TestACL(c *C) {
-	zk, _ := s.init(c)
-
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.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))
+	conn, _ := s.init(c)
+
+	_, err := conn.Create("/test", "", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
+	c.Assert(err, IsNil)
+
+	acl, stat, err := conn.ACL("/test")
+	c.Assert(err, IsNil)
+	c.Assert(acl, Equals, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(stat, NotNil)
 	c.Assert(stat.Version(), Equals, int32(0))
 
-	acl, stat, err = zk.ACL("/non-existent")
+	acl, stat, err = conn.ACL("/non-existent")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNONODE)
+	c.Assert(err, Equals, zk.ZNONODE)
 	c.Assert(acl, IsNil)
 	c.Assert(stat, IsNil)
 }
 
 func (s *S) TestSetACL(c *C) {
-	zk, _ := s.init(c)
+	conn, _ := s.init(c)
 
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL))
+	_, err := conn.Create("/test", "", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
-	err = zk.SetACL("/test", gozk.WorldACL(gozk.PERM_ALL), 5)
+	err = conn.SetACL("/test", zk.WorldACL(zk.PERM_ALL), 5)
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZBADVERSION)
-
-	err = zk.SetACL("/test", gozk.WorldACL(gozk.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(err, Equals, zk.ZBADVERSION)
+
+	err = conn.SetACL("/test", zk.WorldACL(zk.PERM_READ), -1)
+	c.Assert(err, IsNil)
+
+	acl, _, err := conn.ACL("/test")
+	c.Assert(err, IsNil)
+	c.Assert(acl, Equals, zk.WorldACL(zk.PERM_READ))
 }
 
 func (s *S) TestAddAuth(c *C) {
-	zk, _ := s.init(c)
-
-	acl := []gozk.ACL{{gozk.PERM_READ, "digest", "joe:enQcM3mIEHQx7IrPNStYBc0qfs8="}}
-
-	_, err := zk.Create("/test", "", gozk.EPHEMERAL, acl)
+	conn, _ := s.init(c)
+
+	acl := []zk.ACL{{zk.PERM_READ, "digest", "joe:enQcM3mIEHQx7IrPNStYBc0qfs8="}}
+
+	_, err := conn.Create("/test", "", zk.EPHEMERAL, acl)
 	c.Assert(err, IsNil)
 
-	_, _, err = zk.Get("/test")
+	_, _, err = conn.Get("/test")
 	c.Assert(err, NotNil)
-	c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
+	c.Assert(err, Equals, zk.ZNOAUTH)
 
-	err = zk.AddAuth("digest", "joe:passwd")
+	err = conn.AddAuth("digest", "joe:passwd")
 	c.Assert(err, IsNil)
 
-	_, _, err = zk.Get("/test")
+	_, _, err = conn.Get("/test")
 	c.Assert(err, IsNil)
 }
 
 func (s *S) TestWatchOnReconnection(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zk.CountPendingWatches(), Equals, 0)
 
-	zk, session := s.init(c)
+	conn, session := s.init(c)
 
 	event := <-session
-	c.Assert(event.Type, Equals, gozk.EVENT_SESSION)
-	c.Assert(event.State, Equals, gozk.STATE_CONNECTED)
-
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
-
-	stat, watch, err := zk.ExistsW("/test")
+	c.Assert(event.Type, Equals, zk.EVENT_SESSION)
+	c.Assert(event.State, Equals, zk.STATE_CONNECTED)
+
+	c.Check(zk.CountPendingWatches(), Equals, 1)
+
+	stat, watch, err := conn.ExistsW("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zk.CountPendingWatches(), Equals, 2)
 
-	s.StopZK()
+	s.zkServer.Stop()
 	time.Sleep(2e9)
-	s.StartZK()
+	s.zkServer.Start()
 
-	// The session channel should receive the reconnection notification,
+	// 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, zk.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, zk.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 = conn.Create("/test", "", zk.EPHEMERAL, zk.WorldACL(zk.PERM_ALL))
 	c.Assert(err, IsNil)
 
 	event = <-watch
-	c.Assert(event.Type, Equals, gozk.EVENT_CREATED)
+	c.Assert(event.Type, Equals, zk.EVENT_CREATED)
 	c.Assert(event.Path, Equals, "/test")
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zk.CountPendingWatches(), Equals, 1)
 }
 
 func (s *S) TestWatchOnSessionExpiration(c *C) {
-	c.Check(gozk.CountPendingWatches(), Equals, 0)
+	c.Check(zk.CountPendingWatches(), Equals, 0)
 
-	zk, session := s.init(c)
+	conn, session := s.init(c)
 
 	event := <-session
-	c.Assert(event.Type, Equals, gozk.EVENT_SESSION)
-	c.Assert(event.State, Equals, gozk.STATE_CONNECTED)
-
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
-
-	stat, watch, err := zk.ExistsW("/test")
+	c.Assert(event.Type, Equals, zk.EVENT_SESSION)
+	c.Assert(event.State, Equals, zk.STATE_CONNECTED)
+
+	c.Check(zk.CountPendingWatches(), Equals, 1)
+
+	stat, watch, err := conn.ExistsW("/test")
 	c.Assert(err, IsNil)
 	c.Assert(stat, IsNil)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 2)
+	c.Check(zk.CountPendingWatches(), Equals, 2)
 
 	// Use expiration trick described in the FAQ.
-	clientId := zk.ClientId()
-	zk2, session2, err := gozk.ReInit(s.zkAddr, 5e9, clientId)
+	clientId := conn.ClientId()
+	zk2, session2, err := zk.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 == zk.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 == zk.STATE_EXPIRED_SESSION {
 			break
 		}
 	}
 
 	select {
 	case event := <-watch:
-		c.Assert(event.State, Equals, gozk.STATE_EXPIRED_SESSION)
+		c.Assert(event.State, Equals, zk.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, zk.EVENT_CLOSED)
+	c.Assert(event.State, Equals, zk.STATE_CLOSED)
 
-	c.Check(gozk.CountPendingWatches(), Equals, 1)
+	c.Check(zk.CountPendingWatches(), Equals, 1)
 }