Example #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)
}
Example #2
0
func (self *Node) SetExpression(expr setop.SetExpression, items *[]setop.SetOpResult) (err error) {
	if expr.Dest != nil {
		if expr.Op.Merge == setop.Append {
			err = fmt.Errorf("When storing results of Set expressions the Append merge function is not allowed")
			return
		}
		successor := self.node.GetSuccessorFor(expr.Dest)
		if successor.Addr != self.node.GetBroadcastAddr() {
			return successor.Call("DHash.SetExpression", expr, items)
		}
	}
	data := common.Item{
		Key: expr.Dest,
	}
	err = expr.Each(func(b []byte) (result setop.Skipper, err error) {
		succ := self.node.GetSuccessorFor(b)
		res := &treeSkipper{
			remote: succ,
			key:    b,
		}
		if succ.Addr == self.node.GetBroadcastAddr() {
			res.tree = self.tree
		}
		result = res
		return
	}, func(res *setop.SetOpResult) {
		if expr.Dest == nil {
			*items = append(*items, *res)
		} else {
			data.SubKey = res.Key
			data.Value = res.Values[0]
			data.TTL = self.node.Redundancy()
			data.Timestamp = self.timer.ContinuousTime()
			self.subPut(data)
		}
	})
	return
}