Merge lp:~rogpeppe/gozk/factor-out-service into lp:~juju/gozk/trunk

[Roger Peppe]

Factor out server starting code into its own package.

It was orthogonal to the ZooKeeper server code,
feels like it might gain complexity over time,
and it potentially re-usable for other servers.
gozk/service should not be the final name,
as it's entirely independent of zk functionality.

[Gustavo Niemeyer (niemeyer)]

This is an interesting idea, but at the same time it's full of problems and
not really necessary right now. I suggest we delay it until a future point
when we actually need that abstraction, as we'll be in a better position
to generalize it. At that point, we can even preserve for the internal
implementation of the ZooKeeper server itself, without many problems.

Here is some feedback, regardless, which I suggest you don't work on
right now besides for [1] which should be integrated.

[1]

=== added file 'reattach_test.go'
--- reattach_test.go 1970-01-01 00:00:00 +0000
+++ reattach_test.go 2011-10-05 14:37:11 +0000

This should be in a separate merge proposal as it's important and unrelated
to the strawman changes proposed.

[2]

+type Interface interface {
+ // Directory gives the path to the directory containing
+ // the server's configuration and data files. It is assumed that
+ // this exists and can be modified.
+ Directory() string

s/Directory/Dir/

[3]

+
+ // CheckAvailability should return an error if resources
+ // required by the server are not available; for instance
+ // if the server requires a network port which is not free.
+ CheckAvailability() os.Error

We don't need this. The Command function can return an error if
it knows it cannot start.

[4]

+ 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()

This doesn't really guarantee that when the service itself is started,
the port will be available, so we can as well not do it.

[5]

+// Process returns a reference to the identity
+// of the last running server in the Service's directory.
+// If the server was shut down, it returns (nil, nil).

This shouldn't be in a generic service API. What if there
are multiple processes handled by the service?

[6]

+// If the server was shut down, it returns (nil, nil).

If we're returning a nil *Process, we necessarily need err != nil.

[7]

+// It stores the process ID of the server in the file "pid.txt"
+// inside the server's directory. Stdout and stderr of the server
+// are similarly written to "log.txt".

That's not nice. Who owns the content of this directory, the
interface implementation, or the Service? We can't write
arbitrary content into a directory of different ownership.

Also, a generic interface would need to do better in terms
of logging. We could have a file somewhere named output.txt, maybe,
and let logging with the underlying implementation.

[8]

+ if err := p.Kill(); err != nil && !strings.Contains(err.String(), "no such process") {
+ return fmt.Errorf("cannot kill server process: %v", err)
+ }

Different services are stopped in different ways. Some prefer a SIGTERM,
before a SIGKILL, for instance. And what happens if there are multiple
processes?

[9]

+ if err != nil && strings.Contains(err.String(), "no child processes") {
+ // If we can't wait for the server, it's possible that it was running
+ // but not as a child of this process, so give it a little while
+ // to exit. TODO po...

review: Disapprove

[Roger Peppe (rogpeppe)]

On 5 October 2011 16:32, Gustavo Niemeyer <email address hidden> wrote:
> Review: Disapprove
>
> This is an interesting idea, but at the same time it's full of problems and
> not really necessary right now.  I suggest we delay it until a future point
> when we actually need that abstraction, as we'll be in a better position
> to generalize it. At that point, we can even preserve for the internal
> implementation of the ZooKeeper server itself, without many problems.

ok, i'll do that if you don't mind.

the thing that was mostly bothering me was the mingling of the code
from Server and Service, and that the complexities of Service were
obscuring the essential simplicity of Server.

BTW many of the comments below are applicable even without
the factored-out service package.

> Here is some feedback, regardless, which I suggest you don't work on
> right now besides for [1] which should be integrated.
>
> [1]
>
> === added file 'reattach_test.go'
> --- reattach_test.go    1970-01-01 00:00:00 +0000
> +++ reattach_test.go    2011-10-05 14:37:11 +0000
>
> This should be in a separate merge proposal as it's important and unrelated
> to the strawman changes proposed.

oh, i thought it was in the earlier merge.

i've added to the update-server-interface, if that's ok.

> +type Interface interface {
> +       // Directory gives the path to the directory containing
> +       // the server's configuration and data files. It is assumed that
> +       // this exists and can be modified.
> +       Directory() string
>
> s/Directory/Dir/

actually maybe RunDir

> [3]
>
> +
> +       // CheckAvailability should return an error if resources
> +       // required by the server are not available; for instance
> +       // if the server requires a network port which is not free.
> +       CheckAvailability() os.Error
>
> We don't need this.  The Command function can return an error if
> it knows it cannot start.

perhaps. i preferred to keep the availability checking separate
so that calling Command didn't imply that the service was
going to be started immediately.

> [4]
>
> +       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()
>
> This doesn't really guarantee that when the service itself is started,
> the port will be available, so we can as well not do it.

it doesn't guarantee it, but it does mean that we can return
an early error rather than relying on the server to print
the error somewhere at some unspecified later time.
i found it very useful when testing.

i wonder if the Start should print stdout and stderr from
the server for the first half second or so after it's been started.
that's a possible solution, but makes things slower.

> [5]
>
> +// Process returns a reference to the identity
> +// of the last running server in the Service's directory.
> +// If the server was shut down, it returns (nil, nil).
>
> This shouldn't be in a generic service API.  What if there
> are multiple processes handled by the service?

my plan was to change things so the server is started in
its own process group or sess...

Unmerged revisions

23. By Roger Peppe on 2011-10-03

Factored out server running code into a separate package.

22. By Roger Peppe on 2011-10-03

Fix Server code.

21. By Gustavo Niemeyer on 2011-09-24

The package location is now http://launchpad.net/gozk/zk.

The shorter package name makes for significantly more digestible line lengths.

20. By Gustavo Niemeyer on 2011-09-24

Merged clean-up-interface branch, by Roger Peppe [r=niemeyer]

This branch does a number of incompatible changes that improve
the overall API of gozk.

=== modified file 'Makefile'
--- Makefile	2011-08-03 01:56:58 +0000
+++ Makefile	2011-10-03 15:02:28 +0000
@@ -2,10 +2,13 @@
 
 all: package
 
-TARG=gozk
+TARG=launchpad.net/gozk/zk
 
+GOFILES=\
+	server.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-03 15:02: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-03 15:02:28 +0000
@@ -0,0 +1,202 @@
+package zk_test
+
+import (
+	"bufio"
+	. "launchpad.net/gocheck"
+	"launchpad.net/gozk/zk/service"
+	"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 {
+	s, err := zk.AttachServer(runDir)
+	if err != nil {
+		return fmt.Errorf("cannot attach to server at %q: %v", runDir, err)
+	}
+	srv := service.New(s)
+	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 = service.New(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.
+	a, err := zk.AttachServer(s.zkTestRoot)
+	c.Assert(err, IsNil)
+	srv := service.New(a)
+
+	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.
+	a, err := zk.AttachServer(s.zkTestRoot)
+	c.Assert(err, IsNil)
+	srv := service.New(a)
+	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)
+}
\ No newline at end of file

=== modified file 'retry_test.go'
--- retry_test.go	2011-08-19 01:51:37 +0000
+++ retry_test.go	2011-10-03 15:02: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 'server.go'
--- server.go	1970-01-01 00:00:00 +0000
+++ server.go	2011-10-03 15:02:28 +0000
@@ -0,0 +1,239 @@
+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
+	installDir string
+}
+
+func (srv *Server) Directory() string {
+	return srv.runDir
+}
+
+// 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 installDir.
+// If this is empty, a system default will be used.
+//
+// CreateServer does not start the server - the *Server that
+// is returned can be used with the service package, for example:
+// see launchpad.net/gozk/zk/service.
+func CreateServer(port int, runDir, installDir string) (*Server, os.Error) {
+	if err := os.Mkdir(runDir, 0777); err != nil {
+		return nil, err
+	}
+	srv := &Server{runDir: runDir, installDir: installDir}
+	if err := srv.writeLog4JConfig(); err != nil {
+		return nil, err
+	}
+	if err := srv.writeZooKeeperConfig(port); err != nil {
+		return nil, err
+	}
+	if err := srv.writeInstallDir(); 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.readInstallDir(); err != nil {
+		return nil, fmt.Errorf("cannot read server install directory: %v", err)
+	}
+	return srv, nil
+}
+
+func (srv *Server) path(name string) string {
+	return filepath.Join(srv.runDir, name)
+}
+
+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
+}
+
+// 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) {
+	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)
+}
+
+// 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")
+}
+
+func (srv *Server) writeInstallDir() os.Error {
+	return ioutil.WriteFile(srv.path("installdir.txt"), []byte(srv.installDir+"\n"), 0666)
+}
+
+func (srv *Server) readInstallDir() os.Error {
+	data, err := ioutil.ReadFile(srv.path("installdir.txt"))
+	if err != nil {
+		return err
+	}
+	if data[len(data)-1] == '\n' {
+		data = data[0 : len(data)-1]
+	}
+	srv.installDir = string(data)
+	return nil
+}
+
+func (srv *Server) classPath() ([]string, os.Error) {
+	dir := srv.installDir
+	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
+}

