func TestReadTimeout(t *testing.T) {
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatalf("net.Listen returned %v", err)
}
defer l.Close()
go func() {
for {
c, err := l.Accept()
if err != nil {
return
}
go func() {
time.Sleep(time.Second)
c.Write([]byte("+OK\r\n"))
c.Close()
}()
}
}()
// Do
c1, err := redis.Dial(l.Addr().Network(), l.Addr().String(), redis.DialReadTimeout(time.Millisecond))
if err != nil {
t.Fatalf("redis.Dial returned %v", err)
}
defer c1.Close()
_, err = c1.Do("PING")
if err == nil {
t.Fatalf("c1.Do() returned nil, expect error")
}
if c1.Err() == nil {
t.Fatalf("c1.Err() = nil, expect error")
}
// Send/Flush/Receive
c2, err := redis.Dial(l.Addr().Network(), l.Addr().String(), redis.DialReadTimeout(time.Millisecond))
if err != nil {
t.Fatalf("redis.Dial returned %v", err)
}
defer c2.Close()
c2.Send("PING")
c2.Flush()
_, err = c2.Receive()
if err == nil {
t.Fatalf("c2.Receive() returned nil, expect error")
}
if c2.Err() == nil {
t.Fatalf("c2.Err() = nil, expect error")
}
}
// CreatePool creates a redis connection pool
func CreatePool(
host, password, network string,
maxConn int,
idleTimeout, connTimeout time.Duration,
) *rd.Pool {
return &rd.Pool{
MaxIdle: maxConn,
IdleTimeout: idleTimeout,
Dial: func() (rd.Conn, error) {
c, err := rd.Dial(network, host,
rd.DialConnectTimeout(connTimeout),
rd.DialReadTimeout(connTimeout),
rd.DialWriteTimeout(connTimeout))
if err != nil {
return nil, err
}
if password != "" {
if _, err := c.Do("AUTH", password); err != nil {
c.Close()
return nil, err
}
}
return c, err
},
}
}
// Iterate through `machines`, trying to connect to each in turn.
// Returns the first successful connection or the last error encountered.
// Assumes that `machines` is non-empty.
func tryConnect(machines []string, password string) (redis.Conn, error) {
var err error
for _, address := range machines {
var conn redis.Conn
network := "tcp"
if _, err = os.Stat(address); err == nil {
network = "unix"
}
log.Debug(fmt.Sprintf("Trying to connect to redis node %s", address))
dialops := []redis.DialOption{
redis.DialConnectTimeout(time.Second),
redis.DialReadTimeout(time.Second),
redis.DialWriteTimeout(time.Second),
}
if password != "" {
dialops = append(dialops, redis.DialPassword(password))
}
conn, err = redis.Dial(network, address, dialops...)
if err != nil {
continue
}
return conn, nil
}
return nil, err
}
func (m MRedis) pub(ch string, msg string) {
c, err := redis.Dial("tcp", "192.168.176.3:6379", redis.DialReadTimeout(100*time.Second),
redis.DialWriteTimeout(100*time.Second))
if err != nil {
log.Fatal(err)
}
defer c.Close()
log.Printf("ch:%s msg:%s\n", ch, msg)
ok, err := redis.Int64(c.Do("PUBLISH", ch, msg))
if err != nil {
log.Fatal(err)
}
fmt.Print(ok)
/*
var wg sync.WaitGroup
wg.Add(2)
go func()
{
defer wg.Done()
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
}
}
}()
go func() {
defer wg.Done()
psc.Subscribe("example")
psc.PSubscribe("p*")
// The following function calls publish a message using another
// connection to the Redis server.
publish("example", "hello")
publish("example", "world")
publish("pexample", "foo")
publish("pexample", "bar")
// Unsubscribe from all connections. This will cause the receiving
// goroutine to exit.
psc.Unsubscribe()
psc.PUnsubscribe()
}()
wg.Wait()
return
*/
}
// ping executes a PING command against addr until timeout occurs.
func (p *Process) ping(addr string, timeout time.Duration) error {
// Default to local process if addr not specified.
if addr == "" {
addr = fmt.Sprintf("localhost:%s", p.Port)
}
logger := p.Logger.New("fn", "ping", "addr", addr, "timeout", timeout)
logger.Info("sending")
timer := time.NewTimer(timeout)
defer timer.Stop()
ticker := time.NewTicker(checkInterval)
defer ticker.Stop()
for {
// Attempt to ping the server.
if ok := func() bool {
logger.Info("sending PING")
conn, err := redis.Dial("tcp", addr,
redis.DialPassword(p.Password),
redis.DialConnectTimeout(timeout),
redis.DialReadTimeout(timeout),
redis.DialWriteTimeout(timeout),
)
if err != nil {
logger.Error("conn error", "err", err)
return false
}
defer conn.Close()
if _, err := conn.Do("PING"); err != nil {
logger.Error("error getting upstream status", "err", err)
return false
}
logger.Info("PONG received")
return true
}(); ok {
return nil
}
select {
case <-timer.C:
logger.Info("timeout")
return ErrTimeout
case <-ticker.C:
}
}
}
func (l *RedisInput) Run(output chan common.MapStr) error {
logp.Debug("redisinput", "Running Redis Input")
var keysScript = redis.NewScript(1, `return redis.call('KEYS', KEYS[1])`)
go func() {
redisURL := fmt.Sprintf("redis://%s:%d/%d", l.Host, l.Port, l.DB)
dialConnectTimeout := redis.DialConnectTimeout(3 * time.Second)
dialReadTimeout := redis.DialReadTimeout(10 * time.Second)
var backOffCount = 0
var backOffDuration time.Duration = 5 * time.Second
for {
logp.Debug("redisinput", "Connecting to: %s", redisURL)
server, err := redis.DialURL(redisURL, dialConnectTimeout, dialReadTimeout)
if err != nil {
logp.Err("couldn't start listening: " + err.Error())
return
}
logp.Debug("redisinput", "Connected to Redis Server")
reply, err := keysScript.Do(server, "*")
if err != nil {
logp.Err("An error occured while executing KEYS command: %s\n", err)
return
}
keys, err := redis.Strings(reply, err)
if err != nil {
logp.Err("An error occured while converting reply to String: %s\n", err)
return
}
for _, key := range keys {
logp.Debug("redisinput", "key is %s", key)
lineCount, err := l.handleConn(server, output, key)
if err == nil {
logp.Debug("redisinput", "Read %v events", lineCount)
backOffCount = 0
backOffDuration = time.Duration(backOffCount) * time.Second
time.Sleep(backOffDuration)
} else {
backOffCount++
backOffDuration = time.Duration(backOffCount) * time.Second
time.Sleep(backOffDuration)
}
}
defer server.Close()
}
}()
return nil
}
func init() {
// c, err := redis.Dial("tcp", cfg.RedisAddr(),
// redis.DialReadTimeout(1 * time.Second), redis.DialWriteTimeout(1 * time.Second))
c, err := redis.Dial("tcp", fmt.Sprintf(":%d", 6379),
redis.DialReadTimeout(1*time.Second), redis.DialWriteTimeout(1*time.Second))
redisConn = c
if err != nil {
fmt.Print(err)
}
s, _ := redisConn.Do("SELECT", 11)
fmt.Println("select 11, s=", s)
}
func updateCache() {
c, err := redis.Dial("tcp", "172.16.25.133:6379", redis.DialReadTimeout(time.Second*time.Duration(1)))
if err != nil {
log.Error(err)
return
}
defer c.Close()
values, err := redis.StringMap(c.Do("HGETALL", "se:adspaceMap"))
if err != nil {
log.Error(err)
return
}
for k, v := range values {
log.Info(k, v)
var adspaceEntity AdspaceEntity
json.Unmarshal([]byte(v), &adspaceEntity)
if adspaceEntity.DemandAdspaces != nil && len(adspaceEntity.DemandAdspaces) >= 1 {
for _, adspace := range adspaceEntity.DemandAdspaces {
if adspace == nil || adspace.Timeout <= 0 || adspace.Weight <= 0 || adspace.DemandAdspaceKey == "" {
log.Warn(k, v)
continue
}
if adspace.OsType != "" {
as := adspaceCache[k+"_"+adspace.OsType]
as = append(as, *adspace)
adspaceCache[k+"_"+adspace.OsType] = as
} else {
as_android := adspaceCache[k+"_"+system.OS_ANDROID]
as_android = append(as_android, *adspace)
as_ios := adspaceCache[k+"_"+system.OS_IOS]
as_ios = append(as_ios, *adspace)
adspaceCache[k+"_"+system.OS_ANDROID] = as_android
adspaceCache[k+"_"+system.OS_IOS] = as_ios
}
}
}
}
}
func FlushCfgToDB() {
c, err := redis.Dial("tcp", RedisAddr(), redis.DialReadTimeout(1*time.Second), redis.DialWriteTimeout(1*time.Second))
if err != nil {
fmt.Println(err)
return
}
defer c.Close()
c.Do("SELECT", RedisDBs[Cfg])
c.Do("FLUSHALL")
c.Do("SET", "srv:port:agent", AgentPort)
c.Do("SET", "srv:port:lobby", LobbyPort)
c.Do("SET", "srv:port:game", GamePort)
c.Do("SET", "srv:port:data", DaoPort)
fmt.Println("FlushCfgToDB")
}
// RedisInfo executes an INFO command against a Redis server and returns the results.
func (p *Process) RedisInfo(addr string, timeout time.Duration) (*RedisInfo, error) {
// Default to local process if addr not specified.
if addr == "" {
addr = fmt.Sprintf("localhost:%s", p.Port)
}
logger := p.Logger.New("fn", "replInfo", "addr", addr)
logger.Info("sending INFO")
// Connect to the redis server.
conn, err := redis.Dial("tcp", addr,
redis.DialPassword(p.Password),
redis.DialConnectTimeout(timeout),
redis.DialReadTimeout(timeout),
redis.DialWriteTimeout(timeout),
)
if err != nil {
logger.Info("dial error", "err", err)
return nil, err
}
defer conn.Close()
// Execute INFO command.
reply, err := conn.Do("INFO")
if err != nil {
logger.Error("info error", "err", err)
return nil, err
}
buf, ok := reply.([]byte)
if !ok {
logger.Error("info reply type error", "type", fmt.Sprintf("%T", buf))
return nil, fmt.Errorf("unexpected INFO reply format: %T", buf)
}
// Parse the bulk string reply info a typed object.
info, err := ParseRedisInfo(string(buf))
if err != nil {
logger.Error("parse info error", "err", err)
return nil, fmt.Errorf("parse info: %s", err)
}
logger.Info("INFO received")
return info, nil
}
// Callback function factory to vitess pool
func redisFactory(key string, config map[string]string) (redis.Conn, error) {
host := config["host"]
port := config["port"]
redisString := fmt.Sprintf("%s:%s", host, port)
cli, err := redis.Dial("tcp", redisString, redis.DialReadTimeout(time.Second), redis.DialWriteTimeout(time.Second))
// select default db if not specified
db, ok := config["db"]
if ok {
cli.Do("SELECT", db)
} else {
cli.Do("SELECT", 0)
}
if err != nil {
// Write exit
fmt.Println("Error in Redis Dial")
}
return cli, nil
}
func NewUser(p *Models) *User {
u := new(User)
c, err := redis.Dial("tcp", cfg.RedisAddr(),
redis.DialReadTimeout(1*time.Second), redis.DialWriteTimeout(1*time.Second))
if err != nil {
log.Error(err.Error())
return nil
}
u.c = c
//select db
s, err := c.Do("SELECT", cfg.RedisDBs[cfg.Pf])
if err != nil {
log.Error(err.Error())
return nil
}
//temp
fw.PrintType(s, "s")
//fill keys
b, _ := redis.Bool(c.Do("EXISTS", k_account_count))
// switch b.(type) {
// case interface{}:
// log..Debug("interface")
// case []byte:
// log..Debug("byte")
// case string:
// log..Debug("string")
// case *int:
// log..Debug("int")
// default:
// log..Debug("other")
// }
if b == false {
c.Do("SET", k_account_count, 0)
log.Info("fill key:", k_account_count)
}
//register model
u.parent = p
return u
}
// Connect establishes a connection to Redis which provides the
// pub/sub implementation.
func (b *redisBroker) Connect() error {
if b.pool != nil {
return nil
}
var addr string
if len(b.opts.Addrs) == 0 || b.opts.Addrs[0] == "" {
addr = "redis://127.0.0.1:6379"
} else {
addr = b.opts.Addrs[0]
if !strings.HasPrefix("redis://", addr) {
addr = "redis://" + addr
}
}
b.addr = addr
b.pool = &redis.Pool{
MaxIdle: b.bopts.maxIdle,
MaxActive: b.bopts.maxActive,
IdleTimeout: b.bopts.idleTimeout,
Dial: func() (redis.Conn, error) {
return redis.DialURL(
b.addr,
redis.DialConnectTimeout(b.bopts.connectTimeout),
redis.DialReadTimeout(b.bopts.readTimeout),
redis.DialWriteTimeout(b.bopts.writeTimeout),
)
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err := c.Do("PING")
return err
},
}
return nil
}
func main() {
redisConn, _ = redis.Dial("tcp", cfg.RedisAddr(),
redis.DialReadTimeout(1*time.Second), redis.DialWriteTimeout(1*time.Second))
s, _ := redisConn.Do("SELECT", 11)
fmt.Println("select 11, s=", s)
defer redisConn.Close()
N := 10000
// acc := make(chan int, 0)
// do := 0
// mu := sync.Mutex{}
//
t1 := time.Now()
for i := 0; i < N; i++ {
// go func() {
// mu.Lock()
// do = do + 1
//// _, e := redisConn.Do("SET", do, "jjj")
_, e := redisConn.Do("PING")
if e != nil {
fmt.Print(e, "\n")
}
// mu.Unlock()
// acc <- 1
// }()
}
// for i := 0; i < N; i++ {
// <-acc
// }
t2 := time.Now()
d := t2.Sub(t1)
// time.Sleep(3 * time.Second)
// log.Infof("BenchmarkGo, %+v times in %+v", do, d)
log.Infof("BenchmarkGo, %+v times in %+v", N, d)
}
func NewGame(p *Models) *Game {
g := new(Game)
c, err := redis.Dial("tcp", cfg.RedisAddr(),
redis.DialReadTimeout(1*time.Second), redis.DialWriteTimeout(1*time.Second))
if err != nil {
log.Error(err.Error())
return nil
}
g.c = c
//select db
_, err = c.Do("SELECT", cfg.RedisDBs[cfg.Game])
if err != nil {
log.Error(err.Error())
return nil
}
//register model
g.parent = p
return g
}
//create a redis connection pool
func newPoolRedis(server, password string, maxIdle int, maxActive int, readTimeout int) *redis.Pool {
return &redis.Pool{
MaxIdle: maxIdle,
IdleTimeout: 240 * time.Second,
MaxActive: maxActive,
Wait: false,
Dial: func() (retConn redis.Conn, retErr error) {
defer func() { //assure for not panicking
if r := recover(); r != nil {
log.Error("Error open redis conn!! %v", r)
log.Error("Retuning error")
retConn = nil
retErr = errors.New("Error trying to open redis conn!!")
return
}
}()
c, err := redis.Dial("tcp", server, redis.DialReadTimeout(time.Duration(readTimeout)*time.Millisecond))
if err != nil {
log.Error("Erro ao tentar se conectar ao redis! ", err)
return nil, err
}
return c, err
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err := c.Do("PING")
return err
},
}
}
// updateMaster gets the address of the master node from sentinel
func updateMaster() error {
config.Log.Debug("Contacting sentinel for address of master...")
// connect to sentinel in order to query for the master address
r, err := redis.DialURL("redis://"+config.SentinelAddress, redis.DialConnectTimeout(config.TimeoutNotReady), redis.DialReadTimeout(config.TimeoutSentinelPoll), redis.DialPassword(config.SentinelPassword))
if err != nil {
return fmt.Errorf("Failed to reach sentinel - %v", err)
}
// retrieve the master redis address
addr, err := redis.Strings(r.Do("SENTINEL", "get-master-addr-by-name", config.MonitorName))
if err != nil {
return fmt.Errorf("Failed to get-master-addr-by-name - %v", err)
}
// cleanup after ourselves
r.Close()
// construct a useable address from sentinel's response
masterAddr = fmt.Sprintf("%v:%v", addr[0], addr[1])
config.Log.Debug("Master address: '%v'", masterAddr)
// wait for redis to transition to master
if err = verifyMaster(masterAddr, config.SentinelPassword); err != nil {
return fmt.Errorf("Could not verify master - %v", err)
}
return nil
}