Ejemplo n.º 1
0
func main() {
	
	c := runtime.NumCPU() * 2
	runtime.GOMAXPROCS(1)
	conn := client.MustConn("")
	argsWithoutProg := os.Args[1:]
	var i info
	common.MustJSONDecode([]byte(argsWithoutProg[0]), &i)
	r := everything.RGet(i.rideID)
	fmt.Println(r.Name)
	p, _ := everything.GetG(append([]byte{0},[]byte{0}[0],[]byte{0}[0]))
	count := 0
	t := true
	fmt.Print("[")
	for i := r.CurTrip; i < len(r.Times); i++ {
		if r.Capacity - r.Capacities[i] > 2 {
			a := r.GetTimeRange(i)
			for j := 0; j < len(p.Times); j++ {
				if between(a[0], a[1], p.Times[j][0], p.Times[j][1]) {
					t = false
				}
			}
			if t {
				conn.Put([]byte(strconv.Itoa(i)),common.MustJSONEncode(p.Times[j]))
				conn.Put([]byte(strconv.Itoa(i) + "r"),common.MustJSONEncode(r.K)
				fmt.Print("{" + r.Name + ":" + " [" + getTime(p.Times[j][0]) + "," + getTime(p.Times[j][1]) + "],id:" + strconv.Itoa(i) +  "},")
				count += 1
			}
		}
		if count == 3 { break }
	}
	fmt.Print("]")


}
Ejemplo n.º 2
0
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)
}
Ejemplo n.º 3
0
func main() {
	a := (s(3, 30, 50, 20, 27))
	fmt.Println(a)
	fmt.Println(a)
	conn := client.MustConn("localhost:9191")
	bytes := common.MustJSONEncode(a)
	conn.Put(murmur.HashString("hi"), bytes)
}
Ejemplo n.º 4
0
func main() {
	// connect to the default local server
	conn := client.MustConn("localhost:9191")
	// create a user

	// try to fetch the user again
	data, _ := conn.Get(murmur.HashString("hi"))
	var found []int
	// to unserialize it
	common.MustJSONDecode(data, &found)
	fmt.Printf("stored and found ", found)
}
Ejemplo n.º 5
0
//
// Puts a lifter (stored in the all lifters tree) together with best competition score, in ranking trees that are relevant
//
func PutLifterInRankingTrees(lifterItem common.Item) {

	conn := client.MustConn("localhost:9191")

	var lifterCompetitionItems []common.Item = conn.SliceIndex(lifterItem.Key, nil, nil) // Get all competitions under given lifter

	var lifter Lifter

	if err := json.Unmarshal(lifterItem.Value, &lifter); err != nil {
		panic(err)
	}

	var sinclairScores SinclairScoreByCategory = sortCompetitionRankingsByCategory(lifter, lifterCompetitionItems)

	if lifter.Sex == "female" {
		if sinclairScores.Youth != 0.0 {
			conn.SubPut(youthWomenRankingKey, lifterItem.Key, common.EncodeFloat64(sinclairScores.Youth))
		}

		if sinclairScores.Junior != 0.0 {
			conn.SubPut(juniorWomenRankingKey, lifterItem.Key, common.EncodeFloat64(sinclairScores.Junior))
		}

		if sinclairScores.Senior != 0.0 {
			conn.SubPut(seniorWomenRankingKey, lifterItem.Key, common.EncodeFloat64(sinclairScores.Senior))
		}

		if sinclairScores.Veteran != 0.0 {
			conn.SubPut(veteranWomenRankingKey, lifterItem.Key, common.EncodeFloat64(sinclairScores.Veteran))
		}
	} else { // Mens categories
		if sinclairScores.Youth != 0.0 {
			conn.SubPut(youthMenRankingKey, lifterItem.Key, common.EncodeFloat64(sinclairScores.Youth))
		}

		if sinclairScores.Junior != 0.0 {
			conn.SubPut(juniorMenRankingKey, lifterItem.Key, common.EncodeFloat64(sinclairScores.Junior))
		}

		if sinclairScores.Senior != 0.0 {
			conn.SubPut(seniorMenRankingKey, lifterItem.Key, common.EncodeFloat64(sinclairScores.Senior))
		}

		if sinclairScores.Veteran != 0.0 {
			conn.SubPut(veteranMenRankingKey, lifterItem.Key, common.EncodeFloat64(sinclairScores.Veteran))
		}
	}
}
Ejemplo n.º 6
0
func (self *Slave) Prepare(command PrepareCommand, x *Nothing) error {
	if self.hasState(stopped) {
		fmt.Printf("Preparing %+v\n", command)
		self.client = client.MustConn(command.Addr)
		var kv []byte
		for i := command.Range[0]; i < command.Range[1]; i++ {
			kv = murmur.HashInt64(i)
			self.client.Put(kv, kv)
			if i%1000 == 0 {
				fmt.Print(".")
			}
		}
		fmt.Println("done!")
	}
	return nil
}
Ejemplo n.º 7
0
func (self *Slave) Spin(command SpinCommand, result *SpinResult) error {
	if self.switchState(stopped, started) {
		fmt.Println("Spinning on ", command.Addr)
		self.wg = new(sync.WaitGroup)
		self.wg.Add(1)
		self.maxRps = 0
		self.client = client.MustConn(command.Addr)
		self.maxKey = command.MaxKey
		go self.run()
	} else {
		fmt.Println("Already started on", self.addr)
	}
	*result = SpinResult{
		Nodes: len(self.client.Nodes()),
		Keys:  self.client.Size(),
	}
	return nil
}
Ejemplo n.º 8
0
func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())
	flag.Parse()
	if *dir == address {
		*dir = fmt.Sprintf("%v:%v", *broadcastIp, *port)
	}
	s := dhash.NewNodeDir(fmt.Sprintf("%v:%v", *listenIp, *port), fmt.Sprintf("%v:%v", *broadcastIp, *port), *dir)
	s.MustStart()
	if *joinIp != "" {
		s.MustJoin(fmt.Sprintf("%v:%v", *joinIp, *joinPort))
	}

	c := client.MustConn(s.GetListenAddr())
	c.Start()

	setupUDPService(c)
	setupJSONService(c)
}
Ejemplo n.º 9
0
//
// Print ranking with only lifter Id and sinclair score
//
func PrintSimpleRanking() {

	conn := client.MustConn("localhost:9191")

	fmt.Println("Womens youth ranking")
	for _, scoreBox := range conn.MirrorSliceIndex(youthWomenRankingKey, nil, nil) {
		fmt.Println(string(scoreBox.Value), common.MustDecodeFloat64(scoreBox.Key))
	}

	fmt.Println("\nWomens junior ranking")
	for _, scoreBox := range conn.MirrorSliceIndex(juniorWomenRankingKey, nil, nil) {
		fmt.Println(string(scoreBox.Value), common.MustDecodeFloat64(scoreBox.Key))
	}

	fmt.Println("\nWomens senior ranking")
	for _, scoreBox := range conn.MirrorSliceIndex(seniorWomenRankingKey, nil, nil) {
		fmt.Println(string(scoreBox.Value), common.MustDecodeFloat64(scoreBox.Key))
	}

	fmt.Println("\nWomens senior ranking")
	for _, scoreBox := range conn.MirrorSliceIndex(veteranWomenRankingKey, nil, nil) {
		fmt.Println(string(scoreBox.Value), common.MustDecodeFloat64(scoreBox.Key))
	}

	fmt.Println("\nMens youth ranking")
	for _, scoreBox := range conn.MirrorSliceIndex(youthMenRankingKey, nil, nil) {
		fmt.Println(string(scoreBox.Value), common.MustDecodeFloat64(scoreBox.Key))
	}

	fmt.Println("\nMens junior ranking")
	for _, scoreBox := range conn.MirrorSliceIndex(juniorMenRankingKey, nil, nil) {
		fmt.Println(string(scoreBox.Value), common.MustDecodeFloat64(scoreBox.Key))
	}

	fmt.Println("\nMens senior ranking")
	for _, scoreBox := range conn.MirrorSliceIndex(seniorMenRankingKey, nil, nil) {
		fmt.Println(string(scoreBox.Value), common.MustDecodeFloat64(scoreBox.Key))
	}

	fmt.Println("\nMens senior ranking")
	for _, scoreBox := range conn.MirrorSliceIndex(veteranMenRankingKey, nil, nil) {
		fmt.Println(string(scoreBox.Value), common.MustDecodeFloat64(scoreBox.Key))
	}
}
Ejemplo n.º 10
0
func BenchmarkClientAndServer(b *testing.B) {
	oldprocs := runtime.GOMAXPROCS(runtime.NumCPU())
	defer runtime.GOMAXPROCS(oldprocs)
	b.StopTimer()
	if benchNode == nil {
		benchNode = NewNode("127.0.0.1:1231", "127.0.0.1:1231")
		benchNode.MustStart()
	}
	c := client.MustConn("127.0.0.1:1231")
	c.Clear()
	var bs [][]byte
	for i := 0; i < b.N; i++ {
		bs = append(bs, murmur.HashString(fmt.Sprint(i)))
	}
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		c.Put(bs[i], bs[i])
	}
}
Ejemplo n.º 11
0
//
// Initial proof of concept
// Uses faked data
//
func ProofOfConcept() {

	competitionResults, lifters := ReadCsvFile()

	competitionResults2 := competitionResults

	conn := client.MustConn("localhost:9191")

	for index, lifter := range lifters {

		var lifterKey = []byte(lifter.Id)

		if _, exists := conn.SubGet(allLiftersKey, lifterKey); !exists { // Check if the lifter exists in the database already
			if serializedLifter, err := json.Marshal(lifter); err != nil {
				panic(err)
			} else {
				conn.SubPut(allLiftersKey, lifterKey, serializedLifter) // Put lifter in all lifters tree
			}
		}

		if serializedCompetitionResults, err := json.Marshal(competitionResults[index]); err != nil {
			panic(err)
		} else {
			conn.SubPut(lifterKey, []byte(fmt.Sprint(index)), serializedCompetitionResults) // Competition result put in lifter subtree
		}

		if serializedCompetitionResults2, err := json.Marshal(competitionResults2[index]); err != nil {
			panic(err)
		} else {
			competitionResults2[index].Snatch = competitionResults[index].Snatch + 1
			conn.SubPut(lifterKey, []byte(fmt.Sprint(index*2+1)), serializedCompetitionResults2) // Faking extra competitions per lifter
		}
	}

	// Go through all lifters under the All Lifters tree
	for _, lifterItem := range conn.SliceIndex(allLiftersKey, nil, nil) {

		PutLifterInRankingTrees(lifterItem)
	}

	PrintSimpleRanking()
}
Ejemplo n.º 12
0
func ExampleTreeMirror() {
	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"), setop.EncodeFloat64(10))
	conn.SubPut([]byte("myfriends"), []byte("bob"), setop.EncodeFloat64(5))
	conn.SubPut([]byte("myfriends"), []byte("charlie"), setop.EncodeFloat64(6))
	conn.SubPut([]byte("myfriends"), []byte("denise"), setop.EncodeFloat64(4))
	fmt.Printf("name score\n")
	for _, friend := range conn.MirrorReverseSlice([]byte("myfriends"), nil, nil, true, true) {
		fmt.Printf("%v %v\n", fmt.Sprint(setop.DecodeFloat64(friend.Key)), string(friend.Value))
	}
	// Output:
	// name score
	// 10 <nil> alice
	// 6 <nil> charlie
	// 5 <nil> bob
	// 4 <nil> denise
}
Ejemplo n.º 13
0
func ExampleSetExpression() {
	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"), setop.EncodeFloat64(10))
	conn.SubPut([]byte("myfriends"), []byte("bob"), setop.EncodeFloat64(5))
	conn.SubPut([]byte("yourfriends"), []byte("bob"), setop.EncodeFloat64(6))
	conn.SubPut([]byte("yourfriends"), []byte("charlie"), setop.EncodeFloat64(4))
	fmt.Printf("name score\n")
	for _, friend := range conn.SetExpression(setop.SetExpression{
		Code: "(U:FloatSum myfriends yourfriends)",
	}) {
		fmt.Printf("%v %v\n", string(friend.Key), fmt.Sprint(setop.DecodeFloat64(friend.Values[0])))
	}
	// Output:
	// name score
	// alice 10 <nil>
	// bob 11 <nil>
	// charlie 4 <nil>
}
Ejemplo n.º 14
0
func main() {
	//c := runtime.NumCPU() * 2
	runtime.GOMAXPROCS(1)
	conn := client.MustConn("")
	argsWithoutProg := os.Args[1:]
	var i info
	common.MustJSONDecode([]byte(argsWithoutProg[0]), &i)
	s := strings.Split(string(i.times), "id:")[1]
	s = strings.Split(s, "}")[0]
	var time []int
	v, _ := conn.Get([]byte(s))
	common.MustJSONDecode(v, &time)
	p, _ := everything.GetG(append([]byte{0}, []byte{0}[0], []byte{0}[0]))
	p.Times = append(p.Times, time)

	var ri []byte
	v, _ = conn.Get([]byte(s + "r"))
	common.MustJSONDecode(v, &ri)
	p.AppointRide = append(p.AppointRide, ri)

	p.Save()
}
Ejemplo n.º 15
0
func main() {
	flag.Parse()
	conn := client.MustConn(fmt.Sprintf("%v:%v", *ip, *port))
	if len(flag.Args()) == 0 {
		show(conn)
	} else {
		for spec, fun := range actions {
			if spec.cmd == flag.Args()[0] {
				matchingParts := true
				for index, reg := range spec.args {
					if !reg.MatchString(flag.Args()[index+1]) {
						matchingParts = false
						break
					}
				}
				if matchingParts {
					fun(conn, flag.Args())
					return
				}
			}
		}
		fmt.Println("No command given?")
	}
}
Ejemplo n.º 16
0
func testGOBClient(t *testing.T, dhashes []*Node) {
	clearAll(dhashes)
	c := client.MustConn(dhashes[0].GetAddr())
	c.Start()
	testClientInterface(t, dhashes, c)
}
Ejemplo n.º 17
0
//
// Preps database structures
//
func PrepDatabase() {
	conn := client.MustConn("localhost:9191")
	conn.SubAddConfiguration(seniorWomenRankingKey, "mirrored", "yes")
	conn.SubAddConfiguration(seniorMenRankingKey, "mirrored", "yes")
}