Example #1
0
//-----------------------------------------------------------------------------
// Test
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//EXPIRE(key, seconds), TTL(key), INFO
//-----------------------------------------------------------------------------
func TestCommonUsingDo(t *testing.T) {
	//tu.SkipLog(t)

	sleepS := 2

	c := GetRedis().Conn

	c.Do("MSET", "key1", 20, "key2", 30)
	c.Do("HMSET", "key3:subkey1", "field1", 1, "field2", 2)
	c.Do("HMSET", "key3:subkey2", "field1", 99, "field2", 100)

	val, err := redis.Int(c.Do("GET", "key1"))
	if err != nil {
		t.Errorf("key1 is 10: value is %v, error is %s", val, err)
	}

	fields, err := redis.Ints(c.Do("HMGET", "key3:subkey1", "field1", "field2"))
	if err != nil {
		t.Errorf("field1 should be 1, field2 should be 1 but result is %#v, error is %s", fields, err)
	}

	//EXPIRE
	c.Do("EXPIRE", "key1", sleepS)
	c.Do("EXPIRE", "key3:subkey1", sleepS)

	//TTL
	s, err := redis.Int(c.Do("TTL", "key1"))
	if err != nil {
		t.Errorf("redis.Int(c.Do(\"TTL\", \"key1\")) error : %s", err)
	}
	lg.Debugf("TTL is %v", s)

	//sleep
	time.Sleep(time.Duration(sleepS+1) * time.Second)

	s, _ = redis.Int(c.Do("TTL", "key1"))
	lg.Debugf("TTL is %v", s)

	//It can't access
	val, err = redis.Int(c.Do("GET", "key1"))
	if err == nil {
		t.Errorf("key1 has already expired: value is %v", val)
	}

	//It can't access
	//TODO:somehow it can access. but value is 0
	fields, err = redis.Ints(c.Do("HMGET", "key3:subkey1", "field1", "field2"))
	//if err == nil {
	if err != nil || fields[0] != 0 || fields[1] != 0 {
		t.Errorf("key3:subkey1 has already expired: value is %+v", fields)
	}

	//It's OK.
	fields, err = redis.Ints(c.Do("HMGET", "key3:subkey2", "field1", "field2"))
	if err != nil {
		//if err != nil || fields[0] != 99 || fields[1] != 100 {
		t.Errorf("field1 should be 99, field2 should be 100 but result is %#v", fields)
	}
}
Example #2
0
// Get order from redis by id.
func NewOrderFromRedis(id string) (Order, error) {
	var order Order
	order.Id = id
	c := pool.Get()
	defer c.Close()
	hashName := fmt.Sprintf("o_%s", id)
	l, err := redis.Ints(c.Do("HGETALL", hashName))
	if err != nil {
		panic(err)
	}
	if len(l) == 0 {
		return order, ErrOrderNil
	}
	order.Items = make([]OrderFoodItem, len(l)/2)
	order.Total = 0
	for i := 0; i < len(l); i += 2 {
		foodId := l[i]
		price := food2Price[foodId]
		count := l[i+1]
		item := OrderFoodItem{FoodId: foodId, Count: count, Price: price}
		order.Items[i] = item
		order.Total = order.Total + count*price
	}
	return order, nil
}
Example #3
0
//send is faster than do method
func TestStringsUsingSend(t *testing.T) {
	//tu.SkipLog(t)

	GetRedis().ConnectionS(3)

	c := GetRedis().Conn
	c.Send("SET", "key1", 10)
	c.Send("MSET", "key2", 20, "key3", 30)
	c.Flush()
	for i := 0; i < 3; i++ {
		c.Receive() //OK
	}

	//GET
	c.Send("GET", "key1")
	c.Flush()
	val, err := redis.Int(c.Receive())
	if err != nil || val != 10 {
		t.Errorf("key1 should be 10 but result is %d: err is %s", val, err)
	}

	//MGET
	c.Send("MGET", "key2", "key3")
	c.Flush()
	vals, err2 := redis.Ints(c.Receive())
	if err2 != nil || vals[0] != 20 || vals[1] != 30 {
		t.Errorf("key2 should be 20, key2 should be 30, but result is %#v: err is %s", vals, err2)
	}
}
Example #4
0
//-----------------------------------------------------------------------------
func TestListsUsingDo(t *testing.T) {
	//tu.SkipLog(t)

	GetRedis().Connection(1)
	//GetRedisInstance().ConnectionS(2)

	c := GetRedis().Conn
	//c := GetRedisInstance().Pool.Get()

	//RPUSH
	for i := 10; i < 101; i++ {
		c.Do("RPUSH", "key-list1", i)
	}
	vals, _ := redis.Ints(c.Do("LRANGE", "key-list1", 0, -1))
	lg.Debugf("key-list1 values is %v", vals)

	//LPUSH
	for i := 9; i > 0; i-- {
		c.Do("LPUSH", "key-list1", i)
	}
	vals, _ = redis.Ints(c.Do("LRANGE", "key-list1", 0, -1))
	lg.Debugf("key-list1 values is %v", vals)

	//LSET(key, index, value)
	c.Do("LSET", "key-list1", 0, 100)
	result, _ := redis.Int(c.Do("LINDEX", "key-list1", 0))
	lg.Debugf("result of LSET is %v", result)

	//LTRIM(key, start, end)   //update list
	c.Do("LTRIM", "key-list1", 0, 9)
	vals, _ = redis.Ints(c.Do("LRANGE", "key-list1", 0, -1))
	//LLEN(key)   //get length of lists
	length, _ := redis.Int(c.Do("LLEN", "key-list1"))
	lg.Debugf("key-list1 value is %v, length is %d", vals, length)
	vals, _ = redis.Ints(c.Do("LRANGE", "key-list1", 0, -1))
	lg.Debugf("key-list1 values is %v", vals)

	//LPOP(key)
	result, _ = redis.Int(c.Do("LPOP", "key-list1"))
	lg.Debugf("result of LPOP is %v", result)
	result, _ = redis.Int(c.Do("RPOP", "key-list1"))
	lg.Debugf("result of RPOP is %v", result)

	vals, _ = redis.Ints(c.Do("LRANGE", "key-list1", 0, -1))
	lg.Debugf("key-list1 values is %v", vals)
}
Example #5
0
func (dist RedisWordProbabilityDist) ProbabilityOfLabel(label SpamLabel) (float64, error) {
	labelCountKey := dist.label2namespace[label] + dist.textCountSuffix
	totalCountKey := dist.textCountSuffix
	results, err := redis.Ints(dist.conn.Do("MGET", labelCountKey, totalCountKey))
	if err != nil {
		return 0.0, err
	}
	labelCount, totalCount := results[0], results[1]
	return float64(labelCount) / float64(totalCount), nil
}
Example #6
0
//Bulk
func BenchmarkSetBulkData01(b *testing.B) {
	GetRedis().Connection(0)
	c := GetRedis().Conn

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		c.Do("SET", "key1", 10)
		c.Do("MSET", "key2", 20, "key3", 30)
		c.Do("HMSET", "key:subkey1", "field1", 1, "field2", 2)

		redis.Int(c.Do("GET", "key1"))
		redis.Ints(c.Do("MGET", "key2", "key3"))
		redis.Ints(c.Do("HMGET", "key:subkey1", "field1", "field2"))
	}
	b.StopTimer()

	dropDatabase()
	//220368 ns/op (220ms)
}
func (a *Alerter) SetHash(key, field string, value []byte) {
	conn := a.pool.Get()
	defer conn.Close()
	// expire the key after 5 minutes
	conn.Send("MULTI")
	conn.Send("HSET", key, field, value)
	conn.Send("EXPIRE", key, 60*30)
	_, err := redis.Ints(conn.Do("EXEC"))
	if err != nil {
		fmt.Printf("ERROR: unable to set redis key %s\n", err.Error())
	}
}
Example #8
0
func ShowOrdersController(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	r.ParseForm()
	var accessToken string
	if len(r.Form["access_token"]) > 0 {
		accessToken = r.Form["access_token"][0]
	} else {
		accessToken = r.Header.Get("Access-Token")
	}

	if len(accessToken) <= 0 {
		w.WriteHeader(401)
		fmt.Fprintf(w, `{"code": "INVALID_ACCESS_TOKEN", "message": "无效的令牌"}`)
		return
	}

	lua := `local uid = redis.call("get", "u:"..KEYS[1])
		local oid = redis.call("get", "u:o:"..uid)
		if oid then
			local menu = redis.call("hgetall", "o:f:"..oid)
			return {uid, oid, menu}
		end`
	var getScript = redis.NewScript(1, lua)
	c := rp.Get()
	reply, _ := redis.Values(getScript.Do(c, accessToken))

	var json bytes.Buffer
	if len(reply) != 0 {
		var userId, orderId string
		var items []interface{}
		redis.Scan(reply, &userId, &orderId, &items)

		var total int = 0
		var j []string
		v, _ := redis.Ints(items, nil)
		for i := 0; i < len(v); i += 2 {
			fid := v[i]
			cnt := v[i+1]
			total += gfoods[fid].Price * cnt
			j = append(j, fmt.Sprintf(`{"food_id": %d, "count": %d}`, fid, cnt))
		}
		json.WriteString("[{")
		json.WriteString(fmt.Sprintf(`"id": "%s", `, orderId))
		json.WriteString(fmt.Sprintf(`"items": [%s]`, strings.Join(j, ",")))
		json.WriteString(fmt.Sprintf(`,"total": %d`, total))
		json.WriteString("}]")

	} else {
		json.WriteString("{}")
	}

	w.WriteHeader(200)
	fmt.Fprintf(w, json.String())
}
Example #9
0
func ExampleInts() {
	c, err := dial()
	if err != nil {
		panic(err)
	}
	defer c.Close()

	c.Do("SADD", "set_with_integers", 4, 5, 6)
	ints, _ := redis.Ints(c.Do("SMEMBERS", "set_with_integers"))
	fmt.Printf("%#v\n", ints)
	// Output:
	// []int{4, 5, 6}
}
Example #10
0
func (rw *RedisWrapper) GetFrequency(req *ParsedRequest, creatives *InventoryCollection) (response []int, err error) {
	conn := rw.redisPool.Get()
	defer conn.Close()
	frIds := make([]interface{}, creatives.Len())
	for index, value := range creatives.Data {
		frIds[index] = fmt.Sprintf("%v%v_%v",
			rw.configure.RedisFrequencyPrefix, req.Cid, value.ModelSign1)
	}
	if response, err = redis.Ints(conn.Do("mget", frIds...)); err != nil {
		rw.logger.Warning("redis error: %v", err.Error())
	}
	return
}
Example #11
0
func BenchmarkSetBulkData02(b *testing.B) {
	GetRedis().ConnectionS(3)
	c := GetRedis().Conn
	c.Flush()
	c.Receive()

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		c.Send("SET", "key1", 10)
		c.Send("MSET", "key2", 20, "key3", 30)
		c.Send("HMSET", "key:subkey1", "field1", 1, "field2", 2)
		c.Flush()
		for i := 0; i < 3; i++ {
			c.Receive() //OK
		}

		//#1
		c.Send("GET", "key1")
		c.Flush()
		redis.Int(c.Receive())

		//#2
		c.Send("MGET", "key2", "key3")
		c.Flush()
		redis.Ints(c.Receive())

		//#3
		c.Send("HMGET", "key:subkey1", "field1", "field2")
		c.Flush()
		redis.Ints(c.Receive())
	}
	b.StopTimer()

	dropDatabase()
	//149114 ns/op (149ms)
}
Example #12
0
// isFinished returns true if the task has finished.
func (r *RedisRTC) isFinished(id string) bool {
	c := r.redisPool.Get()
	defer util.Close(c)

	util.LogErr(c.Send("MULTI"))
	util.LogErr(c.Send("EXISTS", r.key(id)))
	util.LogErr(c.Send("EXISTS", r.errorKey(id)))
	resArr, err := redis.Ints(c.Do("EXEC"))
	if err != nil {
		glog.Errorf("Unable to check if key exits: %s", err)
		return false
	}

	return (resArr[0] + resArr[1]) > 0
}
Example #13
0
func TestHashesUsingDo(t *testing.T) {
	//tu.SkipLog(t)

	c := GetRedis().Conn
	//c := GetRedisInstance().Pool.Get()
	c.Do("HMSET", "key:subkey1", "field1", 1, "field2", 2)

	fields, err := redis.Ints(c.Do("HMGET", "key:subkey1", "field1", "field2"))
	if err != nil || fields[0] != 1 || fields[1] != 2 {
		t.Errorf("field1 should be 1, field2 should be 2 but result is %#v: err is %s", fields, err)
	}

	//HGETALL
	fields2, _ := redis.StringMap(c.Do("HGETALL", "key:subkey1"))
	lg.Debugf("HGETALL: %v, %s, %s", fields2, fields2["field1"], fields2["field2"])
}
Example #14
0
func TestSetsUsingDo(t *testing.T) {
	//tu.SkipLog(t)

	GetRedis().Connection(1)
	//GetRedisInstance().ConnectionS(2)

	c := GetRedis().Conn
	//c := GetRedisInstance().Pool.Get()

	key := "key-set1"

	//RPUSH
	for i := 0; i < 10; i++ {
		c.Do("SADD", key, i)
	}
	vals, _ := redis.Ints(c.Do("SMEMBERS", key))
	lg.Debugf("%s values is %v", key, vals)
}
Example #15
0
func (dist RedisWordProbabilityDist) ProbabilityOfTextGivenLabel(text Text, label SpamLabel) (float64, error) {
	labelWordCountKey := dist.label2namespace[label] + dist.wordCountSuffix
	wordKeys := dist.textToKeys(label, text...)
	allKeys := append([]interface{}{labelWordCountKey}, wordKeys...)
	result, err := redis.Ints(dist.conn.Do("MGET", allKeys...))
	if err != nil {
		return 0.0, err
	}
	nWordsInLabel := float64(result[0])
	prob := 1.0
	for _, wordFreq := range result[1:] {
		if wordFreq == 0 {
			wordFreq = 1 // add-one smoothing
		}
		prob *= float64(wordFreq) / nWordsInLabel
	}
	return prob, nil
}
Example #16
0
func (this __red) NumSub(messages ...interface{}) []int {
	channels := []interface{}{}
	for _, message := range messages {
		switch message := message.(type) {

		default:
			_ = message
			panic("Unsupported message type")
		}
	}

	conn := this.__.(redis.Conn)
	nrecvs, err := redis.Ints(conn.Do("pubsub numsub", channels...))
	if err != nil {
		panic(err)
	}

	return nrecvs
}
Example #17
0
func (s *SBFFrame) Check(conn redis.Conn, element []byte) bool {
	var flag int = 1
	hashes := murmur.Hashes(element, s.SliceCount, s.SliceSize)
	// check bit val
	conn.Send("MULTI")
	for index, h := range hashes {
		pos := uint32(index)*s.SliceSize + s.StartIndex + h + SBF_FRAME_HEADER_SIZE<<3
		conn.Send("GETBIT", s.Refer, pos)
	}
	if data, err := redis.Ints(conn.Do("EXEC")); err == nil {
		for _, f := range data {
			flag = flag & f
			if flag != 1 {
				return false
			}
		}
		return (flag == 1)
	} else {
		return false
	}
}
Example #18
0
func TestStringsUsingDo(t *testing.T) {
	//tu.SkipLog(t)

	//GetRedisInstance().Connection(1)
	//GetRedisInstance().ConnectionS(2)

	c := GetRedis().Conn
	//c := GetRedisInstance().Pool.Get()
	c.Do("SET", "key1", 10)
	c.Do("MSET", "key2", 20, "key3", 30)

	val, err := redis.Int(c.Do("GET", "key1"))
	if err != nil || val != 10 {
		t.Errorf("key1 should be 10 but result is %d: err is %s", val, err)
	}

	vals, err2 := redis.Ints(c.Do("MGET", "key2", "key3"))
	if err2 != nil || vals[0] != 20 || vals[1] != 30 {
		t.Errorf("key2 should be 20, key2 should be 30, but result is %#v: err is %s", vals, err2)
	}
}
func (p *RedisCounterStorage) GetSumValue(counterName string, dimensionsGroup [][]string) (sumDimVal int64, err error) {
	if dimensionsGroup == nil {
		return
	}

	conn := p.pool.Get()
	defer conn.Close()

	keyPrefix := p.redisConfig.Prefix + _COUNTER_ + counterName

	keys := []interface{}{}

	for _, dim := range dimensionsGroup {
		dimKey := ""
		if dim != nil {
			dimKey = strings.Join(dim, ":")
		}

		keys = append(keys, keyPrefix+":"+dimKey)
	}

	vals, err := conn.Do("MGET", keys...)

	var intVals []int
	if intVals, err = redis.Ints(vals, err); err != nil {
		return
	}

	sumV := 0
	for _, v := range intVals {
		sumV += v
	}

	sumDimVal = int64(sumV)

	return
}
Example #20
0
func main() {
	flag.Parse()
	runtime.GOMAXPROCS(runtime.NumCPU())
	var err error

	file, err := os.Open(*configFile)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	decoder := json.NewDecoder(file)
	config := config.Configuration{}
	err = decoder.Decode(&config)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	if config.Host == "" || config.ClientId == "" {
		fmt.Println("Missing Configs", config)
		os.Exit(1)
	}

	if config.MaxWorkers > 0 {
		max_workers = config.MaxWorkers
	}

	c := crawler.New(config)
	defer c.Close()

	crawler := Crawler{c}

	// We are able to get the highest track id on our own.
	max_id, err := crawler.GetHighTrackId()
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	// Handle signals to stop crawling.
	var canCrawl bool = true
	stopCrawler := make(chan os.Signal, 1)
	signal.Notify(stopCrawler, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		<-stopCrawler
		fmt.Println("Exit signal recieved. Will finish up current crawls and exit the program.")
		canCrawl = false
		close(track_ids)
		close(playlist_ids)
	}()

	track_ids = make(chan int, max_workers)
	var trackMonitor sync.WaitGroup
	trackMonitor.Add(max_workers)
	for i := 0; i < max_workers; i++ {
		go crawler.ProcessTracks(&trackMonitor)
	}

	r := c.RedisClient.Get()
	defer r.Close()

	// If we want to restart crawls due to a server crash...
	if *restartTodo == true && *useEmpty == false && canCrawl {
		playlists, _ := redis.Ints(r.Do("SMEMBERS", "crawlPlaylistsTodo"))
		for _, i := range playlists {
			r.Do("SADD", "crawlPlaylists", i)
		}
		tracks, _ := redis.Ints(r.Do("SMEMBERS", "crawlPlaylistsTodo"))
		for _, i := range tracks {
			r.Do("SADD", "crawlTracks", i)
		}
	}

	// Starts a new crawl from scratch...
	if *useEmpty == true && canCrawl {
		r.Do("DEL", "crawlTracks")
		batch_max := int(max_id/1000) + 1
		for i := batch_max; i > 0; i-- {
			nulls := []interface{}{fmt.Sprintf("trackMeta:%d", i)}
			track_id := i * 1000
			for k := 999; k >= 0; k-- {
				nulls = append(nulls, fmt.Sprintf("%d", (track_id+k)), "null")
			}
			r.Do("HMSET", nulls...)
			r.Do("SADD", "crawlTracks", i)
		}
	}

	var hasMoreTracks bool = true
	for hasMoreTracks && canCrawl {
		// Add all of the tracks that are scheduled to be crawled into a channel
		i, err := redis.Int(r.Do("SPOP", "crawlTracks"))
		if err != nil {
			hasMoreTracks = false
		} else {
			r.Do("SADD", "crawlTracksTodo", i)
			track_ids <- i
		}
	}
	close(track_ids)
	// Wait for all of the tracks to be crawled before going onto the playlists
	trackMonitor.Wait()

	// Manually run garbage collection to free up any memory that is no longer used
	runtime.GC()

	playlist_ids = make(chan int, max_workers)
	var playlistMonitor sync.WaitGroup
	playlistMonitor.Add(max_workers)
	for i := 0; i < max_workers; i++ {
		go crawler.ProcessPlaylists(&playlistMonitor)
	}
	if *useEmpty == true && canCrawl {
		r.Do("DEL", "crawlPlaylists")
		playlist_max := int(*maxPlaylist/1000) + 1
		for i := playlist_max; i > 0; i-- {
			nulls := []interface{}{fmt.Sprintf("playlistTracks:%d", i)}
			playlist_id := i * 1000
			for k := 999; k >= 0; k-- {
				nulls = append(nulls, fmt.Sprintf("%d", (playlist_id+k)), "null")
			}
			r.Do("HMSET", nulls...)
			r.Do("SADD", "crawlPlaylists", i)
		}
	}

	var hasMorePlaylists bool = true
	for hasMorePlaylists && canCrawl {
		i, err := redis.Int(r.Do("SPOP", "crawlPlaylists"))
		if err != nil {
			hasMorePlaylists = false
		} else {
			r.Do("SADD", "crawlPlaylistsTodo", i)
			playlist_ids <- i
		}
	}
	close(playlist_ids)
	playlistMonitor.Wait()
}
Example #21
0
func (s RedisStore) updateRate(c redis.Conn, key string, rate Rate) ([]int, error) {
	c.Send("MULTI")
	c.Send("INCR", key)
	c.Send("TTL", key)
	return redis.Ints(c.Do("EXEC"))
}
Example #22
0
func (s RedisStore) setRate(c redis.Conn, key string, rate Rate) ([]int, error) {
	c.Send("MULTI")
	c.Send("SETNX", key, 1)
	return redis.Ints(c.Do("EXEC"))
}
Example #23
0
// Make order.
func MakeOrder(w http.ResponseWriter, r *http.Request) {
	user, err := GetUserByAccessToken(r)
	if err != nil {
		if err == ErrInvalidAccessToken {
			ResponseErrAccessToken(w)
			return
		}
		panic(err)
	}
	req := RequestMakeOrder{}
	err = RequestBind(r, &req)
	if err != nil {
		if err == io.EOF {
			ResponseErrEmptyRequest(w)
		} else {
			ResponseErrMalformedJson(w)
		}
		return
	}
	cartId := req.CartId
	if !ValidateCartId(cartId) {
		ResponseErrCartNotFound(w)
		return
	}
	if GetUserIdByCartId(cartId) != user.Id {
		ResponseErrNotAuthorizedToAcessCart(w)
		return
	}
	orderHashName := "o_" + strconv.Itoa(user.Id)
	ch := make(chan int, 3)
	go func() {
		c := pool.Get()
		defer c.Close()
		b, err := redis.Bool(c.Do("EXISTS", orderHashName))
		if err != nil && err != redis.ErrNil {
			panic(err)
		}
		if b {
			ch <- 1
			return
		}
		ch <- 0 // order already made
	}()
	go func() {
		c := pool.Get()
		defer c.Close()
		l, err := redis.Ints(c.Do("HGETALL", cartId))
		if err != nil {
			if err == redis.ErrNil {
				ch <- 2 // cart not found
				return
			}
		}
		if len(l) == 0 {
			ch <- 2 // cart not found
			return
		}
		e := make(chan int, len(l)/2)
		for i := 0; i < len(l); i += 2 {
			foodId := l[i]
			count := l[i+1]
			go func() {
				c := pool.Get()
				defer c.Close()
				remain, err := redis.Int(c.Do("HINCRBY", "f", foodId, 0-count))
				if err != nil {
					panic(err)
				}
				if remain < 0 {
					c.Do("HINCRBY", "f", foodId, count) //rollback
					e <- 1
					return
				}
				e <- 0
			}()
		}
		for i := 0; i < len(l); i += 2 {
			if <-e == 1 {
				ch <- 3 // food out of stock
				return
			}
		}
		ch <- 0
	}()
	for i := 0; i < 2; i++ {
		switch <-ch {
		case 1:
			ResponseErrOrderOutOfLimit(w)
			return
		case 2:
			ResponseErrCartNotFound(w)
			return
		case 3:
			ResponseErrFoodOutOfStock(w)
			return
		}
	}
	go func() {
		c := pool.Get()
		defer c.Close()
		c.Do("RENAME", cartId, orderHashName)
	}()
	orderId := userId2OrderId[user.Id]
	w.WriteHeader(http.StatusOK)
	b := FastConcatStringsToBytes(3, `{"id":"`, orderId, `"}`)
	ResponseJsonBytes(w, b)
}
Example #24
0
	v   interface{}
	err error
}

