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

[Roger Peppe]

Update documentation.

Add more complete description of event delivery and comments
on Stat field accessors.

[Gustavo Niemeyer (niemeyer)]

This is a massive change unrelated to documentation.

[Roger Peppe (rogpeppe)]

this was a while ago. i didn't know how to handle the review system...

i think the intended changes are still worth making. i'll make a CL.
i could also use that proposal to change appropriate methods
to return a time.Time if that seems reasonable (e.g. Stat.CTime etc)

On 10 February 2012 12:27, Gustavo Niemeyer <email address hidden> wrote:
> The proposal to merge lp:~rogpeppe/gozk/update-documentation into lp:gozk has been updated.
>
>    Status: Needs review => Rejected
>
> For more details, see:
> https://code.launchpad.net/~rogpeppe/gozk/update-documentation/+merge/77980
> --
> https://code.launchpad.net/~rogpeppe/gozk/update-documentation/+merge/77980
> You are the owner of lp:~rogpeppe/gozk/update-documentation.

Unmerged revisions

24. By Roger Peppe on 2011-10-03

Update documentation to include more accurate
description of events and comments on stat field accessors.

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 17:02:23 +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 17:02:23 +0000
@@ -1,30 +1,29 @@
 package main
 
 import (
-    "gozk"
+	"launchpad.net/zookeeper/zookeeper"
 )
 
 func main() {
-    zk, session, err := gozk.Init("localhost:2181", 5000)
-    if err != nil {
-        println("Couldn't connect: " + err.String())
-        return
-    }
-
-    defer zk.Close()
-
-    // Wait for connection.
-    event := <-session
-    if event.State != gozk.STATE_CONNECTED {
-        println("Couldn't connect")
-        return
-    }
-
-    _, err = zk.Create("/counter", "0", 0, gozk.WorldACL(gozk.PERM_ALL))
-    if err != nil {
-        println(err.String())
-    } else {
-        println("Created!")
-    }
+	zk, session, err := zookeeper.Init("localhost:2181", 5000)
+	if err != nil {
+		println("Couldn't connect: " + err.String())
+		return
+	}
+
+	defer zk.Close()
+
+	// Wait for connection.
+	event := <-session
+	if event.State != zookeeper.STATE_CONNECTED {
+		println("Couldn't connect")
+		return
+	}
+
+	_, err = zk.Create("/counter", "0", 0, zookeeper.WorldACL(zookeeper.PERM_ALL))
+	if err != nil {
+		println(err.String())
+	} else {
+		println("Created!")
+	}
 }
-
 
=== added file 'reattach_test.go'
--- reattach_test.go	1970-01-01 00:00:00 +0000
+++ reattach_test.go	2011-10-03 17:02:23 +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 17:02:23 +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 17:02:23 +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 17:02:23 +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 17:02:23 +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 17:02:23 +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 17:02:23 +0000
@@ -1,4 +1,4 @@
-// gozk - Zookeeper support for the Go language
+// gozk - ZooKeeper support for the Go language
 //
 //   https://wiki.ubuntu.com/gozk
 //
@@ -6,7 +6,7 @@
 //
 // Written by Gustavo Niemeyer <[e-mail]>
 //
-package gozk
+package 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
 }
@@ -59,25 +58,21 @@
 // through one of the W-suffixed functions (GetW, ExistsW, etc).
 // 
 // The session channel will only receive session-level events notifying
-// about critical and transient changes in the ZooKeeper connection
-// state (STATE_CONNECTED, STATE_EXPIRED_SESSION, etc).  On long
-// running applications the session channel must *necessarily* be
-// observed since certain events like session expirations require an
-// explicit reconnection and reestablishment of state (or bailing out).
-// Because of that, the buffer used on the session channel has a limited
-// size, and a panic will occur if too many events are not collected.
+// about changes in the ZooKeeper connection state (STATE_CONNECTED,
+// STATE_EXPIRED_SESSION, etc).  On long running applications the session
+// channel must *necessarily* be observed since certain events like session
+// expirations require an explicit reconnection and reestablishment of
+// state (or bailing out).  Because of that, the buffer used on the session
+// channel has a limited size, and a panic will occur if too many events
+// are not collected.
 //
 // Watch channels enable monitoring state for nodes, and the
 // moment they're fired depends on which function was called to
-// create them.  Note that, unlike in other ZooKeeper interfaces,
-// gozk will NOT dispatch unimportant session events such as
-// STATE_ASSOCIATING, STATE_CONNECTING and STATE_CONNECTED to
-// watch Event channels, since they are transient and disruptive
-// to the workflow.  Critical state changes such as expirations
-// are still delivered to all event channels, though, and the
-// transient events may be obsererved in the session channel.
+// create them.  Two critical session events, STATE_EXPIRED_SESSION
+// and STATE_EXPIRED_SESSION, will be delivered to all
+// node watch channels if they occur.
 //
-// Since every watch channel may receive critical session events, events
+// Since every watch channel may receive these critical session events, events
 // received must not be handled blindly as if the watch requested has
 // been fired.  To facilitate such tests, Events offer the Ok method,
 // and they also have a good String method so they may be used as an
