示例#1
0
func TestPushed(t *testing.T) {
	pc := dialt(t)
	defer pc.Close()

	nc, err := net.Dial("tcp", ":6379")
	if err != nil {
		t.Fatal(err)
	}
	defer nc.Close()
	nc.SetReadDeadline(time.Now().Add(4 * time.Second))

	c := redis.PubSubConn{Conn: redis.NewConn(nc, 0, 0)}

	c.Subscribe("c1")
	expectPushed(t, c, "Subscribe(c1)", redis.Subscription{Kind: "subscribe", Channel: "c1", Count: 1})
	c.Subscribe("c2")
	expectPushed(t, c, "Subscribe(c2)", redis.Subscription{Kind: "subscribe", Channel: "c2", Count: 2})
	c.PSubscribe("p1")
	expectPushed(t, c, "PSubscribe(p1)", redis.Subscription{Kind: "psubscribe", Channel: "p1", Count: 3})
	c.PSubscribe("p2")
	expectPushed(t, c, "PSubscribe(p2)", redis.Subscription{Kind: "psubscribe", Channel: "p2", Count: 4})
	c.PUnsubscribe()
	expectPushed(t, c, "Punsubscribe(p1)", redis.Subscription{Kind: "punsubscribe", Channel: "p1", Count: 3})
	expectPushed(t, c, "Punsubscribe()", redis.Subscription{Kind: "punsubscribe", Channel: "p2", Count: 2})

	pc.Do("PUBLISH", "c1", "hello")
	expectPushed(t, c, "PUBLISH c1 hello", redis.Message{Channel: "c1", Data: []byte("hello")})
}
示例#2
0
文件: utils.go 项目: philips/beam
func newConnectionPool(connector Connector, size int) *redis.Pool {
	return redis.NewPool(func() (redis.Conn, error) {
		conn, err := connector.Connect()
		if err != nil {
			return nil, err
		}
		return redis.NewConn(conn, 0, 0), nil
	}, size)
}
示例#3
0
文件: broker.go 项目: KevBurnsJr/goku
// NewBroker returns a new *Broker.
func NewBroker(cfg BrokerConfig) (*Broker, error) {
	conn, err := net.Dial("tcp", cfg.Hostport)
	if err != nil {
		return nil, err
	}

	return &Broker{
		rc:       redis.NewConn(conn, cfg.Timeout, cfg.Timeout),
		registry: make(map[string]Job),
		dq:       cfg.DefaultQueue,
	}, nil
}
示例#4
0
文件: test.go 项目: dogeerf/tool
func GetKeyByCache(key string) (value string, err error) {
	netConn, err := net.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		return
	}
	redisConn := redis.NewConn(netConn, 200*time.Millisecond, 200*time.Millisecond)
	value, err = redis.String(redisConn.Do("GET", key))
	if err != nil {
		return
	}
	return
}
示例#5
0
文件: redis.go 项目: dogeerf/tool
func main() {
	fmt.Printf("==============================================================\n")
	redisAddr := "localost:7003"
	conn, err := net.Dial("tcp", redisAddr)
	if err != nil {
		fmt.Printf("%s: conn redis :%s\n", setColour("WARNING", "red"), redisAddr)
	}
	c := redis.NewConn(conn, 2e7, 2e7)
	// get all keys *
	// dump value save to hd
	c.Do()
	_ = c
	fmt.Printf("==============================================================\n")
}
示例#6
0
文件: test.go 项目: dogeerf/tool
func SetCacheByKey(key string, value string) (err error) {
	netConn, err := net.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		return err
	}
	redisConn := redis.NewConn(netConn, 200*time.Millisecond, 200*time.Millisecond)
	ok, err := redis.Bool(redisConn.Do("SET", key, value))
	if err != nil {
		return err
	}
	if !ok {
		return fmt.Errorf("set not ok")
	}
	return err
}
示例#7
0
文件: rep.go 项目: RaymondChou/PE-Go
func main() {

	const (
		HeartBeatTime = 30
	)

	nc, err := net.Dial("tcp", ":6969")
	if err != nil {
		fmt.Println(err)
	}
	defer nc.Close()
	// nc.SetReadDeadline(time.Now().Add(4 * time.Second))

	c := redis.NewConn(nc, 0, 0)

	//订阅频道
	c.Send("sub", "Channel", HeartBeatTime)
	c.Flush()

	// 定时请求心跳
	ticker := time.NewTicker(time.Second * HeartBeatTime)
	go func() {
		for t := range ticker.C {
			nc.Write([]byte("h"))
			fmt.Println("Heartbeat send", t)
		}
	}()

	for {

		reply, err := c.Receive()
		if err != nil {
			fmt.Println(err)
		}

		if reply == "h" {
			fmt.Println("Heartbeat received")
		} else if reply != nil {
			reply_str, err := redis.String(reply, err)
			fmt.Printf("%#v\n", reply_str)
			if err != nil {
				fmt.Println(err)
			}
		}

	}

}
示例#8
0
文件: client.go 项目: YaSuenag/hsbeat
func (c *client) Connect(to time.Duration) error {
	debugf("connect")
	err := c.Client.Connect()
	if err != nil {
		return err
	}

	conn := redis.NewConn(c.Client, to, to)
	defer func() {
		if err != nil {
			conn.Close()
		}
	}()

	if err = initRedisConn(conn, c.password, c.db); err == nil {
		c.publish, err = makePublish(conn, c.key, c.dataType)
	}
	return err
}
示例#9
0
func openRedisConn(target string) redigo.Conn {
	return redigo.NewConn(openNetConn(target), 0, 0)
}
示例#10
0
文件: keys.go 项目: dogeerf/tool
func GetRedisConn(redisAddr string) (redisConn redis.Conn) {
	conn, err := net.Dial("tcp", redisAddr)
	CheckErr(err, "conn redis error")
	redisConn = redis.NewConn(conn, 200*time.Millisecond, 200*time.Millisecond)
	return redisConn
}
示例#11
0
文件: out_test.go 项目: htee/htee
func redisPipeConn() (redis.Conn, net.Conn) {
	nConn, c := net.Pipe()
	rConn := redis.NewConn(c, 0, 0)

	return rConn, nConn
}