Esempio n. 1
0
func (ps *pubsub) connectRedis() error {
	ps.lock.Lock()
	defer ps.lock.Unlock()

	log.Println("pubsub connect redis")

	redisPub, err := goredis.Dial(&goredis.DialConfig{
		Address: ps.opts.RedisPubAddress})
	if err != nil {
		log.Fatal("Unable to connect to redis pub", err)
		return err
	}
	ps.redisPub = redisPub

	redisSub, err := goredis.Dial(&goredis.DialConfig{
		Address: ps.opts.RedisSubAddress})
	if err != nil {
		log.Fatal("Unable to connect to redis sub", err)
		return err
	}
	ps.redisSub = redisSub

	redisSubscriber, err := redisSub.PubSub()
	if err != nil {
		log.Fatal("Unable to create redis subscriber", err)
		return err
	}
	ps.redisSubscriber = redisSubscriber
	return nil
}
Esempio n. 2
0
func main() {

	ElasticClient, err := elastic.NewClient()
	if err != nil {
		fmt.Println("ES start error: ", err)
	} else {
		fmt.Println("Connection to ES server established successfully...")
	}

	RedisClient, err2 := goredis.Dial(&goredis.DialConfig{Address: "0.0.0.0:6379"})
	if err2 != nil {
		fmt.Println("Redis start error: ", err)
	} else {
		fmt.Println("Connection to redis-server established successfully...")
	}

	file, _ := os.OpenFile("index.txt", os.O_APPEND|os.O_WRONLY, 0666)

	messages := make(chan string)

	go func() {
		for {
			FetchFromRedis(messages, RedisClient)
		}
	}()

	for {
		select {
		case val := <-messages:
			file.WriteString(string(val) + '\n')
			val = StoreDistance(val)
			Store2ES(ElasticClient, file, val)
		}
	}
}
Esempio n. 3
0
func supercars_05_delete(m *gogrinder.Meta, s gogrinder.Settings) {
	var mm *req.HttpMetric
	c := req.NewDefaultClient()
	base := s["supercars_url"].(string)

	b := gg.NewBracket("05_01_supercars_delete")
	redis, err := goredis.Dial(&goredis.DialConfig{Address: s["redis_srv"].(string)})
	if err != nil {
		// is the redis server running? correct address?
		m.Error += err.Error()
		return
	}

	id, err := redis.SPop("supercars")
	if err != nil {
		// probably run out of data - so it does not make sense to continue
		m.Error += err.Error()
		return
	}
	r, err := http.NewRequest("DELETE", base+"/rest/supercars/"+string(id), nil)
	if err != nil {
		m.Error += err.Error()
		mm = &req.HttpMetric{*m, 0, 0, 400}
	} else {
		_, _, mm = req.DoRaw(c, r, m)
	}
	b.End(mm)
}
Esempio n. 4
0
func New(conf *configReader.Config) *redis.Redis {
	conn, connErr := redis.Dial(&redis.DialConfig{Address: conf.RedisAddress})
	if connErr != nil {
		panic(connErr)
	}
	return conn
}
Esempio n. 5
0
func supercars_03_create(m *gogrinder.Meta, s gogrinder.Settings) {
	var mm *req.HttpMetric
	var resp map[string]interface{}
	c := req.NewDefaultClient()
	base := s["supercars_url"].(string)
	newCar := map[string]interface{}{"name": "Ferrari Enzo", "country": "Italy",
		"top_speed": "218", "0-60": "3.4", "power": "650", "engine": "5998",
		"weight": "1365", "description": "The Enzo Ferrari is a 12 cylinder " +
			"mid-engine berlinetta named after the company's founder, Enzo Ferrari.",
		"image": "050.png"}
	b := gg.NewBracket("03_01_supercars_create")
	r, err := req.NewPostJsonRequest(base+"/rest/supercars/", newCar)
	if err != nil {
		m.Error += err.Error()
		mm = &req.HttpMetric{*m, 0, 0, 400}
	} else {
		resp, _, mm = req.DoJson(c, r, m)
		id := resp["_id"].(string)
		if i, err := strconv.Atoi(id); err != nil || i <= RECORDS {
			m.Error += "Error: something went wrong during new record creation!"
		} else {
			redis, err := goredis.Dial(
				&goredis.DialConfig{Address: s["redis_srv"].(string)})
			if err != nil {
				// is the redis server running? correct address?
				m.Error += err.Error()
			} else {
				redis.SAdd("supercars", id) // no way this can go wrong!
			}
		}
	}
	b.End(mm)
}
Esempio n. 6
0
func DeadHostWatch(host string, deadOut chan<- Event, deadQuit <-chan bool) {
	for {
		select {
		case <-deadQuit:
			fmt.Println("Dead Host Watch Quit Message.......")
			close(deadOut)
			return
		default:
			time.Sleep(1000 * time.Millisecond)
			fmt.Printf("Dead Host Watch check....%s\n", host)

			client, err := goredis.Dial(&goredis.DialConfig{Address: host})
			if err != nil {
				log.Printf("Error connection to database %s", err.Error())
				continue
			}
			log.Printf("Dead Host Ping check to database %s", host)
			if err := client.Ping(); err != nil {
				log.Printf("FALSE Ping check to database")
				continue
			}

			e := Event("DeadHostConnectOk")
			deadOut <- e
			client.ClosePool()
		}
	}
}
Esempio n. 7
0
func dial() *goredis.Redis {
	dialConfig := goredis.DialConfig{
		Address: "avialeta-cache:6379",
	}
	client, err := goredis.Dial(&dialConfig)
	if err != nil {
		log.Error.Fatal(err)
	}
	return client
}
Esempio n. 8
0
func storeinRadis(message string, addr string) {
	client, err := goredis.Dial(&goredis.DialConfig{Address: "127.0.0.1:6379"})

	reply, err2 := client.ExecuteCommand("SET", addr, message)
	err1 := reply.OKValue()

	fmt.Println(err1)
	fmt.Println(err)
	fmt.Println(err2)
	fmt.Println(reply)
}
Esempio n. 9
0
func main() {
	client, _ := goredis.Dial(&goredis.DialConfig{Address: "127.0.0.1:6379"})
	for {
		reply, _ := client.RPop("myqueue1")

		if string(reply) != "" {
			storeinDB(string(reply))
			fmt.Println(string(reply))
		}
	}
}
Esempio n. 10
0
File: redis.go Progetto: luke/subhub
func Connect(masterConfig *goredis.DialConfig, slaveConfig *goredis.DialConfig) (*Redis, error) {
	r := &Redis{}

	log.Println("server connect redis")

	redisMaster, err := goredis.Dial(masterConfig)
	if err != nil {
		log.Fatal("Unable to connect to redis master", err)
		return r, err
	}
	r.redisMaster = redisMaster

	redisSlave, err := goredis.Dial(slaveConfig)
	if err != nil {
		log.Fatal("Unable to connect to redis sub", err)
		return r, err
	}
	r.redisSlave = redisSlave

	return r, err
}
Esempio n. 11
0
func NewRedis(address string) (*Redis, error) {
	var (
		err error
	)

	r := new(Redis)
	r.Client, err = goredis.Dial(&goredis.DialConfig{
		Address: address,
	})

	return r, err
}
Esempio n. 12
0
func redisHeartBeatchecker(host string) (*goredis.Redis, error) {

	client, err := goredis.Dial(&goredis.DialConfig{Address: host})
	if err != nil {
		log.Printf("Error connection to database %s", host)
		log.Printf("Error connection to database->> %s", err.Error())
		return client, err
	}
	if err := client.Ping(); err != nil {
		log.Printf("FALSE Ping check to database")
		return client, err
	}
	client.ClosePool()
	return client, nil
}
Esempio n. 13
0
func storeinRedis(res Response) {
	client, _ := goredis.Dial(&goredis.DialConfig{Address: "127.0.0.1:6379"})

	res2B, _ := json.Marshal(res)
	fmt.Println("res2B", string(res2B))

	reply, _ := client.LPush("Rqueue", string(res2B))

	fmt.Println("Reply: ", reply)

	/*
	   fmt.Println("Stored to Redis Hash...")
	   fmt.Println(err)
	   fmt.Println(err2)
	   fmt.Println(reply) */
}
Esempio n. 14
0
func redisGet(w http.ResponseWriter, r *http.Request) {
	cluster := r.FormValue("cluster")
	key := r.FormValue("key")
	redis, err := goredis.Dial(&goredis.DialConfig{Address: fmt.Sprintf("raftis-%s:%d", cluster, 6379)})
	if err != nil {
		w.Write([]byte(err.Error()))
		return
	}
	val, err := redis.Get(key)
	if err != nil {
		w.Write([]byte(err.Error()))
		return
	}
	w.Write([]byte(val))
	return
}
Esempio n. 15
0
func setSlaveOf(host string) error {

	client, err := goredis.Dial(&goredis.DialConfig{Address: host})
	if err != nil {
		log.Printf("Error SlaveOf connection to database : %s", host)
		return err
	}

	redis_host := strings.Split(host, ":")

	if ret := client.SlaveOf(redis_host[0], redis_host[1]); ret != nil {
		log.Printf("SlaveOf Error %s", host)
		return ret
	}

	log.Printf("OK SlaveOf->> %s", host)
	client.ClosePool()
	return nil
}
Esempio n. 16
0
func main() {

	db, err := sql.Open("mysql", "root:@/go_db")
	client, err2 := goredis.Dial(&goredis.DialConfig{Address: "127.0.0.1:6379"})

	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("Database Connection established...")
	}

	if err2 != nil {
		fmt.Println(err2)
	} else {
		fmt.Println("Redis Connection established...")
	}

	fetchFromRedis(db, client)

	defer db.Close()
}
Esempio n. 17
0
File: cache.go Progetto: dej4vu/figo
func NewCache(addr, password, db string) (*Cache, error) {
	dbid, dbiderr := strconv.Atoi(db)
	if dbiderr != nil {
		return nil, dbiderr
	}

	config := &goredis.DialConfig{
		Network:  "tcp",
		Address:  addr,
		Database: dbid,
		Password: password,
		Timeout:  10 * time.Second,
		MaxIdle:  100,
	}
	redisClient, err := goredis.Dial(config)
	if err != nil {
		return nil, err
	}

	return &Cache{redisClient: redisClient}, nil
}
Esempio n. 18
0
func watchServer(out chan<- Event, quit <-chan bool, watch chan *etcd.Response) {

	for {
		select {
		case <-quit:
			log.Printf(" WatchServer Quit Message..........")
			//close(out)
		default:
			time.Sleep(1000 * time.Millisecond)
			resp, _ := etcd_GetMasterData()
			_host := strings.Split(resp.Node.Value, "\n")

			log.Printf(" >>> WatchServer start >>> %s\n", resp.Node.Value)

			client, err := goredis.Dial(&goredis.DialConfig{Address: _host[0]})
			if err != nil {
				info := config.GetServerInfo()
				key := fmt.Sprintf("%s/Dead", info.AppName)
				etcd_SetData(key, _host[0])

				e := Event("MasterConnectErr")
				out <- e
				log.Printf("Error connection to database %s", err.Error())
				continue
			}
			if err := client.Ping(); err != nil {

				info := config.GetServerInfo()
				key := fmt.Sprintf("%s/Dead", info.AppName)
				etcd_SetData(key, _host[0])

				e := Event("MasterConnectErr")
				out <- e
				log.Printf("FALSE Ping check to database")
				continue
			}
			client.ClosePool()
		}
	}
}
Esempio n. 19
0
func supercars_04_update(m *gogrinder.Meta, s gogrinder.Settings) {
	var mm *req.HttpMetric
	//var resp map[string]interface{}
	c := req.NewDefaultClient()
	base := s["supercars_url"].(string)
	change := map[string]interface{}{"cylinders": "12", "name": "Ferrari Enzo",
		"country": "Italy", "top_speed": "218", "0-60": "3.4", "power": "650",
		"engine": "5998", "weight": "1365", "description": "The Enzo Ferrari " +
			"is a 12 cylinder mid-engine berlinetta named after the company's " +
			"founder, Enzo Ferrari.", "image": "050.png"}
	b := gg.NewBracket("04_01_supercars_update")
	redis, err := goredis.Dial(&goredis.DialConfig{Address: s["redis_srv"].(string)})
	if err != nil {
		// is the redis server running? correct address?
		m.Error += err.Error()
		mm = &req.HttpMetric{*m, 0, 0, 400}
	} else {
		id, err := redis.SPop("supercars")
		if err != nil {
			// probably run out of data - so it does not make sense to continue
			m.Error += err.Error()
			mm = &req.HttpMetric{*m, 0, 0, 400}
		} else {
			r, err := req.NewPutJsonRequest(base+"/rest/supercars/"+string(id),
				change)
			if err != nil {
				m.Error += err.Error()
				mm = &req.HttpMetric{*m, 0, 0, 400}
			} else {
				_, _, mm = req.DoJson(c, r, m)
				//tsUpdate(m, c, base + "/rest/supercars/" + string(id), change)

				// add the record back!
				redis.SAdd("supercars", string(id)) // no way this can go wrong!
			}
		}
	}
	b.End(mm)
}
Esempio n. 20
0
func main() {
	client, err := goredis.Dial(&goredis.DialConfig{Address: "127.0.0.1:6379"})

	for {

		fmt.Println("\033[H\033[2J")
		fmt.Println("Data in Redis Key Value Pair\n============================================================================\n")

		keys, err2 := client.ExecuteCommand("KEYS", "*")

		length := len(keys.Multi)

		for i := 0; i < length; i++ {
			key := string(keys.Multi[i].Bulk)
			value, err3 := client.Get(key)
			fmt.Println("Key:\t", string(key), "Value:\t", string(value))
			Printerror(err)
			Printerror(err2)
			Printerror(err3)
		}
		time.Sleep(25 * time.Millisecond)
	}
}
Esempio n. 21
0
func storeinRadis(msg string) {
	client, _ := goredis.Dial(&goredis.DialConfig{Address: "127.0.0.1:6379"})
	reply, _ := client.ExecuteCommand("LPUSH", "myqueue1", msg)
	fmt.Println(reply)
}