func ve(v interface{}, err error) valueError {
	return valueError{v, err}
}

var replyTests = []struct {
	name     interface{}
	actual   valueError
	expected valueError
}{
	{
		"ints([v1, v2])",
		ve(redis.Ints([]interface{}{[]byte("4"), []byte("5")}, nil)),
		ve([]int{4, 5}, nil),
	},
	{
		"ints(nil)",
		ve(redis.Ints(nil, nil)),
		ve([]int(nil), redis.ErrNil),
	},
	{
		"strings([v1, v2])",
		ve(redis.Strings([]interface{}{[]byte("v1"), []byte("v2")}, nil)),
		ve([]string{"v1", "v2"}, nil),
	},
	{
		"strings([v1, v2])",
		ve(redis.Strings([]interface{}{"v1", "v2"}, nil)),
Example #25
0
var (
	redisunderstands = map[string]func(interface{}, error) (interface{}, error){
		"bool": func(r interface{}, e error) (interface{}, error) {
			return redis.Bool(r, e)
		},
		"float64": func(r interface{}, e error) (interface{}, error) {
			return redis.Float64(r, e)
		},
		"int": func(r interface{}, e error) (interface{}, error) {
			return redis.Int(r, e)
		},
		"int64": func(r interface{}, e error) (interface{}, error) {
			return redis.Int64(r, e)
		},
		"ints": func(r interface{}, e error) (interface{}, error) {
			return redis.Ints(r, e)
		},
		"string": func(r interface{}, e error) (interface{}, error) {
			return redis.String(r, e)
		},
		"strings": func(r interface{}, e error) (interface{}, error) {
			return redis.Strings(r, e)
		},
		"uint64": func(r interface{}, e error) (interface{}, error) {
			return redis.Uint64(r, e)
		},
		"values": func(r interface{}, e error) (interface{}, error) {
			return redis.Values(r, e)
		},
		"stringmap": func(r interface{}, e error) (interface{}, error) {
			return redis.StringMap(r, e)
Example #26
0
func (*RedisStore) Ints(reply interface{}, err error) ([]int, error) {
	return redis.Ints(reply, err)
}