@@ -89,44 +84,78 @@
 //         return
 //     }
 //
-// Note that closed channels will deliver zeroed Event, which means
+// Note that closed channels will deliver a zeroed Event, which means
 // event.Type is set to EVENT_CLOSED and event.State is set to STATE_CLOSED,
 // to facilitate handling.
 type Event struct {
-	Type  int
-	Path  string
+	// Type gives the type of event (one of the EVENT_* constants).
+	// If Type is EVENT_SESSION, then the events is a session
+	// event.
+	Type int
+
+	// For non-session events, Path gives the path of the node
+	// that was being watched.
+	Path string
+
+	// For session events, State (one of the STATE* constants) gives the session
+	// status.
 	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
@@ -141,8 +170,8 @@
 
 // Constants for Create's flags parameter.
 const (
-	EPHEMERAL = 1 << iota
-	SEQUENCE
+	EPHEMERAL = 1 << iota // The node will be deleted when the current session ends.
+	SEQUENCE              // Append a sequence number to the node name.
 )
 
 // Constants for ACL Perms.
@@ -273,104 +302,79 @@
 }
 
 // -----------------------------------------------------------------------
-// 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(),
+	)
+}
+
+// Czxid returns the zxid of the change that caused the node to be created.
+func (stat *Stat) Czxid() int64 {
+	return int64(stat.c.czxid)
+}
+
+// Mzxid returns the zxid of the change that last modified the node.
+func (stat *Stat) Mzxid() int64 {
+	return int64(stat.c.mzxid)
+}
+
+// CTime returns the time in milliseconds from epoch when the node was created.
+func (stat *Stat) CTime() int64 {
+	return int64(stat.c.ctime)
+}
+
+// MTime returns the time in milliseconds from epoch when the node was last modified.
+func (stat *Stat) MTime() int64 {
+	return int64(stat.c.mtime)
+}
+
+// Version returns the number of changes to the data of the node.
+func (stat *Stat) Version() int32 {
+	return int32(stat.c.version)
+}
+
+// CVersion returns the number of changes to the children of the node.
+func (stat *Stat) CVersion() int32 {
+	return int32(stat.c.cversion)
+}
+
+// AVersion returns the number of changes to the ACL of the node.
+func (stat *Stat) AVersion() int32 {
+	return int32(stat.c.aversion)
+}
+
+// If the node is an ephemeral node, EphemeralOwner returns the session id
+// of the owner of the node; otherwise it will return zero.
+func (stat *Stat) EphemeralOwner() int64 {
+	return int64(stat.c.ephemeralOwner)
+}
+
+// DataLength returns the length of the data in the node in bytes.
+func (stat *Stat) DataLength() int32 {
+	return int32(stat.c.dataLength)
+}
+
+// NumChildren returns the number of children of the znode.
+func (stat *Stat) NumChildren() int32 {
+	return int32(stat.c.numChildren)
+}
+
+// Pzxid returns the Pzxid of the node, whatever that is.
+func (stat *Stat) Pzxid() int64 {
+	return int64(stat.c.pzxid)
 }
 
 // -----------------------------------------------------------------------
@@ -380,11 +384,13 @@
 
 // SetLogLevel changes the minimum level of logging output generated
 // to adjust the amount of information provided.
+// The default is LOG_ERROR. If level is zero, no logging output
+// will be generated.
 func SetLogLevel(level int) {
 	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 +404,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 +478,22 @@
 	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) {
+// a single Event value, with Type EVENT_CHANGED or EVENT_DELETED,
+// when the node contents change or it is deleted.
+// It will also receive a critical session event if the server goes down.
+// See the documentation of the Event type for more details.
+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,73 +501,69 @@
 	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
 }
 
 // ChildrenW works like Children but also returns a channel that will
-// 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) {
+// receive a single Event value when a child of the given path is
+// added or removed (EVENT_CHILD), or when the path node itself is
+// deleted (EVENT_DELETED).
+// It will also receive a critical session event if the server goes down.
+// See the documentation of the Event type for more details.
+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,51 +584,51 @@
 // 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
 }
 
 // ExistsW works like Exists but also returns a channel that will
-// receive an Event value when a node is created in case the returned
-// 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) {
+// receive a single Event, with Type EVENT_CREATED, EVENT_DELETED
+// or EVENT_CHANGED, when the node is next created, removed,
+// or its contents change.
+// It will also receive a critical session event if the server goes down.
+// See the documentation of the Event type for more details.
+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 +642,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 +656,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 +673,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 +705,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 +717,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 +756,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 +805,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 +814,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 +827,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 +836,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 +874,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 +887,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 +902,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 +919,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 +928,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 +955,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 +967,7 @@
 			return
 		}
 	}
-	ch := zk.watchChannels[watchId]
+	ch := conn.watchChannels[watchId]
 	if ch == nil {
 		return
 	}
@@ -1002,15 +979,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 17:02:23 +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)
 }