Пример #1
0
// Reflect over the methods defined in redis.Client
// and send back as []string (tolowercase)
// TOOD get rid of redundant code in switch
// (REVU: needs minor update to core code)
func getDefinedMethods(ctype clientType) (map[string]string, *error_) {

	var mmap = map[string]string{}

	spec := redis.DefaultSpec().Db(13).Password("go-redis")

	var e redis.Error
	var client interface{}

	switch ctype {
	case sync:
		client, e = redis.NewSynchClientWithSpec(spec)
	case async:
		client, e = redis.NewAsynchClientWithSpec(spec)
	}
	if e != nil {
		log.Println("ignoring - ", e)
	}
	if client == nil {
		return mmap, &error_{"client is nil", nil}
	} else {
		defer client.(redis.RedisClient).Quit()
	}

	tc := reflect.TypeOf(client)
	nm := tc.NumMethod()

	for i := 0; i < nm; i++ {
		m := tc.Method(i)
		mname := strings.ToLower(m.Name)
		mmap[mname] = mname
	}
	return mmap, nil
}
Пример #2
0
func spamChat1(chanKey string) {
	fmt.Println("spamchat being called")
	spec := redis.DefaultSpec().Password("go-redis")
	client, e := redis.NewAsynchClientWithSpec(spec)
	if e != nil {
		fmt.Print("Error creating spam client for: ", e)
	}
	defer client.Quit()

	for i := 0; i < 1000000; i++ {
		var fr redis.FutureInt64
		//var fr2 redis.FutureBool
		var buf bytes.Buffer
		buf.Write([]byte("hello" + string(i)))
		bt := buf.Bytes()
		fr, e = client.Publish("chat", bt)
		//fmt.Println("we got past 2 publishes")
		if e != nil {
			fmt.Println("error in publishing: ", e)
		}
		_, e = client.Rpush("chatlog", bt)
		if e != nil {
			fmt.Println("error in storing list: ", e)
		}

		numRecieved, _ := fr.Get()
		//fmt.Println(numRecieved)
		//fr2.Get()
	}
}
Пример #3
0
func NewAsyncClientWithSpec(t *testing.T, spec *redis.ConnectionSpec) redis.AsyncClient {
	client, err := redis.NewAsynchClientWithSpec(getTestConnSpec())
	if err != nil {
		t.Fatalf("NewAsynchClientWithSpec - ", err)
	}
	return client
}
Пример #4
0
// Use a single redis.AsyncClient with specified number
// of workers to bench concurrent load on the async client
func benchTask(taskspec taskSpec, iterations int, workers int, printReport bool) (delta int64, err os.Error) {
	signal := make(chan int, workers) // Buffering optional but sensible.
	spec := redis.DefaultSpec().Db(13).Password("go-redis")
	client, e := redis.NewAsynchClientWithSpec(spec)
	if e != nil {
		log.Println("Error creating client for worker: ", e)
		return -1, e
	}
	//    defer client.Quit()        // will be deprecated soon
	defer client.RedisClient().Quit()

	t0 := time.Nanoseconds()
	for i := 0; i < workers; i++ {
		id := fmt.Sprintf("%d", i)
		go taskspec.task(id, signal, client, iterations)
	}
	for i := 0; i < workers; i++ {
		<-signal
	}
	delta = time.Nanoseconds() - t0
	//	for i := 0; i < workers; i++ {
	//		clients[i].Quit()
	//	}
	//
	if printReport {
		report("concurrent "+taskspec.name, delta, iterations*workers)
	}

	return
}
Пример #5
0
func asyncPublish(spec *redis.ConnectionSpec, channel string) {

	client, e := redis.NewAsynchClientWithSpec(spec)
	if e != nil {
		log.Println("failed to create the async client", e)
		return
	}

	// ref will ultimately point to the last future returned from Publish()
	var rcvCntFuture redis.FutureInt64
	for i := 0; i < 100; i++ {
		msg := []byte(fmt.Sprintf("this is message # %d (using async client)!", i))
		var err redis.Error
		// publish the message and don't wait for the future
		// we only care if an error was raised on publish
		rcvCntFuture, err = client.Publish(channel, msg)
		if err != nil {
			fmt.Printf("Error on Publish - %s", err)
		}
	}

	// ok, now let's wait until the last publish's future is done
	// before quiting.
	rcvCnt, fe := rcvCntFuture.Get()
	if fe != nil {
		fmt.Printf("Error on future get - %s\n", fe)
		return
	} else {
		fmt.Printf("(LAST) Message sent to %d subscribers\n", rcvCnt)
	}

	client.Quit()
}
Пример #6
0
func NewRedisAsyncClient() redis.AsyncClient {
	spec := redis.DefaultSpec().Db(0).Host("10.174.178.235")
	client, err := redis.NewAsynchClientWithSpec(spec)
	if err != nil {
		panic(err)
	}
	return client
}
Пример #7
0
// Check that connection is actually passing passwords from spec
// and catching AUTH ERRs.
func TestAsyncClientConnectWithBadSpec(t *testing.T) {
	spec := getTestConnSpec()
	spec.Password("bad-password")
	client, expected := redis.NewAsynchClientWithSpec(spec)
	if expected == nil {
		t.Error("BUG: Expected a RedisError")
	}
	if client != nil {
		t.Error("BUG: async client reference on error MUST be nil")
	}
}
Пример #8
0
func main() {
	runtime.GOMAXPROCS(16)
	key = "user_data_2"
	spec := redis.DefaultSpec().Db(0).Host("10.174.178.235")
	client, err := redis.NewAsynchClientWithSpec(spec)
	if err != nil {
		panic(err)
	}
	primeKey(key, client)
	defer client.Quit()
	handler := func(w http.ResponseWriter, r *http.Request) {
		responseHandler(w, r, client)
	}
	http.HandleFunc("/", handler)
	http.ListenAndServe(":80", nil)
}
Пример #9
0
func main() {
	runtime.GOMAXPROCS(16)
	key = "user_data_2"
	spec := redis.DefaultSpec().Db(0).Host("10.174.178.235")
	primeClient, err := redis.NewAsynchClientWithSpec(spec)
	if err != nil {
		panic(err)
	}
	primeKey(key, primeClient)
	log.Println("Key primed and ready")
	defer primeClient.Quit()
	pool = NewClientPool(100)
	handler := func(w http.ResponseWriter, r *http.Request) {
		responseHandler(w, r)
	}
	http.HandleFunc("/", handler)
	http.ListenAndServe(":80", nil)
}
Пример #10
0
// Check that connection is actually passing passwords from spec
func TestAsyncClientConnectWithSpec(t *testing.T) {
	spec := getTestConnSpec()

	client, err := redis.NewAsynchClientWithSpec(spec)
	if err != nil {
		t.Fatalf("failed to create client with spec. Error: %s ", err)
	} else if client == nil {
		t.Fatal("BUG: client is nil")
	}

	// quit once -- OK
	futureBool, err := client.Quit()
	if err != nil {
		t.Errorf("BUG - initial Quit on asyncClient should not return error - %s ", err)
	}
	if futureBool == nil {
		t.Errorf("BUG - non-error asyncClient response should not return nil future")
	}
	// block until we get results
	ok, fe := futureBool.Get()
	if fe != nil {
		t.Errorf("BUG - non-Error Quit future result get must never return error - got: %s", fe)
	}
	if !ok {
		t.Errorf("BUG - non-Error Quit future result must always be true ")
	}

	// subsequent quit should raise error
	for i := 0; i < 10; i++ {
		futureBool, err = client.Quit()
		if err == nil {
			t.Errorf("BUG - Quit on shutdown asyncClient should return error")
		}
		if futureBool != nil {
			t.Errorf("BUG - Quit on shutdown asyncClient should not return future. got: %s", futureBool)
		}
	}
}
Пример #11
0
// Use a single redis.AsyncClient with specified number
// of workers to bench concurrent load on the async client
func benchTask(taskspec taskSpec, iterations int, workers int, printReport bool) (delta time.Duration, err error) {
	// channel to signal completion
	signal := make(chan int, workers)

	// spec and initialize an AsyncClient
	// will flush your db13 as noted in README ..
	spec := redis.DefaultSpec().Db(13).Password("go-redis")
	client, e := redis.NewAsynchClientWithSpec(spec)
	if e != nil {
		log.Println("Error creating client for worker: ", e)
		return -1, e
	}

	defer client.Quit()

	// panics
	setup(client)

	t0 := time.Now()
	for i := 0; i < workers; i++ {
		id := fmt.Sprintf("%d", i)
		go taskspec.task(id, signal, client, iterations)
	}

	// wait for completion
	for i := 0; i < workers; i++ {
		<-signal
	}
	delta = time.Now().Sub(t0)

	if printReport {
		report(taskspec.name, workers, delta, iterations*workers)
	}

	return
}