=== added directory 'service'
=== added file 'service/Makefile'
--- service/Makefile	1970-01-01 00:00:00 +0000
+++ service/Makefile	2011-10-03 15:02:28 +0000
@@ -0,0 +1,20 @@
+include $(GOROOT)/src/Make.inc
+
+TARG=launchpad.net/gozk/zk/service
+
+GOFILES=\
+	service.go\
+
+GOFMT=gofmt
+BADFMT:=$(shell $(GOFMT) -l $(GOFILES) $(CGOFILES) $(wildcard *_test.go))
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
+
+include $(GOROOT)/src/Make.pkg

=== added file 'service/service.go'
--- service/service.go	1970-01-01 00:00:00 +0000
+++ service/service.go	2011-10-03 15:02:28 +0000
@@ -0,0 +1,160 @@
+// The service package provides support for long-running services.
+package service
+
+import (
+	"os"
+	"fmt"
+	"io/ioutil"
+	"strconv"
+	"path/filepath"
+	"exec"
+	"strings"
+	"time"
+)
+
+// Interface represents a single-process server.
+type Interface interface {
+	// Directory gives the path to the directory containing
+	// the server's configuration and data files. It is assumed that
+	// this exists and can be modified.
+	Directory() string
+
+	// CheckAvailability should return an error if resources
+	// required by the server are not available; for instance
+	// if the server requires a network port which is not free.
+	CheckAvailability() os.Error
+
+	// Command should return a command that can be
+	// used to run the server. The first element of the returned
+	// slice is the executable name; the rest of the elements are
+	// its arguments.
+	Command() ([]string, os.Error)
+}
+
+// Service represents a possibly running server process.
+type Service struct {
+	srv Interface
+}
+
+// New returns a new Service using the given
+// server interface.
+func New(srv Interface) *Service {
+	return &Service{srv}
+}
+
+// Process returns a reference to the identity
+// of the last running server in the Service's directory.
+// If the server was shut down, it returns (nil, nil).
+// The server process may not still be running
+// (for instance if it was terminated abnormally).
+// This function is provided for debugging and testing
+// purposes only.
+func (s *Service) Process() (*os.Process, os.Error) {
+	data, err := ioutil.ReadFile(s.path("pid.txt"))
+	if err != nil {
+		if err, ok := err.(*os.PathError); ok && err.Error == os.ENOENT {
+			return nil, nil
+		}
+		return nil, err
+	}
+	pid, err := strconv.Atoi(string(data))
+	if err != nil {
+		return nil, os.NewError("bad process id found in pid.txt")
+	}
+	return os.FindProcess(pid)
+}
+
+func (s *Service) path(name string) string {
+	return filepath.Join(s.srv.Directory(), name)
+}
+
+// Start starts the server. It returns an error if the server is already running.
+// It stores the process ID of the server in the file "pid.txt"
+// inside the server's directory. Stdout and stderr of the server
+// are similarly written to "log.txt".
+func (s *Service) Start() os.Error {
+	if err := s.srv.CheckAvailability(); err != nil {
+		return err
+	}
+	p, err := s.Process()
+	if p != nil || err != nil {
+		if p != nil {
+			p.Release()
+		}
+		return fmt.Errorf("server may already be running (remove %q to clear)", s.path("pid.txt"))
+	}
+
+	// create 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(s.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 := s.srv.Command()
+	if err != nil {
+		return fmt.Errorf("cannot determine command: %v", err)
+	}
+	cmd := exec.Command(args[0], args[1:]...)
+
+	logf, err := os.OpenFile(s.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 server. It is a no-op if it is already running.
+func (s *Service) Stop() os.Error {
+	p, err := s.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 && !strings.Contains(err.String(), "no such process") {
+		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 err != nil && strings.Contains(err.String(), "no child processes") {
+		// If we can't wait for the server, it's possible that it was running
+		// but not as a child of this process, so give it a little while
+		// to exit. TODO poll with kill(no signal)?
+		time.Sleep(0.5e9)
+	}
+
+	if err := os.Remove(s.path("pid.txt")); err != nil {
+		return fmt.Errorf("cannot remove server process ID file: %v", err)
+	}
+	return nil
+}
+
+// Destroy stops the server, and then removes its
+// directory and all its contents.
+// Warning: this will destroy all data associated with the server.
+func (s *Service) Destroy() os.Error {
+	if err := s.Stop(); err != nil {
+		return err
+	}
+	if err := os.RemoveAll(s.srv.Directory()); err != nil {
+		return err
+	}
+	return nil
+}

=== modified file 'suite_test.go'
--- suite_test.go	2011-08-19 01:43:37 +0000
+++ suite_test.go	2011-10-03 15:02:28 +0000
@@ -1,65 +1,48 @@
-package gozk_test
+package zk_test
 
 import (
 	. "launchpad.net/gocheck"
-	"testing"
-	"io/ioutil"
-	"path"
 	"fmt"
+	"launchpad.net/gozk/zk/service"
+	"launchpad.net/gozk/zk"
 	"os"
-	"gozk"
+	"testing"
 	"time"
 )
 
 func TestAll(t *testing.T) {
-	TestingT(t)
+	if !*reattach {
+		TestingT(t)
+	}
 }
 
 var _ = Suite(&S{})
 
 type S struct {
-	zkRoot      string
-	zkTestRoot  string
-	zkTestPort  int
-	zkServerSh  string
-	zkServerOut *os.File
-	zkAddr      string
+	zkServer   *service.Service
+	zkTestRoot string
+	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 +65,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 +91,38 @@
 	}
 
 	// 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)
+
+	srv, err := zk.CreateServer(port, s.zkTestRoot, "")
+	if err != nil {
+		c.Fatal("Cannot set up server environment: ", err)
+	}
+	s.zkServer = service.New(srv)
+	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.Stop()		// TODO Destroy
 	}
 }

=== renamed file 'gozk.go' => 'zk.go'
--- gozk.go	2011-08-19 01:56:39 +0000
+++ zk.go	2011-10-03 15:02: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,67 @@
 }
 
 // -----------------------------------------------------------------------
