func Register_lua_db_CachePool_Do(L *lua.LState) int {
	ud := L.CheckUserData(1)
	cmd := L.CheckString(2)
	arg1 := L.CheckString(3)
	var value []byte
	var err error
	if v, ok := ud.Value.(*db.CachePool); ok {
		if L.GetTop() == 4 {
			arg2 := L.CheckString(4)
			value, err = redis.Bytes(v.Do(cmd, arg1, arg2))
		} else {
			value, err = redis.Bytes(v.Do(cmd, arg1))
		}
	}
	if err == nil {
		L.Push(lua.LString(string(value)))
		L.Push(lua.LString(""))
	} else {
		if err != nil {
			L.Push(lua.LString(""))
			L.Push(lua.LString(err.Error()))
		} else {
			L.Push(lua.LString(""))
			L.Push(lua.LString("not string type value"))
		}
		logger.Error("Register_lua_db_CachePool_Do Error : %v, %v", value, err)
	}

	return 2
}
Exemple #2
0
func GetUserByName(name string) (user *UserInfo, err error) {
	conn := userRedisPool.Get()
	defer conn.Close()
	key := fmt.Sprintf("n_%s", name)
	var val []byte
	if val, err = redis.Bytes(conn.Do("get", key)); err != nil {
		if err == redis.ErrNil {
			err = UserNotExist
			return
		}
		return
	}

	uid := binary.LittleEndian.Uint32(val)
	idkey := fmt.Sprintf("u%d", uid)
	if val, err = redis.Bytes(conn.Do("get", idkey)); err != nil {
		if err == redis.ErrNil {
			err = UserNotExist
			return
		}
		return
	}

	var u UserInfo
	if err = json.Unmarshal(val, &u); err != nil {
		return
	}
	user = &u
	return
}
Exemple #3
0
func ReadPairs(reply interface{}) (vals map[string]string, res interface{}, err error) {

	rows, ok := reply.([]interface{})

	if !ok {
		fmt.Println("Result not an []interface{}.")
		return vals, reply, err
	}

	ln := len(rows)

	if ln%2 != 0 {
		fmt.Println("len(rows) is not even: ", ln)
		return vals, reply, err
	}

	count := ln / 2
	vals = make(map[string]string)

	err = nil

	for i := 0; i < count; i++ {
		n := i * 2
		k, err := redis.Bytes(rows[n], err)
		v, err := redis.Bytes(rows[n+1], err)

		if err != nil {
			fmt.Println("Couldn't convert via redis.Bytes(row)")
		}

		vals[string(k)] = string(v)
	}

	return vals, reply, err
}
Exemple #4
0
func (c *Client) Queues(name string) ([]*Queue, error) {
	args := []interface{}{0, "queues", timestamp()}
	if name != "" {
		args = append(args, name)
	}

	byts, err := redis.Bytes(c.Do("qless", args...))
	if err != nil {
		return nil, err
	}

	qr := []*Queue{NewQueue(c)}
	if name == "" {
		err = json.Unmarshal(byts, &qr)
		for _, q := range qr {
			q.cli = c
		}
	} else {
		err = json.Unmarshal(byts, &qr[0])
	}

	if err != nil {
		return nil, err
	}

	return qr, err
}
Exemple #5
0
func (problem Problem) GetState(user models.User) (*ProblemState, error) {
	redisC := models.RedisPool.Get()
	defer redisC.Close()

	log.WithFields(log.Fields{
		"user_id":      user.Id,
		"problem_name": problem.Name,
	}).Info("Getting state in Redis")

	stateBytes, err := redis.Bytes(redisC.Do("GET", problem.GetKeyForUser(user)))
	if err == redis.ErrNil {
		return &ProblemState{Status: StatusStarting, StartedAt: time.Now(), EndingAt: time.Now().Add(problem.SolvingTime)}, nil
	}
	if err != nil {
		return nil, err
	}

	var state ProblemState
	pCache := bytes.NewBuffer(stateBytes)
	decCache := gob.NewDecoder(pCache)
	gob.Register(ReverseData{})
	err = decCache.Decode(&state)
	if err != nil {
		return nil, err
	}

	return &state, nil
}
Exemple #6
0
func (p *portalAPI) activateUser(res http.ResponseWriter, req *http.Request) {
	vars := mux.Vars(req)
	activationKey := vars["key"]
	r := p.a.redis.Get()
	actJson, err := redis.Bytes(r.Do("GET", "activation:"+activationKey))
	if err != nil {
		if err == redis.ErrNil {
			abort(res, 403, "Invalid or expired activation code.")
			return
		} else {
			abort(res, 500, err.Error())
		}
	}
	act := activationData{}
	json.Unmarshal(actJson, &act)
	if act.Email == "" {
		abort(res, 500, "Invalid activation data.")
		return
	}
	if p.m.ActivateUser(act.Email) != nil {
		abort(res, 500, "Could not activate account: %s", err.Error())
		return
	}
	r.Do("DELETE", "activation:"+activationKey)
	if act.After != "" {
		http.Redirect(res, req, act.After, 302)
	} else {
		res.WriteHeader(http.StatusOK)
		res.Write([]byte("Activation successful. Please return to the login page and log in."))
	}
}
Exemple #7
0
func (this *ReqRedisModule) GetMaterial(ads *[]context.AdInfo) (err error) {

	utils.DebugLog.Write("start to get material, ads len[%d]", len(*ads))
	var ids []int64
	for i := 0; i < len(*ads); i++ {
		ids = append(ids, (*ads)[i].Adid)
	}
	var ans []interface{}
	utils.DebugLog.Write("request is [%s]", ids)
	ans, err = this.query(ids)
	if err != nil {
		utils.WarningLog.Write("request redis fail . err[%s]", err.Error())
		return
	}
	var material_tmp jesgoo_protocol.Material
	for i := 0; i < len(ans); i++ {
		tp, err := redis.Bytes(ans[i], nil)
		if err != nil {
			utils.WarningLog.Write("read redis return fail err[%s]", err.Error())
			continue
		}
		err = proto.Unmarshal(tp, &material_tmp)
		if err != nil {
			utils.FatalLog.Write("parse material fail . adid[%d]", (*ads)[i].Adid)
			continue
		}
		err = this.fill_material(&(*ads)[i], &material_tmp)
		if err != nil {
			utils.FatalLog.Write("fill material fail . adid[%d] err[%s]", (*ads)[i].Adid, err.Error())
		}
		//		utils.DebugLog.Write("get material . [%s]", tp)
	}
	err = nil
	return
}
/*
Get the session for this request from Redis
*/
func (sh *SessionHolder) Get(c web.C, r *http.Request) (*base.Session, error) {
	sessionId := sh.GetSessionId(r)
	if sessionId == "" {
		return nil, base.ErrorSessionNotFound
	}

	conn := c.Env["redis"].(redigo.Conn)

	sess, err := conn.Do("GET", sessionKey(sessionId))
	if err != nil {
		return nil, err
	}
	if sess == nil {
		return nil, base.ErrorSessionNotFound
	}
	sessionBytes, err := redigo.Bytes(sess, err)
	if err != nil {
		return nil, err
	}

	dec := gob.NewDecoder(bytes.NewReader(sessionBytes))
	var session base.Session
	err = dec.Decode(&session)
	if err == nil {
		session.SetId(sessionId)
	}

	return &session, err
}
Exemple #9
0
/**
 * 缓存一定时间
 */
