func authenticateByPassword(c *redis.Client, password string) error { if r := c.Cmd("AUTH", password); r.Err != nil { logger.Errorf("Faild to authenticate. %s", r.Err) return r.Err } return nil }
func (u *Universe) SpawnAsteroid(redis_client *redis.Client) { if rand.Float32() < 0.1 { live_asteroids := redis_client.Cmd("KEYS", "asteroid-*") num_asteroids := 1000 if len(live_asteroids.Elems) < num_asteroids { temp_asteroid := &asteroid.Asteroid{gameobject.GameObject{ Id: rand.Intn(500000), X: rand.Float64(), Y: rand.Float64(), Velx: rand.Float64() * 100, Vely: rand.Float64() * 100}, 100} u.Asteroids = append(u.Asteroids, temp_asteroid) asteroid_json, _ := json.Marshal(temp_asteroid) redis_client.Cmd("SET", fmt.Sprintf("asteroid-%v", temp_asteroid.Id), asteroid_json) } // temp_bullet := &bullet.Bullet{gameobject.GameObject{ // Id: rand.Intn(500000), // X: rand.Float64(), // Y: rand.Float64(), // Velx: rand.Float64() * 100, // Vely: rand.Float64() * 100}, // 100} // u.Bullets = append(u.Bullets,temp_bullet) // redis_client.Cmd("SET", fmt.Sprintf("bullet-%v", temp_bullet.Id), temp_bullet) } }
func fetchPercentageOfMemory(c *redis.Client, stat map[string]float64) error { r := c.Cmd("CONFIG", "GET", "maxmemory") if r.Err != nil { logger.Errorf("Failed to run `CONFIG GET maxmemory` command. %s", r.Err) return r.Err } res, err := r.Hash() if err != nil { logger.Errorf("Failed to fetch maxmemory. %s", err) return err } maxsize, err := strconv.ParseFloat(res["maxmemory"], 64) if err != nil { logger.Errorf("Failed to parse maxmemory. %s", err) return err } if maxsize == 0.0 { stat["percentage_of_memory"] = 0.0 } else { stat["percentage_of_memory"] = 100.0 * stat["used_memory"] / maxsize } return nil }
func getBackend(hostname string, defaultBackendType string, redisClient *redis.Client) (string, error) { fmt.Println("Looking up", hostname) backends, error := redisClient.Cmd("smembers", "hostnames:"+hostname+":backends").List() if error != nil { fmt.Println("Error in redis lookup for hostname backend", error) return "", error } if len(backends) == 0 { backends, error = redisClient.Cmd("smembers", "hostnames:"+defaultBackendType+":backends").List() if error != nil { fmt.Println("Error in redis lookup for default backend", error) return "", error } if len(backends) == 0 { fmt.Println("No default backend of type", defaultBackendType) return "", errors.New("Could not find default backend of type " + defaultBackendType) } } fmt.Println("Found backends:", backends) backend := backends[int(rand.Float32()*float32(len(backends)))] return backend, nil }
func getRedisInfo(c *redis.Client) (*map[string]string, error) { info := make(map[string]string) r := c.Cmd("info") if r.Err != nil { return nil, errors.New("couldn't execute query") } str, err := r.Str() if err != nil { return nil, errors.New("couldn't execute query") } for _, line := range strings.Split(str, "\r\n") { if line == "" { continue } if re, _ := regexp.MatchString("^#", line); re { continue } record := strings.SplitN(line, ":", 2) if len(record) < 2 { continue } key, value := record[0], record[1] info[key] = value } return &info, nil }
func SetRedisValue(redisClient *redis.Client, key string, value string) { var reply *redis.Reply = redisClient.Cmd("SET", key, value) if reply.Err != nil { panic(reply.Err) } }
func list(connection *redis.Client) map[string][]string { var blacklisted []string var whitelisted []string var marked []string repsheet := connection.Cmd("KEYS", "*:repsheet:*:*") for i := 0; i < len(repsheet.Elems); i++ { value, _ := repsheet.Elems[i].Str() parts := strings.Split(value, ":") repsheetType := parts[len(parts)-1] switch repsheetType { case "blacklisted": blacklisted = append(blacklisted, parts[0]) case "whitelisted": whitelisted = append(whitelisted, parts[0]) case "marked": marked = append(marked, parts[0]) } } var list = make(map[string][]string) list["blacklisted"] = blacklisted list["whitelisted"] = whitelisted list["marked"] = marked return list }
// Returns a client back to the pool. If the pool is full the client is closed // instead. If the client is already closed (due to connection failure or // what-have-you) it should not be put back in the pool. The pool will create // more connections as needed. func (p *Pool) Put(conn *redis.Client) { select { case p.pool <- conn: default: conn.Close() } }
func storeCacheValues(rascalData []byte, cdnName string, sampleTime int64, cacheGroupMap map[string]string, redisClient *redis.Client) error { /* note about the redis data: keys are cdnName:deliveryService:cacheGroup:cacheName:statName */ type CacheStatsJson struct { Pp string `json:"pp"` Date string `json:"date"` Caches map[string]map[string][]struct { Index uint64 `json:"index"` Time uint64 `json:"time"` Value string `json:"value"` Span uint64 `json:"span"` } `json:"caches"` } var jData CacheStatsJson err := json.Unmarshal(rascalData, &jData) errHndlr(err, ERROR) statCount := 0 statTotals := make(map[string]float64) for cacheName, cacheData := range jData.Caches { for statName, statData := range cacheData { redisKey := cdnName + ":all:" + cacheGroupMap[cacheName] + ":" + cacheName + ":" + statName redisKey = strings.Replace(redisKey, ":bandwidth", ":kbps", 1) statValue := statData[0].Value //fmt.Printf("%s ->%s\n", redisKey, statValue) statCount++ statFloatValue, err := strconv.ParseFloat(statValue, 64) if err != nil { statFloatValue = 0.0 } statTotals[cdnName+":all:"+cacheGroupMap[cacheName]+":all:"+statName] += statFloatValue statTotals[cdnName+":all:all:all:"+statName] += statFloatValue if statName == "maxKbps" { r := redisClient.Cmd("zadd", redisKey, sampleTime, statValue) // only care for the last val here. errHndlr(r.Err, ERROR) } else { r := redisClient.Cmd("rpush", redisKey, statValue) errHndlr(r.Err, ERROR) } } } for totalKey, totalVal := range statTotals { totalKey = strings.Replace(totalKey, ":bandwidth", ":kbps", 1) if strings.Contains(totalKey, "maxKbps") { r := redisClient.Cmd("zadd", totalKey, sampleTime, strconv.FormatFloat(totalVal, 'f', 2, 64)) errHndlr(r.Err, ERROR) } else { r := redisClient.Cmd("rpush", totalKey, strconv.FormatFloat(totalVal, 'f', 2, 64)) errHndlr(r.Err, ERROR) } statCount++ } r := redisClient.Cmd("rpush", cdnName+":tstamp", sampleTime) errHndlr(r.Err, ERROR) log.Info("Saved ", statCount, " values for ", cdnName, " @ ", sampleTime) return nil }
func someFunc(c *redis.Client) (err error) { reply := c.Cmd("set", "mykey", "myvalue") // what is the recommended error if reply.Err != nil { return reply.Err } // some code here return }
func (rp *redisPool) FreeClient(c *redis.Client) { select { case rp.client_chan <- c: // redisClient on free list; nothing more to do. default: // Free list full, close connection and let it get GC'd log.Info("Free list is full - closing redis connection") go c.Close() } }
func search(connection *redis.Client, actor string) bool { searchString := fmt.Sprintf("%s:*", actor) results := connection.Cmd("KEYS", searchString) if len(results.Elems) == 1 { return true } else { return false } }
// Removes and calls Close() on all the connections currently in the pool. // Assuming there are no other connections waiting to be Put back this method // effectively closes and cleans up the pool. func (p *Pool) Empty() { var conn *redis.Client for { select { case conn = <-p.pool: conn.Close() default: return } } }
// Puts the connection back in the pool for the given address. Takes in a // pointer to an error which can be used to decide whether or not to put the // connection back. It's a pointer because this method is deferable (like // CarefullyPut) func (c *Cluster) putConn(addr string, conn *redis.Client, maybeErr *error) { c.callCh <- func(c *Cluster) { pool := c.pools[addr] if pool == nil { conn.Close() return } pool.CarefullyPut(conn, maybeErr) } }
// A useful helper method which acts as a wrapper around Put. It will only // actually Put the conn back if potentialErr is not an error or is a // redis.CmdError. It would be used like the following: // // func doSomeThings(p *Pool) error { // conn, redisErr := p.Get() // if redisErr != nil { // return redisErr // } // defer p.CarefullyPut(conn, &redisErr) // // var i int // i, redisErr = conn.Cmd("GET", "foo").Int() // if redisErr != nil { // return redisErr // } // // redisErr = conn.Cmd("SET", "foo", i * 3).Err // return redisErr // } // // If we were just using the normal Put we wouldn't be able to defer it because // we don't want to Put back a connection which is broken. This method takes // care of doing that check so we can still use the convenient defer func (p *Pool) CarefullyPut(conn *redis.Client, potentialErr *error) { if potentialErr != nil && *potentialErr != nil { // We don't care about command errors, they don't indicate anything // about the connection integrity if _, ok := (*potentialErr).(*redis.CmdError); !ok { conn.Close() return } } p.Put(conn) }
func GetDomain(key string, conn *redis.Client) (string, error) { reply := conn.Cmd("HGET", "$domainkeys", key) if reply.Type == redis.NilReply { return "", reply.Err } domain, err := reply.Str() if err != nil { return "", err } else { return domain, nil } }
/* the ds json looks like: { "deliveryService": { "linear-gbr-hls-sbr": { "location.us-ma-woburn.kbps": [{ "index": 520281, "time": 1398893383605, "value": "0", "span": 520024 }], "location.us-de-newcastle.kbps": [{ "index": 520281, "time": 1398893383605, "value": "0", "span": 517707 }], } } */ func storeDsValues(rascalData []byte, cdnName string, sampleTime int64, redisClient *redis.Client, dsAggregate map[string]AggregationConfig) error { type DsStatsJson struct { Pp string `json:"pp"` Date string `json:"date"` DeliveryService map[string]map[string][]struct { Index uint64 `json:"index"` Time uint64 `json:"time"` Value string `json:"value"` Span uint64 `json:"span"` } `json:"deliveryService"` } var jData DsStatsJson err := json.Unmarshal(rascalData, &jData) errHndlr(err, ERROR) statCount := 0 statTotals := make(map[string]float64) for dsName, dsData := range jData.DeliveryService { for dsMetric, dsMetricData := range dsData { keyPart := strings.Replace(dsMetric, "location.", "", -1) keyPart = strings.Replace(keyPart, ".kbps", ":all:kbps", -1) keyPart = strings.Replace(keyPart, ".tps", ":all:tps", -1) keyPart = strings.Replace(keyPart, ".status", ":all:status", -1) keyPart = strings.Replace(keyPart, "total:all:", "all:all:", -1) // for consistency all everywhere redisKey := cdnName + ":" + dsName + ":" + keyPart statValue := dsMetricData[0].Value //fmt.Printf("%s ->%s\n", redisKey, statValue) statCount++ aggConfig, exists := dsAggregate[dsMetric] if exists { statFloatValue, err := strconv.ParseFloat(statValue, 64) if err != nil { statFloatValue = 0.0 } statTotals[cdnName+":all:all:all:"+aggConfig.RedisKey] += statFloatValue } r := redisClient.Cmd("rpush", redisKey, statValue) errHndlr(r.Err, ERROR) } } for totalKey, totalVal := range statTotals { r := redisClient.Cmd("rpush", totalKey, strconv.FormatFloat(totalVal, 'f', 2, 64)) errHndlr(r.Err, ERROR) statCount++ } log.Info("Saved ", statCount, " ds values for ", cdnName, " @ ", sampleTime) return nil }
func addToList(connection *redis.Client, list string, actor string, reason string, ttl int) { actorString := fmt.Sprintf("%s:repsheet:ip:%sed", actor, list) if reason == "" { reason = "true" } if ttl < 0 { connection.Cmd("SET", actorString, reason) } else { connection.Cmd("SETEX", actorString, ttl, reason) } }
// benchmark benchmarks the given command with the given parameters // and displays the given test name. func benchmark(c *redis.Client, testname string, command string, params ...interface{}) { fmt.Printf("===== %s =====\n", testname) start := time.Now() for i := 0; i < *requests; i++ { c.Cmd(command, params...) } duration := time.Now().Sub(start) rps := float64(*requests) / duration.Seconds() fmt.Println("Requests per second:", rps) fmt.Printf("Duration: %v\n\n", duration.Seconds()) }
// A useful helper method, analagous to the pool package's CarefullyPut method. // Since we don't want to Put a connection which is having connectivity // issues, this can be defered inside a function to make sure we only put back a // connection when we should. It should be used like the following: // // func doSomeThings(c *Client) error { // conn, redisErr := c.GetMaster("bucket0") // if redisErr != nil { // return redisErr // } // defer c.CarefullyPutMaster("bucket0", conn, &redisErr) // // var i int // i, redisErr = conn.Cmd("GET", "foo").Int() // if redisErr != nil { // return redisErr // } // // redisErr = conn.Cmd("SET", "foo", i * 3).Err // return redisErr // } func (c *Client) CarefullyPutMaster( name string, client *redis.Client, potentialErr *error, ) { if potentialErr != nil && *potentialErr != nil { // If the client sent back that it's READONLY then we don't want to keep // this connection around. Otherwise, we don't care about command errors if cerr, ok := (*potentialErr).(*redis.CmdError); !ok || cerr.Readonly() { client.Close() return } } c.PutMaster(name, client) }
func (self *OutputConfig) closeRedisClient() (err error) { var ( client *redis.Client ) for _, client = range self.clients { client.Close() } self.clients = self.clients[:0] return }
func (u *Universe) InitUniverse(redis_client *redis.Client) { live_asteroids := redis_client.Cmd("KEYS", "asteroid-*") //load asteroids from db u.Asteroids = make([]*asteroid.Asteroid, 0, len(live_asteroids.Elems)) for key := range live_asteroids.Elems { asteroid := &asteroid.Asteroid{} temp_asteroid := redis_client.Cmd("GET", live_asteroids.Elems[key]) if err := json.Unmarshal([]byte(temp_asteroid.String()), &asteroid); err != nil { } u.Asteroids = append(u.Asteroids, asteroid) } }
// Release pushes back client to pool (if number of available clients in the pool is < MaxClients), // otherwise closes client func Release(client *redis.Client) { if client != nil { if len(clients) < config.Cfg.DB.MaxClients { log.Println("Releasing Db Client") clients <- client log.Println("Number of idle Db Clients: ", len(clients)) } else { log.Println("Closing Db Client") if err := client.Close(); err != nil { log.Println("Close error: ", err) } } } }
func (s *Server) GetIdentIndex(db *redis.Client, start int, stop int) ([]Ident, error) { zrange, err := db.Cmd("zrange", "nodes", start, stop).List() if err != nil { return []Ident{}, err } idents := make([]Ident, len(zrange)) for index, signature := range zrange { ident, err := s.GetIdent(db, signature) if err != nil { return []Ident{}, err } idents[index] = ident } return idents, nil }
func (u *Universe) Update(delta_time float64, redis_client *redis.Client) { //here we run the game simulation //check redis for api spawned things //bullets //should we spawn more asteroids? u.SpawnAsteroid(redis_client) //asteroid updates a.Update() for _, a := range u.Asteroids { a.Update(delta_time) //write to redis redis_client.Cmd("SET", fmt.Sprintf("asteroid-%v", a.Id), a.Dump()) } }
func (s *Server) PutIdent(db *redis.Client, identity Ident) (Ident, error) { data, err := identity.ToJson() if err != nil { return identity, err } zadd := db.Cmd("zadd", "nodes", time.Now().Unix(), identity.Signature) if zadd.Err != nil { return identity, zadd.Err } set := db.Cmd("set", node_key(identity.Signature), data) if set.Err != nil { return identity, set.Err } return identity, nil }
func (s *Server) GetIdent(db *redis.Client, signature string) (Ident, error) { ident := Ident{} get := db.Cmd("get", node_key(signature)) if get.Err != nil { return ident, get.Err } if get.Type == redis.NilReply { return ident, errors.New(fmt.Sprintf("Ident %s does not exist.", signature)) } str, err := get.Str() if err != nil { panic(err) } return NewIdentFromString(str) }
func NewConnection() (*redis.Client, chan bool) { var r *redis.Client // we try to get a connection from the pool a number of times for retries := 0; retries < 20; retries++ { r = GetConnectionFromPool() if r != nil { break } redisLock.Lock() breakOnCount := *connectionsAllocated < (connectionPoolCount / 4) redisLock.Unlock() if breakOnCount { break } time.Sleep(time.Millisecond * 1) } if r == nil { redisLock.Lock() *connectionsAllocated++ r = redisinterface.SetupRedisConnection() redisLock.Unlock() fmt.Print("Connections initialized: ", *connectionsAllocated, "\n") } // buffered channel, as the connection // may time out returnChannel := make(chan bool, 1) defer func(rChan chan bool) { go func() { select { case _ = <-rChan: AddConnectionToPool(r) case <-time.After(time.Second * 60): fmt.Print("Connection Timeout") r.Close() } }() }(returnChannel) return r, returnChannel }
func slugExists(redis *redis.Client, slug string) bool { exists, err := redis.Cmd("HEXISTS", UrlStore, slug).Bool() if err != nil { fmt.Println("[!ERR] slugExists - ", err) // TODO: Better to return true, but it could make infinite loop. Make better. return false } return exists }
func (self *OutputConfig) redisSend(client *redis.Client, key string, raw []byte) (err error) { var ( res *redis.Reply ) switch self.DataType { case "list": res = client.Cmd("rpush", key, raw) err = res.Err case "channel": res = client.Cmd("publish", key, raw) err = res.Err default: err = errors.New("unknown DataType: " + self.DataType) } return }