-// 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) String() string {
+	return fmt.Sprintf(
+		"{Czxid: %d; Mzxid: %d; CTime: %d; MTime: %d; "+
+		"Version: %d; CVersion: %d; AVersion: %d; "+
+		"EphemeralOwner: %d; DataLength: %d; "+
+		"NumChildren: %d; Pzxid: %d}",
+		stat.Czxid(), stat.Mzxid(), stat.CTime(), stat.MTime(),
+		stat.Version(), stat.CVersion(), stat.AVersion(),
+		stat.EphemeralOwner(), stat.DataLength(),
+		stat.NumChildren(), stat.Pzxid(),
+	)
+}
+
+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 +371,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 +385,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 +459,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 +481,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 +521,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 +562,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 +585,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 +619,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 +633,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 +650,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 +682,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 +694,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 +733,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 +782,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 +791,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 +804,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 +813,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 +851,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 +864,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 +879,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 +896,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 +905,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 +932,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 +944,7 @@
 			return
 		}
 	}
-	ch := zk.watchChannels[watchId]
+	ch := conn.watchChannels[watchId]
 	if ch == nil {
 		return
 	}
@@ -1002,15 +956,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-03 15:02: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,114 @@
 // 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)
-
-	s.StopZK()
+	c.Check(zk.CountPendingWatches(), Equals, 2)
+
+	err = s.zkServer.Stop()
+	c.Assert(err, IsNil)
+
 	time.Sleep(2e9)
-	s.StartZK()
 
-	// The session channel should receive the reconnection notification,
+	err = s.zkServer.Start()
+	c.Assert(err, IsNil)
+ 
+	// 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 +591,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 +633,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)
 }