Esempio n. 1
0
func main() {

	client, err := proxy.NewWithDefaultConfig().ServantByAddr(":9001")
	if err != nil {
		panic(err)
	}
	defer client.Recycle()

	ctx := rpc.NewContext()
	ctx.Reason = "go.duplex"
	ctx.Rid = 189
	for i := 0; i < 10; i++ {
		go func() {
			t1 := time.Now()
			r, err := client.Ping(ctx)
			if err != nil {
				log.Println(err)
			} else {
				log.Println(r, time.Since(t1))
			}

		}()
	}

	<-make(chan struct{})
}
Esempio n. 2
0
func main() {
	proxy := proxy.NewWithDefaultConfig()
	if host == "" {
		pingCluster(proxy)
		return
	}

	// ping a single faed
	client, err := proxy.ServantByAddr(host + ":" + port)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer client.Recycle()

	ctx := rpc.NewContext()
	ctx.Reason = REASON
	ctx.Rid = time.Now().UnixNano()
	pong, err := client.Ping(ctx)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(pong)
	}

}
Esempio n. 3
0
func main() {
	cf := config.NewDefaultProxy()
	cf.PoolCapacity = 2
	peer := proxy.New(cf)

	for {
		time.Sleep(time.Duration(interval) * time.Second)
		fmt.Println()

		client, err := peer.ServantByAddr(host + ":" + port)
		if err != nil {
			fmt.Println(err)
			continue
		}

		ctx := rpc.NewContext()
		ctx.Reason = "broken.test"
		ctx.Rid = time.Now().UnixNano()
		pong, err := client.Ping(ctx)
		if err != nil {
			fmt.Println("err:", err)

			if proxy.IsIoError(err) {
				client.Close()
			}
		} else {
			fmt.Println(pong)
		}

		client.Recycle()
	}

}
Esempio n. 4
0
func (this *FunServantPeer) NewContext(reason string, uid int64) *rpc.Context {
	ctx := rpc.NewContext()
	ctx.Rid = this.pool.nextTxn() + time.Now().UnixNano() // roughly unique, maybe enough
	ctx.Reason = reason
	ctx.Uid = uid

	return ctx
}
Esempio n. 5
0
func BenchmarkGetSession(b *testing.B) {
	servant := setupServant()
	b.ReportAllocs()
	ctx := rpc.NewContext()
	ctx.Reason = "Map:enterKingdomBlock"
	for i := 0; i < b.N; i++ {
		ctx.Rid = time.Now().UnixNano()
		servant.getSession(ctx)
	}
}
Esempio n. 6
0
func BenchmarkMcSet(b *testing.B) {
	servant := setupServant()
	b.ReportAllocs()

	ctx := rpc.NewContext()
	ctx.Caller = "me"
	for i := 0; i < b.N; i++ {
		servant.McSet(ctx, "foo", []byte("bar"), 0)
	}
}
Esempio n. 7
0
func BenchmarkMcSet(b *testing.B) {
	servant := setupServant()
	b.ReportAllocs()

	ctx := rpc.NewContext()
	ctx.Reason = "benchmark"
	ctx.Rid = 1
	data := rpc.NewTMemcacheData()
	data.Data = []byte("bar")
	for i := 0; i < b.N; i++ {
		servant.McSet(ctx, "default", "foo", data, 0)
	}
}
Esempio n. 8
0
func BenchmarkServantMcSet(b *testing.B) {
	servant := Servant(":9001")
	defer servant.Transport.Close()

	ctx := rpc.NewContext()
	ctx.Caller = "bench"

	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		servant.McSet(ctx, "foo", []byte("bar"), 0)
	}
	b.SetBytes(10)
}
Esempio n. 9
0
func BenchmarkServantPing(b *testing.B) {
	servant := Servant(":9001")
	defer servant.Transport.Close()

	ctx := rpc.NewContext()
	ctx.Caller = "bench"

	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		servant.Ping(ctx)

	}
	b.SetBytes(10)
}
Esempio n. 10
0
func main() {
	t1 := time.Now()

	client := proxy.Servant(":9001")
	defer client.Transport.Close()

	ctx := rpc.NewContext()
	ctx.Caller = "me"
	for i := 0; i < 10; i++ {
		r, _ := client.Ping(ctx)

		fmt.Println(r, time.Since(t1))
		t1 = time.Now()
	}
}
Esempio n. 11
0
func TestContextInfo(t *testing.T) {
	ctx := rpc.NewContext()
	ctx.Caller = "POST+/facebook/getPaymentRequestId/+34ca2cf6"

	fun := FunServantImpl{}
	info := fun.contextInfo(ctx)
	assert.Equal(t, true, info.Valid())
	assert.Equal(t, "POST", info.httpMethod)
	assert.Equal(t, "/facebook/getPaymentRequestId/", info.uri)
	assert.Equal(t, "34ca2cf6", info.seqId)

	ctx.Caller = ""
	info = fun.contextInfo(ctx)
	assert.Equal(t, false, info.Valid())
}
Esempio n. 12
0
func BenchmarkPingOnLocalhost(b *testing.B) {
	b.ReportAllocs()

	cf := &config.ConfigProxy{PoolCapacity: 1}
	client, err := proxy.New(cf).ServantByAddr("localhost:9001")
	if err != nil {
		b.Fatal(err)
	}
	defer client.Recycle()

	ctx := rpc.NewContext()
	ctx.Reason = "benchmark"
	ctx.Rid = 2

	for i := 0; i < b.N; i++ {
		client.Ping(ctx)
	}
}
Esempio n. 13
0
func pingCluster(proxy *proxy.Proxy) {
	if err := etclib.Dial([]string{zk}); err != nil {
		fmt.Printf("zk: %s", err.Error())
		return
	}
	go proxy.StartMonitorCluster()
	proxy.AwaitClusterTopologyReady()

	peers := proxy.ClusterPeers()
	if len(peers) == 0 {
		fmt.Println("found no fae peers")
		return
	}

	for i := 0; i < loops; i++ {
		for _, peerAddr := range peers {
			client, err := proxy.ServantByAddr(peerAddr)
			if err != nil {
				fmt.Printf("[%6d] %21s: %s\n", i+1, peerAddr, err)
				continue
			}

			ctx := rpc.NewContext()
			ctx.Reason = REASON
			ctx.Rid = time.Now().UnixNano() + int64(i)
			pong, err := client.Ping(ctx)
			if err != nil {
				client.Close()
				fmt.Printf("[%6d] %21s: %s\n", i+1, peerAddr, err)
			} else {
				fmt.Printf("[%6d] %21s: %s\n", i+1, peerAddr, pong)
			}

			client.Recycle()
		}
	}

}
Esempio n. 14
0
func main() {
	t1 := time.Now()

	client, err := proxy.NewWithDefaultConfig().ServantByAddr(":9001")
	if err != nil {
		panic(err)
	}
	defer client.Recycle()

	ctx := rpc.NewContext()
	ctx.Reason = "gotest"
	ctx.Rid = 189
	for i := 0; i < 10; i++ {
		r, err := client.Ping(ctx)
		if err != nil {
			panic(err)
		}

		fmt.Println(r, time.Since(t1))
		t1 = time.Now()
	}

}
Esempio n. 15
0
// auto fills Rid field.
func NewContext(reason string) *rpc.Context {
	ctx := rpc.NewContext()
	ctx.Reason = reason
	ctx.Rid = time.Now().UnixNano() // TODO strict enough?
	return ctx
}
Esempio n. 16
0
func runSession(proxy *proxy.Proxy, wg *sync.WaitGroup, round int, seq int) {
	report.updateConcurrency(1)
	report.incSessions()
	defer func() {
		wg.Done()
		report.updateConcurrency(-1)
		//log.Printf("session{round^%d seq^%d} done", round, seq)
	}()

	t1 := time.Now()
	client, err := proxy.ServantByAddr(host + ":9001")
	if err != nil {
		report.incConnErrs()
		log.Printf("session{round^%d seq^%d} error: %v", round, seq, err)
		return
	}
	defer client.Recycle() // when err occurs, do we still need recycle?

	var enableLog = false
	if !logTurnOff && sampling(SampleRate) {
		enableLog = true
	}

	if enableLog {
		log.Printf("session{round^%d seq^%d} connected within %s",
			round, seq, time.Since(t1))
	}

	ctx := rpc.NewContext()
	ctx.Reason = "stress.go"
	for i := 0; i < LoopsPerSession; i++ {
		//time.Sleep(time.Millisecond * 5)
		ctx.Rid = time.Now().UnixNano()

		if Cmd&CallNoop != 0 {
			var r int32
			r, err = client.Noop(1)
			if err != nil {
				recordIoError(err)
				report.incCallErr()
				if !errOff {
					log.Printf("session{round^%d seq^%d noop}: %v", round, seq, err)
				}
				client.Close()
				return
			} else {
				report.incCallOk()
				if enableLog {
					log.Printf("session{round^%d seq^%d noop}: %v", round, seq, r)
				}
			}
		}

		if Cmd&CallPing != 0 {
			var r string
			r, err = client.Ping(ctx)
			if err != nil {
				recordIoError(err)
				report.incCallErr()
				if !errOff {
					log.Printf("session{round^%d seq^%d ping}: %v", round, seq, err)
				}
				client.Close()
				return
			} else {
				report.incCallOk()
				if enableLog {
					log.Printf("session{round^%d seq^%d ping}: %v", round, seq, r)
				}
			}
		}

		if Cmd&CallLCache != 0 {
			key := fmt.Sprintf("lc_stress:%d", rand.Int())
			value := []byte("value of " + key)
			_, err = client.LcSet(ctx, key, value)
			if err != nil {
				recordIoError(err)
				report.incCallErr()
				if !errOff {
					log.Printf("session{round^%d seq^%d lc.set}: %v", round, seq, err)
				}
				client.Close()
				return
			} else {
				report.incCallOk()
			}

			value, _, err = client.LcGet(ctx, key)
			if err != nil {
				recordIoError(err)
				report.incCallErr()
				if !errOff {
					log.Printf("session{round^%d seq^%d lc.get}: %v", round, seq, err)
				}
				client.Close()
				return
			} else {
				report.incCallOk()
				if enableLog {
					log.Printf("session{round^%d seq^%d lcache}: %s => %s",
						round, seq, key, string(value))
				}
			}
		}

		if Cmd&CallIdGen != 0 {
			var r int64
			r, err = client.IdNext(ctx)
			if err != nil {
				recordIoError(err)
				report.incCallErr()
				if !errOff {
					log.Printf("session{round^%d seq^%d idgen}: %v", round, seq, err)
				}
				client.Close()
				return
			} else {
				if enableLog {
					log.Printf("session{round^%d seq^%d idgen}: %d",
						round, seq, r)
				}
				report.incCallOk()
			}
		}

		if Cmd&CallMysql != 0 {
			// with cache
			if true {
				r, err := client.MyQuery(ctx, "UserShard", "UserInfo", 1,
					"SELECT * FROM UserInfo WHERE uid=?",
					[]string{"1"}, "user:1")
				if err != nil {
					recordIoError(err)
					report.incCallErr()
					if !errOff {
						log.Printf("session{round^%d seq^%d mysql.cache}: %v", round, seq, err)
					}
					client.Close()
					return
				} else {
					if enableLog {
						log.Printf("session{round^%d seq^%d mysql}: %+v",
							round, seq, r)
					}
					report.incCallOk()
				}
			}

			// without cache
			if true {
				var rows *rpc.MysqlResult
				rows, err = client.MyQuery(ctx, "UserShard", "UserInfo", 1,
					"SELECT * FROM UserInfo WHERE uid=?",
					[]string{"1"}, "")
				if err != nil {
					recordIoError(err)
					report.incCallErr()
					if !errOff {
						log.Printf("session{round^%d seq^%d mysql.nocache}: %v", round, seq, err)
					}
					client.Close()
					return
				} else {
					if enableLog {
						log.Printf("session{round^%d seq^%d mysql}: %+v",
							round, seq, rows.Rows)
					}
					report.incCallOk()
				}
			}

		}

		continue // TODO

		var (
			key     string
			value   []byte
			mcValue = rpc.NewTMemcacheData()
			result  []byte
		)
		key = fmt.Sprintf("mc_stress:%d", rand.Int())
		value = []byte("value of " + key)
		mcValue.Data = value

		if Cmd&CallMemcache != 0 {
			_, err = client.McSet(ctx, MC_POOL, key, mcValue, 36000)
			if err != nil {
				report.incCallErr()
				log.Printf("session{round^%d seq^%d mc_set} %v", round, seq, err)
			} else {
				report.incCallOk()
			}
			_, miss, err := client.McGet(ctx, MC_POOL, key)
			if miss != nil || err != nil {
				report.incCallErr()
				log.Printf("session{round^%d seq^%d mc_get} miss^%v, err^%v",
					round, seq, miss, err)
			} else {
				report.incCallOk()
			}
		}

		if Cmd&CallMongo != 0 {
			mgQuery, _ := bson.Marshal(bson.M{"snsid": "100003391571259"})
			mgFields, _ := bson.Marshal(bson.M{})
			result, _, err = client.MgFindOne(ctx, "default", "idmap",
				0, mgQuery, mgFields)
			if err != nil {
				report.incCallErr()
				log.Printf("session{round^%d seq^%d mg_findOne} %v", round, seq, err)
			} else {
				report.incCallOk()

				if false {
					log.Println(result)
				}
			}
		}

	}

	if enableLog {
		log.Printf("session{round^%d seq^%d} done", round, seq)
	}

}