improved the test suite

client/client_test.go → client/examples/example_test.go

@@ -2,13 +2,19 @@ package client
 
 import (
 	"fmt"
+
+	"github.com/zond/god/client"
 	"github.com/zond/god/common"
+	"github.com/zond/god/dhash"
 	"github.com/zond/setop"
 )
 
+var ran = false
+
 func ExampleSetExpression() {
-	conn := MustConn("127.0.0.1:9191")
-	conn.Kill()
+	server := dhash.NewNodeDir("127.0.0.1:2020", "127.0.0.1:2020", "").MustStart()
+	defer server.Stop()
+	conn := client.MustConn("127.0.0.1:2020")
 	conn.SubPut([]byte("myfriends"), []byte("alice"), common.EncodeFloat64(10))
 	conn.SubPut([]byte("myfriends"), []byte("bob"), common.EncodeFloat64(5))
 	conn.SubPut([]byte("yourfriends"), []byte("bob"), common.EncodeFloat64(6))
@@ -27,8 +33,9 @@ func ExampleSetExpression() {
 }
 
 func ExampleTreeMirror() {
-	conn := MustConn("127.0.0.1:9191")
-	conn.Kill()
+	server := dhash.NewNodeDir("127.0.0.1:3030", "127.0.0.1:3030", "").MustStart()
+	defer server.Stop()
+	conn := client.MustConn("127.0.0.1:3030")
 	conn.SubAddConfiguration([]byte("myfriends"), "mirrored", "yes")
 	conn.SubPut([]byte("myfriends"), []byte("alice"), common.EncodeFloat64(10))
 	conn.SubPut([]byte("myfriends"), []byte("bob"), common.EncodeFloat64(5))

dhash/client_test.go

@@ -3,15 +3,16 @@ package dhash
 import (
 	"bytes"
 	"fmt"
-	"github.com/zond/god/client"
-	"github.com/zond/god/common"
-	"github.com/zond/god/murmur"
-	"github.com/zond/setop"
 	"math/big"
 	"net"
 	"runtime"
 	"testing"
 	"time"
+
+	"github.com/zond/god/client"
+	"github.com/zond/god/common"
+	"github.com/zond/god/murmur"
+	"github.com/zond/setop"
 )
 
 type testClient interface {
@@ -113,6 +114,7 @@ func TestClient(t *testing.T) {
 	dhashes := testStartup(t, common.Redundancy*2, 11191)
 	testGOBClient(t, dhashes)
 	testJSONClient(t, dhashes)
+	stopServers(dhashes)
 }
 
 func clearAll(dhashes []*Node) {
@@ -122,13 +124,15 @@ func clearAll(dhashes []*Node) {
 }
 
 func testGOBClient(t *testing.T, dhashes []*Node) {
+	fmt.Println(" === Run testGOBClient")
 	clearAll(dhashes)
 	c := client.MustConn(dhashes[0].GetBroadcastAddr())
 	c.Start()
 	testClientInterface(t, dhashes, c)
 }
 
 func testJSONClient(t *testing.T, dhashes []*Node) {
+	fmt.Println(" === Run testJSONClient")
 	for _, dhash := range dhashes {
 		clearAll(dhashes)
 		addr, err := net.ResolveTCPAddr("tcp", dhash.node.GetBroadcastAddr())
@@ -141,20 +145,33 @@ func testJSONClient(t *testing.T, dhashes []*Node) {
 }
 
 func testClientInterface(t *testing.T, dhashes []*Node, c testClient) {
+	fmt.Println("  === Run testGetPutDel")
 	testGetPutDel(t, c)
+	fmt.Println("  === Run testSubGetPutDel")
 	testSubGetPutDel(t, c)
+	fmt.Println("  === Run testSubClear")
 	testSubClear(t, c)
+	fmt.Println("  === Run testIndices")
 	testIndices(t, dhashes, c)
 	if rc, ok := c.(*client.Conn); ok {
+		fmt.Println("  === Run testDump")
 		testDump(t, rc)
+		fmt.Println("  === Run testSubDump")
 		testSubDump(t, rc)
 	}
+	fmt.Println("  === Run testNextPrev")
 	testNextPrev(t, c)
+	fmt.Println("  === Run testCounts")
 	testCounts(t, dhashes, c)
+	fmt.Println("  === Run testNextPrevIndices")
 	testNextPrevIndices(t, dhashes, c)
+	fmt.Println("  === Run testSlices")
 	testSlices(t, dhashes, c)
+	fmt.Println("  === Run testSliceIndices")
 	testSliceIndices(t, dhashes, c)
+	fmt.Println("  === Run testSliceLen")
 	testSliceLen(t, dhashes, c)
+	fmt.Println("  === Run testSetExpression")
 	testSetExpression(t, c)
 }
 

dhash/json_client.go

@@ -4,18 +4,24 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os/exec"
+
 	"github.com/zond/god/common"
 	"github.com/zond/setop"
-	"net/http"
 )
 
 // JSONClient is used in the tests to ensure that the JSON API provides roughly the same functionality as the gob API.
 // It is also a demonstration and example of how the JSON API can be used.
 // It is NOT meant to be used as a real client, since if you are using Go anyway the client.Conn type is much more efficient.
 type JSONClient string
 
+var jsonClient = &http.Client{}
+
+var lastOpen int32 = 0
+
 func (self JSONClient) call(action string, params, result interface{}) {
-	client := new(http.Client)
 	buf := new(bytes.Buffer)
 	if params != nil {
 		err := json.NewEncoder(buf).Encode(params)
@@ -28,14 +34,20 @@ func (self JSONClient) call(action string, params, result interface{}) {
 		panic(err)
 	}
 	req.Header.Set("Accept", "application/json")
-	resp, err := client.Do(req)
+	resp, err := jsonClient.Do(req)
 	if err != nil {
+		outp, e := exec.Command("sysctl", "kern.num_files").Output()
+		if e != nil {
+			panic(e)
+		}
+		fmt.Println(string(outp))
 		panic(err)
 	}
 	err = json.NewDecoder(resp.Body).Decode(result)
 	if err != nil {
 		panic(err)
 	}
+	ioutil.ReadAll(resp.Body)
 	resp.Body.Close()
 }
 func (self JSONClient) SSubPut(key, subKey, value []byte) {

discord/node.go

@@ -3,13 +3,15 @@ package discord
 import (
 	"bytes"
 	"fmt"
-	"github.com/zond/god/common"
-	"github.com/zond/god/murmur"
 	"net"
 	"net/rpc"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
+
+	"github.com/zond/god/common"
+	"github.com/zond/god/murmur"
 )
 
 // CommListener is a function listening for generic communication between two Nodes.
@@ -206,11 +208,20 @@ func (self *Node) Start() (err error) {
 		}
 	}
 	self.ring.Add(self.Remote())
-	go server.Accept(self.getListener())
+	go func() {
+		var conn net.Conn
+		for conn, err = self.getListener().Accept(); err == nil; conn, err = self.getListener().Accept() {
+			go server.ServeConn(conn)
+		}
+		if !strings.Contains(err.Error(), "use of closed network connection") {
+			panic(err)
+		}
+	}()
 	go self.notifyPeriodically()
 	go self.pingPeriodically()
 	return
 }
+
 func (self *Node) notifyPeriodically() {
 	for self.hasState(started) {
 		self.notifySuccessor()

timenet/timenet_test.go

@@ -2,11 +2,12 @@ package timenet
 
 import (
 	"fmt"
-	"github.com/zond/god/common"
 	"math"
 	"math/rand"
 	"testing"
 	"time"
+
+	"github.com/zond/god/common"
 )
 
 func init() {
@@ -78,5 +79,5 @@ func TestSample(t *testing.T) {
 	common.AssertWithin(t, func() (string, bool) {
 		d := producer.deviance()
 		return fmt.Sprint(d), d > 0 && d < 1000000
-	}, time.Second*10)
+	}, time.Second*20)
 }