redis.go.redisgo

// Copyright 2014 mqant Author. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package utils

import (
	"github.com/go-redis/redis"
	"github.com/liangdas/mqant/log"
	"runtime"
	"time"
	"net"
	"crypto/tls"
)
var factory *RedisFactory

func GetRedisFactory() *RedisFactory {
	if factory==nil{
		factory=&RedisFactory{
			pools:NewBeeMap(),
		}
	}
	return factory
}
type RedisFactory struct{
	pools *BeeMap
}
func initOpt(opt *redis.Options) {
	if opt.Network == "" {
		opt.Network = "tcp"
	}
	if opt.Dialer == nil {
		opt.Dialer = func() (net.Conn, error) {
			conn, err := net.DialTimeout(opt.Network, opt.Addr, opt.DialTimeout)
			if opt.TLSConfig == nil || err != nil {
				return conn, err
			}
			t := tls.Client(conn, opt.TLSConfig)
			return t, t.Handshake()
		}
	}
	if opt.PoolSize == 0 {
		opt.PoolSize = 10 * runtime.NumCPU()
	}
	if opt.DialTimeout == 0 {
		opt.DialTimeout = 5 * time.Second
	}
	switch opt.ReadTimeout {
	case -1:
		opt.ReadTimeout = 0
	case 0:
		opt.ReadTimeout = 3 * time.Second
	}
	switch opt.WriteTimeout {
	case -1:
		opt.WriteTimeout = 0
	case 0:
		opt.WriteTimeout = opt.ReadTimeout
	}
	if opt.PoolTimeout == 0 {
		opt.PoolTimeout = opt.ReadTimeout + time.Second
	}
	if opt.IdleTimeout == 0 {
		opt.IdleTimeout = 5 * time.Minute
	}
	if opt.IdleCheckFrequency == 0 {
		opt.IdleCheckFrequency = time.Minute
	}

	switch opt.MinRetryBackoff {
	case -1:
		opt.MinRetryBackoff = 0
	case 0:
		opt.MinRetryBackoff = 8 * time.Millisecond
	}
	switch opt.MaxRetryBackoff {
	case -1:
		opt.MaxRetryBackoff = 0
	case 0:
		opt.MaxRetryBackoff = 512 * time.Millisecond
	}
}
func (this RedisFactory)GetPool(url string) (*redis.Client,error) {
	if pool,ok:=this.pools.Items()[url];ok{
		return pool.(*redis.Client),nil
	}
	options, err:=redis.ParseURL(url)
	if err!=nil{
		return nil,err
	}
	initOpt(options)
	log.Error("options.PoolTimeout",options.PoolTimeout)
	client := redis.NewClient(options)
	//pool := &redis.Pool{
	//	MaxIdle:     30,
	//	IdleTimeout: 240 * time.Second,
	//	Dial: func() (redis.Conn, error) {
	//		c, err := redis.DialURL(url)
	//		if err != nil {
	//			return nil, err
	//		}
	//		return c, err
	//	},
	//	TestOnBorrow: func(c redis.Conn, t time.Time) error {
	//		_, err := c.Do("PING")
	//		return err
	//	},
	//}
	if client!=nil{
		this.pools.Set(url,client)
	}
	return client,nil
}
func (this RedisFactory)CloseAllPool(){
	for _,pool:=range this.pools.Items(){
		pool.(*redis.Client).Close()
	}
	this.pools.DeleteAll()
}