本文整理汇总了Golang中github.com/garyburd/redigo/redis.PubSubConn.Receive方法的典型用法代码示例。如果您正苦于以下问题:Golang PubSubConn.Receive方法的具体用法?Golang PubSubConn.Receive怎么用?Golang PubSubConn.Receive使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类github.com/garyburd/redigo/redis.PubSubConn
的用法示例。
在下文中一共展示了PubSubConn.Receive方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: SubCommonMsg
func SubCommonMsg() error {
r := Redix[_SubCommonMsg]
RedixMu[_SubCommonMsg].Lock()
defer RedixMu[_SubCommonMsg].Unlock()
psc := redis.PubSubConn{Conn: r}
err := psc.PSubscribe(SubCommonMsgKey)
if err != nil {
return err
}
ch := make(chan redis.PMessage, 128)
go func() {
defer psc.Close()
for {
data := psc.Receive()
switch m := data.(type) {
case redis.PMessage:
ch <- m
case redis.Subscription:
if m.Count == 0 {
glog.Fatalf("Subscription: %s %s %d, %v\n", m.Kind, m.Channel, m.Count, m)
return
}
case error:
glog.Errorf("[modifypwd|redis] sub of error: %v\n", m)
return
}
}
}()
go HandleCommonMsg(ch)
return nil
}
示例2: SubModifiedPasswd
func SubModifiedPasswd() error {
r := Redix[_SubModifiedPasswd]
RedixMu[_SubModifiedPasswd].Lock()
defer RedixMu[_SubModifiedPasswd].Unlock()
psc := redis.PubSubConn{Conn: r}
err := psc.Subscribe(SubModifiedPasswdKey)
if err != nil {
return err
}
ch := make(chan []byte, 128)
go func() {
defer psc.Close()
for {
data := psc.Receive()
switch n := data.(type) {
case redis.Message:
ch <- n.Data
case redis.Subscription:
if n.Count == 0 {
glog.Fatalf("Subscription: %s %s %d, %v\n", n.Kind, n.Channel, n.Count, n)
return
}
case error:
glog.Errorf("[modifypwd|redis] sub of error: %v\n", n)
return
}
}
}()
go HandleModifiedPasswd(ch)
return nil
}
示例3: RedisSub
func RedisSub(key string) (chan interface{}, redis.PubSubConn, error) {
mq := make(chan interface{}, Conf.RedisMQSize)
c := redisPool.Get()
defer c.Close()
pc, err := redis.Dial(Conf.RedisNetwork, Conf.RedisAddr)
if err != nil {
Log.Printf("redis.Dial(\"%s\", \"%s\") failed (%s)", Conf.RedisNetwork, Conf.RedisAddr, err.Error())
return nil, redis.PubSubConn{}, err
}
psc := redis.PubSubConn{pc}
// check queue
err = redisQueue(c, key, mq)
if err != nil {
Log.Printf("redisQueue failed (%s)", err.Error())
return nil, redis.PubSubConn{}, err
}
// subscribe
psc.Subscribe(key)
if _, ok := psc.Receive().(redis.Subscription); !ok {
Log.Printf("init sub must redis.Subscription")
return nil, redis.PubSubConn{}, fmt.Errorf("first sub must init")
}
// double check
err = redisQueue(c, key, mq)
if err != nil {
Log.Printf("redisQueue failed (%s)", err.Error())
return nil, redis.PubSubConn{}, err
}
go func() {
// DEBUG
Log.Printf("redis routine start")
// DEBUG
defer Log.Printf("redis routine exit")
defer psc.Close()
for {
switch n := psc.Receive().(type) {
case redis.Message:
mq <- string(n.Data)
case redis.PMessage:
mq <- string(n.Data)
case redis.Subscription:
// DEBUG
Log.Printf("redis UnSubscrption")
return
case error:
Log.Printf("psc.Receive() failed (%s)", n.Error())
mq <- n
return
}
}
}()
return mq, psc, nil
}
示例4: pingAndPurgeIfNeeded
// pingAndPurgeIfNeeded pings other by publishing to others ping key. If it
// does not receive a pong reply within some amount of time, it will
// assume the pool is stale and purge it.
func (p *Pool) pingAndPurgeIfNeeded(other *Pool) error {
ping := redisPool.Get()
pong := redis.PubSubConn{redisPool.Get()}
// Listen for pongs by subscribing to the other pool's pong key
pong.Subscribe(other.pongKey())
// Ping the other pool by publishing to its ping key
ping.Do("PUBLISH", other.pingKey(), 1)
// Use a select statement to either receive the pong or timeout
pongChan := make(chan interface{})
errChan := make(chan error)
go func() {
defer func() {
pong.Close()
ping.Close()
}()
select {
case <-p.exit:
return
default:
}
for {
reply := pong.Receive()
switch reply.(type) {
case redis.Message:
// The pong was received
pongChan <- reply
return
case error:
// There was some unexpected error
err := reply.(error)
errChan <- err
return
}
}
}()
timeout := time.After(p.config.StaleTimeout)
select {
case <-pongChan:
// The other pool responded with a pong
return nil
case err := <-errChan:
// Received an error from the pubsub conn
return err
case <-timeout:
// The pool is considered stale and should be purged
t := newTransaction()
other.RLock()
otherId := other.id
other.RUnlock()
t.purgeStalePool(otherId)
if err := t.exec(); err != nil {
return err
}
}
return nil
}
示例5: subscribe
func subscribe(emitter *emission.Emitter) {
conn, _ := redis.Dial("tcp", ":6379")
channel := redis.PubSubConn{conn}
channel.Subscribe(CHANNEL_NAME)
for {
reply := channel.Receive()
switch parsed := reply.(type) {
case redis.Message:
message := string(parsed.Data)
emitter.Emit("message", message)
}
}
}
示例6: listen
func listen(connection redis.Conn) {
pubSubConnection := redis.PubSubConn{connection}
pubSubConnection.Subscribe(redisChannel)
log.Println("Listening to redis '" + redisChannel + "' channel...")
for {
reply, message := pubSubConnection.Receive().(redis.Message)
if message {
hit := parseMessage(reply)
hits <- hit
log.Print("[" + hit.Code + "] " + hit.Host + hit.Path)
}
}
}
示例7: ReadFrames
func (self *Server) ReadFrames() {
c, err := redis.Dial("tcp", ":6379")
if err != nil {
panic(err)
}
psc := redis.PubSubConn{c}
psc.Subscribe("pokemon.streams.frames")
for {
switch v := psc.Receive().(type) {
case redis.Message:
frame := &Frame{}
err := json.Unmarshal(v.Data, &frame)
if err != nil {
continue
}
self.sendAll <- frame.Delta
self.frame = "0\t" + frame.Dithered
case redis.Subscription:
fmt.Printf("%s: %s %d\n", v.Channel, v.Kind, v.Count)
case error:
panic(v)
}
}
}
示例8: ProcessNewBlock
func ProcessNewBlock(conf *Config, rpool *redis.Pool, spool *redis.Pool) {
log.Println("ProcessNewBlock startup")
conn := rpool.Get()
defer conn.Close()
psc := redis.PubSubConn{Conn: conn}
psc.Subscribe("btcplex:blocknotify")
for {
switch v := psc.Receive().(type) {
case redis.Message:
hash := string(v.Data)
log.Printf("Processing new block: %v\n", hash)
c := rpool.Get()
newblock, err := SaveBlockFromRPC(conf, spool, hash)
if err != nil {
log.Printf("Error processing new block: %v\n", err)
} else {
// Once the block is processed, we can publish it as btcplex own blocknotify
c.Do("PUBLISH", "btcplex:blocknotify2", hash)
newblockjson, _ := json.Marshal(newblock)
c.Do("PUBLISH", "btcplex:newblock", string(newblockjson))
}
c.Close()
}
}
}
示例9: main
func main() {
addr := flag.String("addr", ":6379", "redis address")
format := flag.String("fmt", `{"%s":"%s"}`, "data format")
flag.Parse()
args := flag.Args()
conn, err := redis.Dial("tcp", *addr)
if err != nil {
log.Fatal(err)
return
}
psc := redis.PubSubConn{conn}
for _, channel := range args {
psc.Subscribe(channel)
}
for {
switch v := psc.Receive().(type) {
case redis.Message:
fmt.Println(fmt.Sprintf(*format, v.Channel, v.Data))
case redis.Subscription:
fmt.Printf("%s: %s %d\n", v.Channel, v.Kind, v.Count)
case error:
log.Println(v)
}
}
}
示例10: main
func main() {
c, err := redis.Dial("tcp", ":6379")
if err != nil {
panic(err)
}
defer c.Close()
psc := redis.PubSubConn{Conn: c}
psc.Subscribe("example")
psc.PSubscribe("p*")
for {
switch n := psc.Receive().(type) {
case redis.Message:
fmt.Printf("Message: %s %s\n", n.Channel, n.Data)
case redis.PMessage:
fmt.Printf("PMessage: %s %s %s\n", n.Pattern, n.Channel, n.Data)
case redis.Subscription:
fmt.Printf("Subscription: %s %s %d\n", n.Kind, n.Channel, n.Count)
if n.Count == 0 {
return
}
case error:
fmt.Printf("error: %v\n", n)
return
}
}
}
示例11: ListenToChannel
func (c *Cache) ListenToChannel(channel string, callback func(line string)) error {
// Listening on the "dead" channel to get dead notifications by Hipache
// Format received on the channel is:
// -> frontend_key;backend_url;backend_id;number_of_backends
// Example: "localhost;http://localhost:4242;0;1"
conn := c.pool.Get()
psc := redis.PubSubConn{conn}
psc.Subscribe(channel)
go func() {
defer conn.Close()
for {
switch v := psc.Receive().(type) {
case redis.Message:
callback(string(v.Data[:]))
case error:
conn.Close()
conn := c.pool.Get()
time.Sleep(10 * time.Second)
psc = redis.PubSubConn{conn}
psc.Subscribe(channel)
}
}
}()
return nil
}
示例12: StartPubSubHandler
// StartPubSubHandler will listen for a signal and run the callback with the message
func (r *RedisClusterStorageManager) StartPubSubHandler(channel string, callback func(redis.Message)) error {
if r.db == nil {
return errors.New("Redis connection failed")
}
handle := r.db.RandomRedisHandle()
if handle == nil {
return errors.New("Redis connection failed")
}
psc := redis.PubSubConn{r.db.RandomRedisHandle().Pool.Get()}
psc.Subscribe(channel)
for {
switch v := psc.Receive().(type) {
case redis.Message:
callback(v)
case redis.Subscription:
log.Debug("Subscription started: ", v.Channel)
case error:
log.Error("Redis disconnected or error received, attempting to reconnect: ", v)
return v
}
}
return errors.New("Connection closed.")
return nil
}
示例13: RunOnce
func (cs *CustomerService) RunOnce() bool {
c, err := redis.Dial("tcp", config.redis_address)
if err != nil {
log.Info("dial redis error:", err)
return false
}
psc := redis.PubSubConn{c}
psc.Subscribe("application_update")
cs.Clear()
for {
switch v := psc.Receive().(type) {
case redis.Message:
if v.Channel == "application_update" {
cs.HandleUpdate(string(v.Data))
} else {
log.Infof("%s: message: %s\n", v.Channel, v.Data)
}
case redis.Subscription:
log.Infof("%s: %s %d\n", v.Channel, v.Kind, v.Count)
case error:
log.Info("error:", v)
return true
}
}
}
示例14: RunOnce
func (group_manager *GroupManager) RunOnce() bool {
c, err := redis.Dial("tcp", config.redis_address)
if err != nil {
log.Info("dial redis error:", err)
return false
}
psc := redis.PubSubConn{c}
psc.Subscribe("group_create", "group_disband", "group_member_add", "group_member_remove")
group_manager.Reload()
for {
switch v := psc.Receive().(type) {
case redis.Message:
if v.Channel == "group_create" {
group_manager.HandleCreate(string(v.Data))
} else if v.Channel == "group_disband" {
group_manager.HandleDisband(string(v.Data))
} else if v.Channel == "group_member_add" {
group_manager.HandleMemberAdd(string(v.Data))
} else if v.Channel == "group_member_remove" {
group_manager.HandleMemberRemove(string(v.Data))
} else {
log.Infof("%s: message: %s\n", v.Channel, v.Data)
}
case redis.Subscription:
log.Infof("%s: %s %d\n", v.Channel, v.Kind, v.Count)
case error:
log.Info("error:", v)
return true
}
}
}
示例15: TestPublish
func TestPublish(t *testing.T) {
emitter, _ := NewEmitter(&EmitterOpts{
Host: "localhost",
Port: 6379,
})
if emitter == nil {
t.Error("emitter is nil")
}
c, _ := redis.Dial("tcp", "localhost:6379")
defer c.Close()
psc := redis.PubSubConn{Conn: c}
psc.Subscribe("socket.io#emitter")
emitter.Emit("text", "hogefuga")
for {
switch v := psc.Receive().(type) {
case redis.Message:
isContain := strings.Contains(string(v.Data), "hogefuga")
if !isContain {
t.Errorf("%s not contains hogefuga", v.Data)
return
} else {
return
}
}
}
}