Esempio n. 1
0
func PubSub() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Recovered in PubSub", r)
		}
	}()
	c2, err := redis.Dial("tcp", redisIp)
	errHndlr(err)
	defer c2.Close()
	//authServer
	authE := c2.Cmd("auth", redisPassword)
	errHndlr(authE.Err)

	psc := pubsub.NewSubClient(c2)
	psr := psc.Subscribe("events")
	ppsr := psc.PSubscribe("EVENT:*")

	if ppsr.Err == nil {

		for {
			psr = psc.Receive()
			if psr.Err != nil {

				fmt.Println(psr.Err.Error())

				break
			}
			list := strings.Split(psr.Message, ":")
			fmt.Println(list)
			if len(list) >= 8 {
				stenent := list[1]
				scompany := list[2]
				sclass := list[3]
				stype := list[4]
				scategory := list[5]
				sparam1 := list[6]
				sparam2 := list[7]
				ssession := list[8]

				itenet, _ := strconv.Atoi(stenent)
				icompany, _ := strconv.Atoi(scompany)

				go OnEvent(itenet, icompany, sclass, stype, scategory, ssession, sparam1, sparam2)
			}

		}
		//s := strings.Split("127.0.0.1:5432", ":")
	}

	psc.Unsubscribe("events")

}
Esempio n. 2
0
// Creates a sentinel client. Connects to the given sentinel instance, pulls the
// information for the masters of the given names, and creates an intial pool of
// connections for each master. The client will automatically replace the pool
// for any master should sentinel decide to fail the master over. The returned
// error is a *ClientError.
func NewClient(
	network, address string, poolSize int, names ...string,
) (
	*Client, error,
) {

	// We use this to fetch initial details about masters before we upgrade it
	// to a pubsub client
	client, err := redis.Dial(network, address)
	if err != nil {
		return nil, &ClientError{err: err}
	}

	masterPools := map[string]*pool.Pool{}
	for _, name := range names {
		r := client.Cmd("SENTINEL", "MASTER", name)
		l, err := r.List()
		if err != nil {
			return nil, &ClientError{err: err, SentinelErr: true}
		}
		addr := l[3] + ":" + l[5]
		pool, err := pool.NewPool("tcp", addr, poolSize)
		if err != nil {
			return nil, &ClientError{err: err}
		}
		masterPools[name] = pool
	}

	subClient := pubsub.NewSubClient(client)
	r := subClient.Subscribe("+switch-master")
	if r.Err != nil {
		return nil, &ClientError{err: r.Err, SentinelErr: true}
	}

	c := &Client{
		poolSize:       poolSize,
		masterPools:    masterPools,
		subClient:      subClient,
		getCh:          make(chan *getReq),
		putCh:          make(chan *putReq),
		closeCh:        make(chan struct{}),
		alwaysErrCh:    make(chan *ClientError),
		switchMasterCh: make(chan *switchMaster),
	}

	go c.subSpin()
	go c.spin()
	return c, nil
}
func main() {

	client, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		log.Fatal(err)
	}

	r := client.Cmd("PING")
	if r.Err != nil {
		log.Fatal(err)
	}
	log.Printf("Results from PING: %s\n", r.String())

	r = client.Cmd("SET", "foo", "bar")
	if r.Err != nil {
		log.Fatal(err)
	}

	log.Printf("r.String(): %s\n", r.String())

	r = client.Cmd("GET", "foo")
	log.Printf("r.String(): %s\n", r.String())

	r = client.Cmd("SET", "foo_int", 123)

	r = client.Cmd("GET", "foo_int")
	i, _ := r.Int()
	log.Printf("i: %d\n", i)

	// Batching Commands
	client.Append("SET", "name", "Roberto")
	client.Append("GET", "name")

	r = client.GetReply() // Response from the SET
	log.Printf("Response from the SET: r.String(): %s\n", r.String())

	r = client.GetReply() // Response from the GET
	log.Printf("Response from the GET: r.String(): %s\n", r.String())

	// Use MGET
	client.Cmd("SET", "first_name", "Roberto")
	client.Cmd("SET", "last_name", "Rojas")

	r = client.Cmd("MGET", "first_name", "last_name")
	list, _ := r.List()
	for idx, value := range list {
		log.Printf("MGET - value(%d): %s\n", idx, value)
	}

	client.Close()

	// Pub-Sub Sample

	go func() {
		cli, _ := redis.Dial("tcp", "localhost:6379")
		i := 0
		for {
			i++
			cli.Cmd("PUBLISH", "news.tech", fmt.Sprintf("This is tech story #%d", i))
			cli.Cmd("PUBLISH", "news.sports", fmt.Sprintf("This is sports story #%d", i))
			if i > 10 {
				break
			}
		}
	}()

	go func() {
		cli, _ := redis.Dial("tcp", "localhost:6379")
		sub := pubsub.NewSubClient(cli)
		sr := sub.PSubscribe("news.*")
		if sr.Err != nil {
			log.Fatal(sr.Err)
		}

		for {
			r := sub.Receive()
			if r.Err != nil {
				log.Fatal(r.Err)
			}
			log.Printf("Pubsub Message: %s\n", r.Message)
		}

	}()

	fmt.Println("Press any key to stop program...")
	fmt.Scanln() // Keep the program running until any key is pressed...

}
Esempio n. 4
0
func main() {
	c, err := redis.DialTimeout("tcp", "127.0.0.1:6379", time.Duration(10)*time.Second)
	errHndlr(err)
	defer c.Close()

	// select database
	r := c.Cmd("select", 8)
	errHndlr(r.Err)

	r = c.Cmd("flushdb")
	errHndlr(r.Err)

	r = c.Cmd("echo", "Hello world!")
	errHndlr(r.Err)

	s, err := r.Str()
	errHndlr(err)
	fmt.Println("echo:", s)

	//* Strings
	r = c.Cmd("set", "mykey0", "myval0")
	errHndlr(r.Err)

	s, err = c.Cmd("get", "mykey0").Str()
	errHndlr(err)
	fmt.Println("mykey0:", s)

	myhash := map[string]string{
		"mykey1": "myval1",
		"mykey2": "myval2",
		"mykey3": "myval3",
	}

	// Alternatively:
	// c.Cmd("mset", "mykey1", "myval1", "mykey2", "myval2", "mykey3", "myval3")
	r = c.Cmd("mset", myhash)
	errHndlr(r.Err)

	ls, err := c.Cmd("mget", "mykey1", "mykey2", "mykey3").List()
	errHndlr(err)
	fmt.Println("mykeys values:", ls)

	//* List handling
	mylist := []string{"foo", "bar", "qux"}

	// Alternativaly:
	// c.Cmd("rpush", "mylist", "foo", "bar", "qux")
	r = c.Cmd("rpush", "mylist", mylist)
	errHndlr(r.Err)

	mylist, err = c.Cmd("lrange", "mylist", 0, -1).List()
	errHndlr(err)

	fmt.Println("mylist:", mylist)

	//* Hash handling

	// Alternatively:
	// c.Cmd("hmset", "myhash", ""mykey1", "myval1", "mykey2", "myval2", "mykey3", "myval3")
	r = c.Cmd("hmset", "myhash", myhash)
	errHndlr(r.Err)

	myhash, err = c.Cmd("hgetall", "myhash").Hash()
	errHndlr(err)

	fmt.Println("myhash:", myhash)

	//* Pipelining
	c.Append("set", "multikey", "multival")
	c.Append("get", "multikey")

	c.GetReply()     // set
	r = c.GetReply() // get
	errHndlr(r.Err)

	s, err = r.Str()
	errHndlr(err)
	fmt.Println("multikey:", s)

	//* Publish/Subscribe

	// Subscribe
	c2, err := redis.Dial("tcp", "localhost:6379")
	errHndlr(err)
	defer c2.Close()
	psc := pubsub.NewSubClient(c2)
	psr := psc.Subscribe("queue1", "queue2")

	// Publish
	c.Cmd("publish", "queue1", "ohai")

	// Receive publish
	psr = psc.Receive() //Blocks until reply is received or timeout is tripped
	if !psr.Timeout() {
		fmt.Println("publish:", psr.Message)
	} else {
		fmt.Println("error: sub timedout")
		return
	}

	// Unsubscribe
	psc.Unsubscribe("queue1", "queue2") //Unsubscribe before issuing any other commands with c
}