func TestPublishEvent(t *testing.T) {
db := redisdb.New(dburl)
if err := db.Connect(); err != nil {
t.Fatalf("Failed to connect to redis: %s", err.Error())
}
c, err := redis.Dial("tcp", dburl)
if err != nil {
t.Fatalf("Failed to connect to redis2: %s", err.Error())
}
ps := pubsub.NewSubClient(c)
ps.Subscribe("thechan")
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
resp := ps.Receive()
if resp.Message != "moar" {
t.Errorf("Expected moar but got %s", resp.Message)
}
wg.Done()
}()
go func() {
buf := bytes.NewBufferString("moar")
if err := db.PublishEvent("thechan", buf); err != nil {
t.Fatalf("Should have have errored publishing: %s", err.Error())
}
}()
wg.Wait()
}
// NewClientCustom is the same as NewClient, except it takes in a DialFunc which
// will be used to create all new connections to the master instances. This can
// be used to implement authentication, custom timeouts, etc...
func NewClientCustom(
network, address string, poolSize int, df DialFunc, 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.NewCustom("tcp", addr, poolSize, (pool.DialFunc)(df))
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,
dialFunc: (pool.DialFunc)(df),
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 (t *Transport) subscribe(channel chan *api.Message) {
conn, _ := t.getConnection() // todo handle messages better
defer conn.Close()
psc := pubsub.NewSubClient(conn)
subClient := psc.Subscribe(t.InputBinding)
log.Debugf("Processor subscribing to: %s", subClient)
defer psc.Unsubscribe(t.InputBinding)
for {
resp := psc.Receive()
//log.Debugln("after: ", resp)
if resp.Err != nil {
channel <- api.NewMessageFromRawBytes([]byte(resp.Err.Error()))
} else {
channel <- api.NewMessageFromRawBytes([]byte(resp.Message))
}
}
}