func (this *RedisPool) GetCachedEx(res interface{}, key string, expire int, f RedisCommondRunner) error {
	c := this.RedisPool().Get()
	// defer c.Close()

	reply, err := redis.Bytes(c.Do("GET", key))
	if err == nil && reply != nil {
		c.Close()
		return json.Unmarshal(reply, res)
	}

	if err = f(); err != nil {
		c.Close()
		return err
	}

	var buf []byte
	if buf, err = json.Marshal(res); err != nil {
		c.Close()
		return err
	}

	_, err = c.Do("SETEX", key, expire, buf)
	if err != nil {
		log.Println("REDIS SETEX", key, "failed", err)
	}

	c.Close()
	return nil
}
Exemple #10
0
// verifyMaster verifies that the decided master node has fully transitioned
func verifyMaster(addr, pass string) error {
	// connect to redis in order to verify its state
	r, err := redis.DialURL("redis://"+addr, redis.DialConnectTimeout(config.TimeoutNotReady), redis.DialPassword(pass))
	if err != nil {
		return fmt.Errorf("Failed to reach redis at: '%v'", addr)
	}

	// give redis some time to transition
	timeout := time.After(config.TimeoutMasterWait)

	for {
		select {
		case <-timeout:
			return fmt.Errorf("Timed out waiting for redis to transition to master")
		default:
			// retrieve the redis node's role
			info, err := redis.Bytes(r.Do("INFO", "replication"))
			if err != nil {
				return fmt.Errorf("Failed to get INFO - %v", err)
			}

			// check if node is master
			if strings.Contains(string(info), "role:master") {
				return nil
			}
		}
	}

	// cleanup after ourselves
	r.Close()

	return nil
}
Exemple #11
0
func Deq(pool *redis.Pool, latch *utee.Throttle, uid interface{}) ([]byte, error) {
	c := pool.Get()
	defer c.Close()
	defer latch.Release()
	for {
		name := qname(uid)
		k, err := redis.String(c.Do("LPOP", name))
		if err != nil && err != redis.ErrNil {
			continue
		}

		if len(k) == 0 {
			break
		}
		b, err := redis.Bytes(c.Do("GET", k))
		if err != nil && err != redis.ErrNil {
			continue
		}
		if b != nil {
			c.Send("DEL", k)
			continue
		}
	}
	i++
	if i%10000 == 0 {
		log.Println("@success:", i)
	}
	return nil, nil
}
Exemple #12
0
// Do executes function f for each document in the database.
func (db *Database) Do(f func(*doc.Package, []Package) error) error {
	c := db.Pool.Get()
	defer c.Close()
	keys, err := redis.Values(c.Do("KEYS", "pkg:*"))
	if err != nil {
		return err
	}
	for _, key := range keys {
		p, err := redis.Bytes(c.Do("HGET", key, "gob"))
		if err == redis.ErrNil {
			continue
		}
		if err != nil {
			return err
		}
		p, err = snappy.Decode(nil, p)
		if err != nil {
			return err
		}
		var pdoc doc.Package
		if err := gob.NewDecoder(bytes.NewReader(p)).Decode(&pdoc); err != nil {
			return err
		}
		pkgs, err := db.getSubdirs(c, pdoc.ImportPath, &pdoc)
		if err != nil {
			return err
		}
		if err := f(&pdoc, pkgs); err != nil {
			return err
		}
	}
	return nil
}
Exemple #13
0
func (engine *RedisPoolEngine) Read(key string) (data []byte, err error) {
	c := pool.Get()
	defer c.Close()

	data, err = redis.Bytes(c.Do("GET", key))
	return data, err
}
Exemple #14
0
func gobm(c redis.Conn, m map[string]interface{}) {
	gob.Register(time.Time{})

	var buffer bytes.Buffer
	encoder := gob.NewEncoder(&buffer)

	err := encoder.Encode(m)
	if err != nil {
		panic(err)
	}

	c.Send("MULTI")
	c.Send("SET", "drugs:1", buffer.String())
	c.Send("EXPIRE", "drugs:1", "5")
	r, err := c.Do("EXEC")
	if err != nil {
		panic(err)
	}

	r, err = c.Do("GET", "drugs:1")
	v, err := redis.Bytes(r, err)
	if err != nil {
		panic(err)
	}

	m2 := make(map[string]interface{})
	buffer2 := bytes.NewBuffer(v)
	decoder := gob.NewDecoder(buffer2)
	err = decoder.Decode(&m2)
	if err != nil {
		panic(err)
	}

	// fmt.Printf("%#+v", m2)
}
Exemple #15
0
func kmsgpackm(c redis.Conn, m map[string]interface{}) {
	mp := &kmsgpack.Coder{}

	b, err := mp.Marshal(m)
	if err != nil {
		panic(err)
	}

	c.Send("MULTI")
	c.Send("SET", "drugs:1", string(b))
	c.Send("EXPIRE", "drugs:1", "5")
	r, err := c.Do("EXEC")
	if err != nil {
		panic(err)
	}

	r, err = c.Do("GET", "drugs:1")
	v, err := redis.Bytes(r, err)
	if err != nil {
		panic(err)
	}

	m2 := make(map[string]interface{})
	err = mp.Unmarshal(v, &m2)
	if err != nil {
		panic(err)
	}

	// fmt.Printf("%#+v", m2)
}
Exemple #16
0
func (b *redisBackend) Restore() {
	c := redisPool.Get()
	ctx := b.ctx
	defer c.Close()
	log.Info("redis: restoring ", b.queue)
	t0 := time.Now()

	for {
		if time.Since(t0).Seconds() > 5 {
			log.Info("redis: restoring ...")
			t0 = time.Now()
		}
		reply, err := redis.Bytes(c.Do("RPOP", b.queue))
		if err != nil {
			ctx.restoreDone <- true
			return
		}
		for {
			if ctx.buffering {
				log.Debug("we're buffering, wait restoring..")
				time.Sleep(time.Second)
			} else {
				break
			}
		}
		ctx.parsedLines <- &reply
	}
}
Exemple #17
0
func GetService(key string) ([]byte, error) {
	pool := NewPool()
	c := pool.Get()

	result, err := redis.Bytes(c.Do("GET", key))
	return result, err
}
Exemple #18
0
func (this *RedisStore) Poll(c chan []byte, queue string) error {
	go func() {
		consumer, _ := this.GetConn()
		defer this.CloseConn(consumer)
		var err error

		for {
			consumer, err = this.GetConn()
			if err != nil {
				time.Sleep(time.Millisecond * 100)
				continue
			}

			message, err := redis.Bytes(consumer.Do("LPOP", queue))
			this.CloseConn(consumer)

			if err == nil && len(message) > 0 {
				c <- message
			} else {
				time.Sleep(this.pollingFreq)
			}
		}
	}()

	return nil
}
Exemple #19
0
func (store *RedisStore) Get(id string) (*Session, error) {
	var isNew bool = true
	var values = map[interface{}]interface{}{}

	if len(id) > 0 {
		c := store.pool.Get()

		buf, err := redis.Bytes(c.Do("GET", id))
		c.Close()

		if err != nil && err != redis.ErrNil {
			return nil, err
		}

		if buf != nil {
			values, err = store.codec.Decode(buf)
			if err != nil {
				return nil, err
			}

			isNew = false
		}
	}

	if isNew {
		id = GenerateID()
	}

	s := NewSession(id, store, store.config.MaxAge)

	s.Values = values

	return s, nil
}
Exemple #20
0
// getGobItem searches cache by given key from redis and returns Item data
func (c *RedisCache) getGobItem(key string) (*eurekache.Item, bool) {
	conn, err := c.conn()
	if err != nil {
		return nil, false
	}
	defer conn.Close()

	data, err := conn.Do("GET", c.prefix+key)
	if err != nil {
		return nil, false
	}

	b, err := redis.Bytes(data, err)
	if err != nil {
		return nil, false
	}

	var item eurekache.Item
	dec := gob.NewDecoder(bytes.NewBuffer(b))
	err = dec.Decode(&item)
	if err != nil {
		return nil, false
	}

	return &item, true
}
Exemple #21
0
func findSession(w http.ResponseWriter, r *http.Request, rc redis.Conn) (*Session, error) {
	session := new(Session)

	usertokenCookie, err := r.Cookie("usertoken")
	if err != nil {
		return session, lwutil.NewErr(err)
	}
	usertoken := usertokenCookie.Value

	//redis
	if rc == nil {
		rc = redisPool.Get()
		defer rc.Close()
	}

	sessionBytes, err := redis.Bytes(rc.Do("get", fmt.Sprintf("sessions/%s", usertoken)))
	if err != nil {
		return session, lwutil.NewErr(err)
	}

	err = json.Unmarshal(sessionBytes, session)
	lwutil.CheckError(err, "")

	//update session
	dt := time.Now().Sub(session.Born)
	if dt > sessionUpdateSecond*time.Second {
		newSession(w, session.Userid, session.Username, session.Appid, rc)
	}

	return session, nil
}
Exemple #22
0
func (rs *redisBackend) Read(id string) (*Session, error) {
	conn := rs.db.Get()
	defer conn.Close()
	data, err := redis.Bytes(conn.Do("GET", rs.key(id)))

	if err != nil {
		return nil, err
	}

	s := new(Session)

	if err = json.Unmarshal(data, s); err != nil {
		// try to read profileID as string
		ss := new(sessionString)

		if err = json.Unmarshal(data, ss); err != nil {
			return nil, err
		}

		profileID, err := strconv.Atoi(ss.ProfileID)

		if err != nil {
			return nil, err
		}

		s.ProfileID = profileID
	}

	s.Id = id
	return s, nil
}
Exemple #23
0
// load sbf header from redis
func LoadHeader(conn redis.Conn, refer string) (*SBFHeader, error) {
	if ret, err := redis.Bytes(conn.Do("GETRANGE", refer, 0, SBF_HEADER_SIZE-1)); err == nil {
		if len(ret) > 0 {
			header := new(SBFHeader)
			copy(header.Name[:], ret[0:3])
			copy(header.Version[:], ret[3:8])
			// from bytes to number
			if err := BytesToNumber(ret[8:10], &header.Count); err != nil {
				return nil, err
			}
			if err := BytesToNumber(ret[10:12], &header.FullRate); err != nil {
				return nil, err
			}
			if err := BytesToNumber(ret[12:14], &header.SliceCount); err != nil {
				return nil, err
			}
			if err := BytesToNumber(ret[14:18], &header.SliceSize); err != nil {
				return nil, err
			}
			header.Refer = refer
			return header, nil
		} else {
			return nil, errors.New(fmt.Sprintf("SBF %s NOT FOUND.", refer))
		}
	} else {
		return nil, err
	}
}
Exemple #24
0
func (this *HashMap) GetObject(k string, clazz interface{}) error {
	b, err := redis.Bytes(Do("HGET", this.Name, k))
	if err != nil {
		return err
	}
	return json.Unmarshal(b, clazz)
}
Exemple #25
0
// Get returns the response corresponding to key if present.
func (c cache) Get(key string) (resp []byte, ok bool) {
	item, err := redis.Bytes(c.Do("GET", cacheKey(key)))
	if err != nil {
		return nil, false
	}
	return item, true
}
Exemple #26
0
// Pops a job off the queue.
func (q *Queue) Pop(count int) ([]*Job, error) {
	if count == 0 {
		count = 1
	}

	reply, err := redis.Bytes(q.cli.Do("qless", 0, "pop", timestamp(), q.Name, workerName(), count))
	if err != nil {
		return nil, err
	}

	//"{}"
	if len(reply) == 2 {
		return nil, nil
	}

	//println(string(reply))

	var jobs []*Job
	err = json.Unmarshal(reply, &jobs)
	if err != nil {
		return nil, err
	}

	for _, v := range jobs {
		v.cli = q.cli
	}

	return jobs, nil
}
Exemple #27
0
// Get returns a key value
func Get(key string) ([]byte, error) {
	conn := redisPool.Get()
	defer conn.Close()

	channel := channel(key)
	return redis.Bytes(conn.Do("GET", channel.id()))
}
Exemple #28
0
// Http request handler for posting and getting high scores.
func HandleScore(w http.ResponseWriter, req *http.Request) {
	var out string

	// Connect to the data source.
	conn := pool.Get()
	defer conn.Close()

	outVal, err := redis.Bytes(conn.Do("GET", "highScore:value"))
	if err != nil {
		return
	}

	highScore, err := strconv.ParseFloat(string(outVal), 64)
	if err != nil {
		return
	}

	if req.Method == "GET" {
		// Retrieve the high score from the server and format it as json.
		if err == nil {
			currentHigh := HighScore{float64(highScore), 0}
			marshaled, _ := json.Marshal(currentHigh)
			out = string(marshaled)
		}
	} else if req.Method == "POST" {
		postedScore, err := strconv.ParseFloat(req.FormValue("scorePosted"), 64)
		if err == nil && postedScore > highScore {
			conn.Do("SET", "highScore:value", postedScore)
		}
	}

	io.WriteString(w, out)
}
Exemple #29
0
func (task *FlushTask) readValuesFromRedis(items []dbproto.FlushItem) ([][]byte, error) {
	// TODO:
	// use MGET for performace
	count := len(items)
	values := make([][]byte, count)
	var err error
	var conn redis.Conn
	for i := 0; i < count; i++ {
		redis_key := items[i].GetMsgType() + "_" + items[i].GetKey()
		conn = task.getRedisConn(items[i].GetKey())
		values[i], err = redis.Bytes(conn.Do("GET", redis_key))
		if err != nil {
			logger.Printf("Read Key %s but ERROR: redis: %v", redis_key, err)
			values[i] = nil

			// if no data from redis, just ignore
			if err == redis.ErrNil {
				continue
			}

			// if other errors, return
			return nil, err
		}
	}
	return values, nil
}
Exemple #30
0
func TestSet(t *testing.T) {
	assert := assert.New(t)
	key := "key"

	pool := helper.TestGetPool()
	c := NewRedisCache(pool)
	c.SetPrefix(testRedisPrefix)

	err := c.Set(key, "valueTestSet")
	assert.NoError(err)

	// get data
	b, err := pool.Get().Do("GET", testRedisPrefix+key)
	assert.NoError(err)
	b, err = redis.Bytes(b, err)
	assert.NoError(err)

	buf := bytes.NewBuffer(b.([]byte))
	dec := gob.NewDecoder(buf)

	item := &eurekache.Item{}
	err = dec.Decode(&item)
	assert.NoError(err)
	assert.Equal("valueTestSet", item.Value)

	// delete data
	err = c.Set(key, nil)
	assert.NoError(err)

	b, err = pool.Get().Do("GET", testRedisPrefix+key)
	assert.NoError(err)
	assert.Nil(b)

}