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
}
Exemple #4
0
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)
	}
}
Exemple #7
0
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
}
Exemple #8
0
// 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
}
Exemple #10
0
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()
	}
}
Exemple #12
0
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
	}
}
Exemple #13
0
// 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
		}
	}
}
Exemple #14
0
// 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)
	}
}
Exemple #15
0
// 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)
}
Exemple #16
0
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
}
Exemple #18
0
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)
	}
}
Exemple #19
0
// 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())
}
Exemple #20
0
// 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)
}
Exemple #21
0
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)
	}
}
Exemple #23
0
Fichier : db.go Projet : porjo/yag
// 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)
			}
		}
	}
}
Exemple #24
0
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())
	}
}
Exemple #26
0
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
}
Exemple #27
0
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
}
Exemple #29
0
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
}
Exemple #30
0
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
}