func (subscriber *Subscriber) Work(queueName string, concurrency int, fn Worker) {
subscriber.isRunning = true
subscriber.workChannel = make(chan string)
for i := 0; i < concurrency; i++ {
subscriber.wg.Add(1)
go subscriber.doWork(fn)
}
go func() {
for subscriber.isRunning {
connection := subscriber.connectionPool.Get()
data, err := connection.Do("BRPOP", "ceausescu:"+queueName, 0)
if err != nil {
log.Println(err)
continue
}
connection.Close()
result, err := redis.StringMap(data, nil)
if err != nil {
log.Println(err)
continue
}
subscriber.workChannel <- result["ceausescu:"+queueName]
}
}()
}
func instanceIsMaster(pool *redis.Pool, port string) {
c := pool.Get()
defer c.Close()
for {
master, err := redis.StringMap(c.Do("CONFIG", "GET", "slaveof"))
if err != nil {
// Retry connection to Redis until it is back.
//log.Println(err)
defer c.Close()
time.Sleep(time.Second * time.Duration(connectionLostInterval))
c = pool.Get()
continue
}
for _, value := range master {
if value != "" {
// Instance is now a slave, notify.
if fetchPossible[port] {
c.Do("PUBLISH", "redis-scouter", "stop")
fetchPossible[port] = false
log.Printf("[instance-check-%s] became a slave", port)
}
} else {
// Re-enable metrics.
if !fetchPossible[port] {
fetchPossible[port] = true
log.Printf("[instance-check-%s] became a master", port)
}
}
}
time.Sleep(time.Second * time.Duration(masterCheckInterval))
}
}
func GetRedisSlaves(node *HANodeSt) {
redisConn := gRedisPool.Get()
defer redisConn.Close()
//values, err := redis.Strings(redisConn.Do("SENTINEL", "slaves", "mymaster" ))
//values, err := redisConn.Do("SENTINEL", "slaves", "mymaster" )
//values, err := redisConn.Do("get", "hello1" )
values, err := redis.Values(redisConn.Do("SENTINEL", "slaves", node.Name))
if err != nil {
log.Errorf("get master error:%s", err.Error())
}
slaveNo := len(values)
slaveList := list.New()
for i := 0; i < slaveNo; i++ {
smap, _ := redis.StringMap(values[i], nil)
host := smap["ip"]
port := smap["port"]
flag := smap["flags"]
if flag != "slave" {
continue
}
slaveList.PushBack(host + ":" + port)
}
node.Slaves = slaveList
//gHANodeMap[item] = node
}
//GetJobs returns all the command jobs
func (client *clientImpl) GetJobs(ID string, timeout int) ([]*Job, error) {
db := client.redis.Get()
defer db.Close()
queue := fmt.Sprintf(cmdQueueCmdQueued, ID)
data, err := db.Do("BRPOPLPUSH", queue, queue, timeout)
if err != nil {
return nil, err
}
if data == nil {
return nil, TIMEOUT
}
resultQueue := fmt.Sprintf(hashCmdResults, ID)
jobsdata, err := redis.StringMap(db.Do("HGETALL", resultQueue))
if err != nil {
return nil, err
}
results := make([]*Job, 0, 10)
for _, jobdata := range jobsdata {
result := &Job{}
if err := json.Unmarshal([]byte(jobdata), result); err != nil {
return nil, err
}
result.redis = client.redis
results = append(results, result)
}
return results, nil
}
// Expired implements the `func Expired` defined on the Strategy interface. It
// scans iteratively over the Heart's `location` field to look for items that
// have expired. An item is marked as expired iff the last update time happened
// before the instant of the maxAge subtracted from the current time.
func (s HashExpireyStrategy) Expired(location string,
pool *redis.Pool) (expired []string, err error) {
now := time.Now()
cnx := pool.Get()
defer cnx.Close()
reply, err := redis.StringMap(cnx.Do("HGETALL", location))
if err != nil {
return
}
for id, tick := range reply {
lastUpdate, err := time.Parse(DefaultTimeFormat, tick)
if err != nil {
continue
} else if lastUpdate.Add(s.MaxAge).Before(now) {
expired = append(expired, id)
}
}
return
}
func forward(incoming, outgoing chan slack.Message) {
c := redisPool.Get()
defer c.Close()
for m := range incoming {
if m.Type != "message" {
continue
}
ok, err := redis.Bool(c.Do("SISMEMBER", KEY_CHANNELS, m.Channel))
if err != nil {
log.Println(err)
} else if ok {
fwdMap, err := redis.StringMap(c.Do("HGETALL", m.Channel))
if err != nil {
log.Println(err)
} else {
for query, toChanId := range fwdMap {
ok, err := regexp.MatchString(query, m.Text)
if err != nil {
log.Println(err)
} else if ok {
m.Channel = toChanId
outgoing <- m
}
}
}
}
}
}
func (rr *Redrec) getItemScores(item string, max int) (map[string]string, error) {
scores, err := redis.StringMap(rr.rconn.Do("ZREVRANGE", fmt.Sprintf("item:%s:scores", item), 0, max))
if err != nil {
return nil, err
}
return scores, nil
}
func queueStats(port string) {
// Connect to redis.
pool := newPool(port)
c := pool.Get()
if !instanceAlive(pool) {
log.Printf("error: cannot connect to redis on port %s, aborting\n", port)
return
}
// Subscribe to the keyspace notifications.
c.Send("PSUBSCRIBE", "__keyspace@*", "redis-scouter")
c.Flush()
// Ignore first two ACKs when subscribing.
c.Receive()
c.Receive()
go instanceIsMaster(pool, port)
go keyspaceEnable(pool, port)
for {
if fetchPossible[port] {
reply, err := redis.StringMap(c.Receive())
if err != nil {
// Retry connection to Redis until it is back.
defer c.Close()
log.Printf("connection to redis lost. retry in %ds\n", connectionLostInterval)
time.Sleep(time.Second * time.Duration(connectionLostInterval))
c = pool.Get()
//go keyspaceEnable(pool, port)
c.Send("PSUBSCRIBE", "__keyspace@*", "redis-scouter")
c.Flush()
c.Receive()
c.Receive()
continue
}
// Match for a LIST keyspace event.
for k, v := range reply {
if v == "stop" {
// Break loop if we get a message on redis-scouter pubsub.
continue
}
operation := listOperationsRegex.FindString(v)
queue := keyspaceRegex.FindStringSubmatch(k)
if len(queue) == 2 && operation != "" {
Stats.Add(fmt.Sprintf("%s.%s.%s", port, queue[1], operation), 1)
}
}
} else {
// Do not fetch stats for now.
time.Sleep(time.Second * time.Duration(fetchMetricsInterval))
}
}
}
// GetStringMap returns map[string]string, err by its key
//returns nil and a filled error if something wrong happens
func (r *Service) GetStringMap(key string) (map[string]string, error) {
redisVal, err := r.Get(key)
if redisVal == nil {
return nil, ErrKeyNotFound.Format(key)
}
_map, err := redis.StringMap(redisVal, err)
if err != nil {
return nil, err
}
return _map, nil
}
func c_redis_counters(server string, db int) (opentsdb.MultiDataPoint, error) {
var md opentsdb.MultiDataPoint
conn, err := redis.Dial("tcp", server, redis.DialDatabase(db))
if err != nil {
return md, err
}
defer conn.Close()
if _, err := conn.Do("CLIENT", "SETNAME", "scollector"); err != nil {
return md, err
}
cursor := 0
for {
vals, err := redis.Values(conn.Do("HSCAN", collect.RedisCountersKey, cursor))
if err != nil {
return md, err
}
if len(vals) != 2 {
return md, fmt.Errorf("Unexpected number of values")
}
cursor, err = redis.Int(vals[0], nil)
if err != nil {
return md, err
}
pairs, err := redis.StringMap(vals[1], nil)
if err != nil {
return md, err
}
for mts, val := range pairs {
parts := strings.Split(mts, ":")
if len(parts) != 2 {
slog.Errorf("Invalid metric tag set counter: %s", mts)
continue
}
metric := parts[0]
tags, err := opentsdb.ParseTags(parts[1])
if err != nil {
slog.Errorf("Invalid tags: %s", parts[1])
continue
}
v, err := strconv.Atoi(val)
if err != nil {
slog.Errorf("Invalid counter value: %s", val)
continue
}
Add(&md, metric, v, tags, metadata.Counter, metadata.Count, "")
}
if cursor == 0 {
break
}
}
return md, nil
}
func (r *Checkpointer) Begin() error {
conn := r.pool.Get()
defer conn.Close()
res, err := conn.Do("HGETALL", r.redisPrefix+".sequence")
r.heads, err = redis.StringMap(res, err)
if err != nil {
return err
}
r.wg.Add(1)
go r.RunCheckpointer()
return nil
}
func (this *UserOption) GetAll() []*User {
c := this.RO.Pool.Get()
defer c.Close()
length, _ := redis.Int(c.Do("LLEN", this.userListKey))
users := make([]*User, length)
userNames, _ := redis.Strings(c.Do("LRANGE", this.userListKey, 0, length-1))
for k, userName := range userNames {
userMap, _ := redis.StringMap(c.Do("HGETALL", this.nameKey(userName)))
time, _ := strconv.ParseInt(userMap["time"], 10, 64)
users[k] = NewUser(userMap["name"], userMap["nick"], userMap["password"], userMap["salt"], time)
}
return users
}
func c_redis_counters(server string, db int) (opentsdb.MultiDataPoint, error) {
var md opentsdb.MultiDataPoint
conn, err := redis.Dial("tcp", server, redis.DialDatabase(db))
if err != nil {
return md, slog.Wrap(err)
}
defer conn.Close()
//do a dance to detect proper hscan command for ledis or redis
hscanCmd := "XHSCAN"
info, err := redis.String(conn.Do("info", "server"))
if err != nil {
return md, slog.Wrap(err)
}
if strings.Contains(info, "redis_version") {
hscanCmd = "HSCAN"
}
cursor := "0"
for {
vals, err := redis.Values(conn.Do(hscanCmd, collect.RedisCountersKey, cursor))
if err != nil {
return md, slog.Wrap(err)
}
if len(vals) != 2 {
return md, fmt.Errorf("Unexpected number of values")
}
cursor, err = redis.String(vals[0], nil)
if err != nil {
return md, slog.Wrap(err)
}
pairs, err := redis.StringMap(vals[1], nil)
if err != nil {
return md, slog.Wrap(err)
}
for key, val := range pairs {
ak := models.AlertKey(key)
v, err := strconv.Atoi(val)
if err != nil {
slog.Errorf("Invalid counter value: %s", val)
continue
}
Add(&md, ak.Name(), v, ak.Group(), metadata.Counter, metadata.Count, "")
}
if cursor == "" || cursor == "0" {
break
}
}
return md, nil
}
// HGETALL() does the "HGETALL" command.
//
// Params:
// conn: redis.Conn.
// key: key stores the hash.
// Return:
// m: map contains the specified fields and their respective values.
// err: nil if no error occurs or specified error otherwise.
func HGETALL(conn redis.Conn, key string) (m map[string]string, err error) {
if err = CheckKey(key); err != nil {
return nil, err
}
if m, err = redis.StringMap(conn.Do("HGETALL", key)); err != nil {
if DEBUG {
fmt.Printf("HGETALL(%v) err: %v\n", key, err)
}
return nil, err
}
return m, nil
}
func (this *UserOption) Get(name string) (*User, error) {
c := this.RO.Pool.Get()
defer c.Close()
key := this.nameKey(name)
if existed, _ := redis.Int(c.Do("EXISTS", key)); existed == 0 {
return nil, fmt.Errorf("不存在")
}
userMap, err := redis.StringMap(c.Do("HGETALL", key))
if err != nil {
return nil, err
}
time, _ := strconv.ParseInt(userMap["time"], 10, 64)
return NewUser(userMap["name"], userMap["nick"], userMap["password"], userMap["salt"], time), nil
}
func (m MRedis) Hgetall(s string) {
c, err := redis.Dial("tcp", "127.0.0.1:6379", redis.DialDatabase(2))
if err != nil {
panic(err)
}
defer c.Close()
ok, err := redis.StringMap(c.Do("HGETALL", "*.pplive.com"))
if err != nil {
panic(err)
}
for k, v := range ok {
fmt.Printf("%s = %s\n", k, v)
}
}
func loadNodes() error {
nodes = make(map[string]*node)
servers, err := redis.StringMap(do("HGETALL", "servers"))
if err != nil {
return err
}
for name, ip := range servers {
nn, err := newNode(name, ip)
if err != nil {
return err
}
nodes[nn.name] = nn
}
return nil
}
func (client *client) GetConfig(key string) (string, error) {
configCommand := client.lookupAlias("CONFIG")
output, err := redisclient.StringMap(client.connection.Do(configCommand, "GET", key))
if err != nil {
return "", err
}
value, found := output[key]
if !found {
return "", fmt.Errorf("Key '%s' not found", key)
}
return value, nil
}
func checkUser(regUser UserInfo) (map[string]string, error) {
c, err := redis.Dial("tcp", "localhost:6379")
errStr := make(map[string]string)
if err != nil {
fmt.Println("Connect to redis error", err)
return errStr, err
}
defer c.Close()
if res, err := redis.StringMap(c.Do("hgetall", userListKey+regUser.UserName)); err != nil {
return errStr, err
} else {
return res, nil
}
}
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"])
}
func updateCache() {
c, err := redis.Dial("tcp", "172.16.25.133:6379", redis.DialReadTimeout(time.Second*time.Duration(1)))
if err != nil {
log.Error(err)
return
}
defer c.Close()
values, err := redis.StringMap(c.Do("HGETALL", "se:adspaceMap"))
if err != nil {
log.Error(err)
return
}
for k, v := range values {
log.Info(k, v)
var adspaceEntity AdspaceEntity
json.Unmarshal([]byte(v), &adspaceEntity)
if adspaceEntity.DemandAdspaces != nil && len(adspaceEntity.DemandAdspaces) >= 1 {
for _, adspace := range adspaceEntity.DemandAdspaces {
if adspace == nil || adspace.Timeout <= 0 || adspace.Weight <= 0 || adspace.DemandAdspaceKey == "" {
log.Warn(k, v)
continue
}
if adspace.OsType != "" {
as := adspaceCache[k+"_"+adspace.OsType]
as = append(as, *adspace)
adspaceCache[k+"_"+adspace.OsType] = as
} else {
as_android := adspaceCache[k+"_"+system.OS_ANDROID]
as_android = append(as_android, *adspace)
as_ios := adspaceCache[k+"_"+system.OS_IOS]
as_ios = append(as_ios, *adspace)
adspaceCache[k+"_"+system.OS_ANDROID] = as_android
adspaceCache[k+"_"+system.OS_IOS] = as_ios
}
}
}
}
}
func (redisSource *RedisSource) Get() (map[string]interface{}, error) {
connection, err := redis.DialURL(redisSource.URI)
if err != nil {
return nil, err
}
reply, err := redis.StringMap(connection.Do("HGETALL", redisSource.Key))
result := make(map[string]interface{})
for key, value := range reply {
result[key] = value
}
return result, nil
}
func getMailConfigFromRedis() (map[string]string, error) {
defer func() {
msg := recover()
if msg != nil {
fmt.Println("Panic error :", msg)
return
}
}()
conn := driver.RedisPool.Get()
defer conn.Close()
m, err := redis.StringMap(conn.Do("hgetall", REDIS_SEND_MAIL_CONFIG_TABLE))
if err != nil {
return nil, err
}
return m, nil
}
func (a *Alerter) GetAll(key_search string) (map[string][]map[string]interface{}, error) {
var alerts = make(map[string][]map[string]interface{})
conn := a.pool.Get()
defer conn.Close()
keys, _ := redis.Strings(conn.Do("KEYS", key_search))
for _, v := range keys {
capsule_id := strings.Split(v, ":")[1]
current, _ := redis.StringMap(conn.Do("HGETALL", v))
for _, alert := range current {
var dat map[string]interface{}
if err := json.Unmarshal([]byte(alert), &dat); err != nil {
return alerts, err
}
alerts[capsule_id] = append(alerts[capsule_id], dat)
}
}
return alerts, nil
}
func (this *TSKLOption) Get(user *User) (*TSKL, error) {
c := this.RO.Pool.Get()
defer c.Close()
key := this.nameKey(user.Name)
if existed, _ := redis.Int(c.Do("EXISTS", key)); existed == 0 {
return nil, fmt.Errorf("不存在")
}
tsklMap, err := redis.StringMap(c.Do("HGETALL", key))
if err != nil {
return nil, err
}
tskl := NewTSKL(user)
tskl.Hash = tsklMap["hash"]
tskl.Send = tsklMap["send"]
tskl.Back = tsklMap["back"]
tskl.Berr = tsklMap["berr"]
return tskl, nil
}
// GetAll returns all keys and their values from a specific key (map[string]string)
// returns a filled error if something bad happened
func (r *Service) GetAll(key string) (map[string]string, error) {
c := r.pool.Get()
defer c.Close()
if err := c.Err(); err != nil {
return nil, err
}
reply, err := c.Do("HGETALL", r.Config.Prefix+key)
if err != nil {
return nil, err
}
if reply == nil {
return nil, ErrKeyNotFound.Format(key)
}
return redis.StringMap(reply, err)
}
func (p *RedisCounterStorage) GetOptions(counterName, key string) (opts []CounterOption, exist bool) {
conn := p.pool.Get()
defer conn.Close()
redisKey := p.redisConfig.Prefix + _CONFIG_ + counterName + ":" + key
vals, err := conn.Do("HGETALL", redisKey)
if kvVals, e := redis.StringMap(vals, err); e != nil {
exist = false
return
} else {
for k, v := range kvVals {
opts = append(opts, CounterOption{OptionName(k), v})
}
exist = true
}
return
}
func (ut *UserToken) getUserIdFromTokenCache() bool {
conn := config.RedisPool.Get()
defer conn.Close()
v, err := redis.Values(conn.Do("HGETALL", "Token:"+ut.Token))
if len(v) == 0 {
return false
}
if err != nil {
log.Err(ae.Redis("", err))
return false
}
vMap, _ := redis.StringMap(v, nil)
ut.UserID, _ = strconv.ParseUint(vMap["user_id"], 10, 64)
ut.RefreshToken, _ = vMap["refresh_token"]
ut.Created, _ = time.Parse("2006-01-02 15:04:05.999999999 -0700 -0700", vMap["created"])
ut.Expires, _ = time.Parse("2006-01-02 15:04:05.999999999 -0700 -0700", vMap["expires"])
return true
}
func (sched *Scheduler) Start() {
db := sched.pool.Get()
defer db.Close()
var cursor int
for {
slice, err := redis.Values(db.Do("HSCAN", hashScheduleKey, cursor))
if err != nil {
log.Println("Failed to load schedule from redis", err)
break
}
var fields interface{}
if _, err := redis.Scan(slice, &cursor, &fields); err == nil {
set, _ := redis.StringMap(fields, nil)
for key, cmd := range set {
job := &SchedulerJob{}
err := json.Unmarshal([]byte(cmd), job)
if err != nil {
log.Println("Failed to load scheduled job", key, err)
continue
}
job.ID = key
sched.cron.AddJob(job.Cron, job)
}
} else {
log.Println(err)
break
}
if cursor == 0 {
break
}
}
sched.cron.Start()
}
func main() {
c, err := redis.Dial("tcp", "10.100.51.125:6379")
if err != nil {
fmt.Println(err)
return
}
defer c.Close()
n, err := redis.StringMap(c.Do("HGETALL", "yes_dsp"))
if err != nil {
fmt.Println(err)
return
}
for _, value := range n {
js, err := json.NewJson([]byte(value))
if err != nil {
fmt.Println(err)
continue
}
bidurl, err := js.Get("bidURL").String()
if err != nil {
fmt.Println(err)
continue
}
purl, err := url.Parse(bidurl)
if err != nil {
fmt.Println(err)
continue
}
prefix := purl.Host[0]
if prefix == '1' || prefix == '2' || prefix == '3' || prefix == '4' || prefix == '5' || prefix == '6' || prefix == '7' || prefix == '8' || prefix == '9' || prefix == '0' {
continue
}
hosts := strings.Split(purl.Host, ":")
/*if len(hosts) > 1 {
fmt.Println(hosts[1])
}*/
fmt.Println(hosts[0])
}
}