Esempio n. 1
0
func testMigrate(t *testing.T, dhashes []*Node) {
	for _, d := range dhashes {
		d.Clear()
	}
	var item common.Item
	for i := 0; i < 1000; i++ {
		item.Key = []byte(fmt.Sprint(i))
		item.Value = []byte(fmt.Sprint(i))
		item.Timestamp = 1
		dhashes[0].Put(item)
	}
	common.AssertWithin(t, func() (string, bool) {
		sum := 0
		status := new(bytes.Buffer)
		ordered := dhashAry(dhashes)
		sort.Sort(ordered)
		lastOwned := ordered[len(ordered)-1].Owned()
		ok := true
		for _, d := range ordered {
			sum += d.Owned()
			fmt.Fprintf(status, "%v %v %v\n", d.node.GetBroadcastAddr(), common.HexEncode(d.node.GetPosition()), d.Owned())
			if float64(lastOwned)/float64(d.Owned()) > migrateHysteresis {
				ok = false
			}
			if d.Owned() == 0 {
				ok = false
			}
			lastOwned = d.Owned()
		}
		return string(status.Bytes()), ok && sum == 1000
	}, time.Second*100)
}
Esempio n. 2
0
func testSync(t *testing.T, dhashes []*Node) {
	dhashes[0].tree.Put([]byte{3}, []byte{0}, 1)
	common.AssertWithin(t, func() (string, bool) {
		having := countHaving(t, dhashes, []byte{3}, []byte{0})
		return fmt.Sprint(having), having == common.Redundancy
	}, time.Second*10)
}
Esempio n. 3
0
func testClean(t *testing.T, dhashes []*Node) {
	for _, n := range dhashes {
		n.tree.Put([]byte{1}, []byte{1}, 1)
	}
	common.AssertWithin(t, func() (string, bool) {
		having := countHaving(t, dhashes, []byte{1}, []byte{1})
		return fmt.Sprint(having), having == common.Redundancy
	}, time.Second*20)
}
Esempio n. 4
0
func testPut(t *testing.T, dhashes []*Node) {
	for index, n := range dhashes {
		n.Put(common.Item{Key: []byte{byte(index + 100)}, Timestamp: 1, Value: []byte{byte(index + 100)}})
	}
	common.AssertWithin(t, func() (string, bool) {
		haves := make(map[int]bool)
		for index, _ := range dhashes {
			count := countHaving(t, dhashes, []byte{byte(index + 100)}, []byte{byte(index + 100)})
			haves[count] = true
		}
		return fmt.Sprint(haves), len(haves) == 1 && haves[common.Redundancy] == true
	}, time.Second*10)
}
Esempio n. 5
0
func assertMirrored(t *testing.T, dhashes []*Node, c testClient, subTree []byte) {
	common.AssertWithin(t, func() (string, bool) {
		for _, n := range dhashes {
			var conf common.Conf
			n.SubConfiguration(subTree, &conf)
			var s int
			n.SubSize(subTree, &s)
			if s > 0 {
				if conf.Data["mirrored"] != "yes" {
					return fmt.Sprint(n, conf.Data), false
				}
			}
		}
		return "", true
	}, time.Second*10)
}
Esempio n. 6
0
func TestSample(t *testing.T) {
	producer := newTestPeerProducer()
	peer1 := producer.makePeer()
	peer2 := producer.makePeer()
	peer3 := producer.makePeer()
	peer4 := producer.makePeer()
	producer.add("1", peer1)
	producer.add("2", peer2)
	producer.add("3", peer3)
	producer.add("4", peer4)
	peer1.Start()
	peer2.Start()
	peer3.Start()
	peer4.Start()
	common.AssertWithin(t, func() (string, bool) {
		d := producer.deviance()
		return fmt.Sprint(d), d > 0 && d < 1000000
	}, time.Second*20)
}
Esempio n. 7
0
func TestStartup(t *testing.T) {
	firstPort := 9191
	var nodes []*Node
	n := 10
	for i := 0; i < n; i++ {
		nodes = append(nodes, NewNode(fmt.Sprintf("%v:%v", "127.0.0.1", firstPort+i), fmt.Sprintf("%v:%v", "127.0.0.1", firstPort+i)))
	}
	for i := 0; i < n; i++ {
		nodes[i].MustStart()
	}
	for i := 1; i < n; i++ {
		nodes[i].MustJoin(nodes[0].GetBroadcastAddr())
	}
	common.AssertWithin(t, func() (string, bool) {
		routes := make(map[string]bool)
		for i := 0; i < n; i++ {
			routes[nodes[i].Nodes().Describe()] = true
		}
		return fmt.Sprint(routes), len(routes) == 1 && nodes[0].ring.Size() > 0
	}, time.Second*30)
}
Esempio n. 8
0
func testStartup(t *testing.T, n, port int) (dhashes []*Node) {
	for i := 0; i < n; i++ {
		os.RemoveAll(fmt.Sprintf("127.0.0.1:%v", port+i*2))
	}
	dhashes = make([]*Node, n)
	for i := 0; i < n; i++ {
		dhashes[i] = NewNode(fmt.Sprintf("127.0.0.1:%v", port+i*2), fmt.Sprintf("127.0.0.1:%v", port+i*2))
		dhashes[i].MustStart()
	}
	for i := 1; i < n; i++ {
		dhashes[i].MustJoin(fmt.Sprintf("127.0.0.1:%v", port))
	}
	common.AssertWithin(t, func() (string, bool) {
		routes := make(map[string]bool)
		for _, dhash := range dhashes {
			routes[dhash.node.GetNodes().Describe()] = true
		}
		return fmt.Sprint(routes), len(routes) == 1
	}, time.Second*10)
	return
}