fix #241#192

@@ -39,10 +39,10 @@ Then in you web app init the global session manager
 			go globalSessions.GC()
 			go globalSessions.GC()
 		}
 		}
 
 
-* Use **Redis** as provider, the last param is the Redis conn address:
+* Use **Redis** as provider, the last param is the Redis conn address,poolsize,password:
 
 
 		func init() {
 		func init() {
-			globalSessions, _ = session.NewManager("redis", "gosessionid", 3600, "127.0.0.1:6379")
+			globalSessions, _ = session.NewManager("redis", "gosessionid", 3600, "127.0.0.1:6379,100,astaxie")
 			go globalSessions.GC()
 			go globalSessions.GC()
 		}
 		}
 		
 		

 package session
 package session
 
 
 import (
 import (
-	"fmt"
 	"github.com/garyburd/redigo/redis"
 	"github.com/garyburd/redigo/redis"
+	"strconv"
+	"strings"
 )
 )
 
 
 var redispder = &RedisProvider{}
 var redispder = &RedisProvider{}
 
 
-var MAX_POOL_SIZE = 20
+var MAX_POOL_SIZE = 100
 
 
 var redisPool chan redis.Conn
 var redisPool chan redis.Conn
 
 
@@ -52,72 +53,73 @@ func (rs *RedisSessionStore) SessionRelease() {
 type RedisProvider struct {
 type RedisProvider struct {
 	maxlifetime int64
 	maxlifetime int64
 	savePath    string
 	savePath    string
+	poolsize    int
+	password    string
+	poollist    *redis.Pool
 }
 }
 
 
-func (rp *RedisProvider) connectInit() redis.Conn {
-	/*c, err := redis.Dial("tcp", rp.savePath)
-	if err != nil {
-		return nil
+//savepath like redisserveraddr,poolsize,password
+//127.0.0.1:6379,100,astaxie
+func (rp *RedisProvider) SessionInit(maxlifetime int64, savePath string) error {
+	rp.maxlifetime = maxlifetime
+	configs := strings.Split(savePath, ",")
+	if len(configs) > 0 {
+		rp.savePath = configs[0]
 	}
 	}
-	return c*/
-	//if redisPool == nil {
-	redisPool = make(chan redis.Conn, MAX_POOL_SIZE)
-	//}
-	if len(redisPool) == 0 {
-		go func() {
-			for i := 0; i < MAX_POOL_SIZE/2; i++ {
-				c, err := redis.Dial("tcp", rp.savePath)
-				if err != nil {
-					fmt.Println(err)
-					return
+	if len(configs) > 1 {
+		poolsize, err := strconv.Atoi(configs[1])
+		if err != nil || poolsize <= 0 {
+			rp.poolsize = MAX_POOL_SIZE
+		} else {
+			rp.poolsize = poolsize
 		}
 		}
-				putRedis(c)
+	} else {
+		rp.poolsize = MAX_POOL_SIZE
 	}
 	}
-		}()
+	if len(configs) > 2 {
+		rp.password = configs[2]
 	}
 	}
-	return <-redisPool
-}
-
-func putRedis(conn redis.Conn) {
-	if redisPool == nil {
-		redisPool = make(chan redis.Conn, MAX_POOL_SIZE)
+	rp.poollist = redis.NewPool(func() (redis.Conn, error) {
+		c, err := redis.Dial("tcp", rp.savePath)
+		if err != nil {
+			return nil, err
 		}
 		}
-	if len(redisPool) >= MAX_POOL_SIZE {
-		conn.Close()
-		return
+		if rp.password != "" {
+			if _, err := c.Do("AUTH", rp.password); err != nil {
+				c.Close()
+				return nil, err
 			}
 			}
-	redisPool <- conn
-}
-
-func (rp *RedisProvider) SessionInit(maxlifetime int64, savePath string) error {
-	rp.maxlifetime = maxlifetime
-	rp.savePath = savePath
+		}
+		return c, err
+	}, rp.poolsize)
 	return nil
 	return nil
 }
 }
 
 
 func (rp *RedisProvider) SessionRead(sid string) (SessionStore, error) {
 func (rp *RedisProvider) SessionRead(sid string) (SessionStore, error) {
-	c := rp.connectInit()
+	c := rp.poollist.Get()
 	//if str, err := redis.String(c.Do("GET", sid)); err != nil || str == "" {
 	//if str, err := redis.String(c.Do("GET", sid)); err != nil || str == "" {
 	if str, err := redis.String(c.Do("HGET", sid, sid)); err != nil || str == "" {
 	if str, err := redis.String(c.Do("HGET", sid, sid)); err != nil || str == "" {
 		//c.Do("SET", sid, sid, rp.maxlifetime)
 		//c.Do("SET", sid, sid, rp.maxlifetime)
 		c.Do("HSET", sid, sid, rp.maxlifetime)
 		c.Do("HSET", sid, sid, rp.maxlifetime)
 	}
 	}
+	c.Do("EXPIRE", sid, rp.maxlifetime)
 	rs := &RedisSessionStore{c: c, sid: sid}
 	rs := &RedisSessionStore{c: c, sid: sid}
 	return rs, nil
 	return rs, nil
 }
 }
 
 
 func (rp *RedisProvider) SessionRegenerate(oldsid, sid string) (SessionStore, error) {
 func (rp *RedisProvider) SessionRegenerate(oldsid, sid string) (SessionStore, error) {
-	c := rp.connectInit()
+	c := rp.poollist.Get()
 	if str, err := redis.String(c.Do("HGET", oldsid, oldsid)); err != nil || str == "" {
 	if str, err := redis.String(c.Do("HGET", oldsid, oldsid)); err != nil || str == "" {
 		c.Do("HSET", oldsid, oldsid, rp.maxlifetime)
 		c.Do("HSET", oldsid, oldsid, rp.maxlifetime)
 	}
 	}
 	c.Do("RENAME", oldsid, sid)
 	c.Do("RENAME", oldsid, sid)
+	c.Do("EXPIRE", sid, rp.maxlifetime)
 	rs := &RedisSessionStore{c: c, sid: sid}
 	rs := &RedisSessionStore{c: c, sid: sid}
 	return rs, nil
 	return rs, nil
 }
 }
 
 
 func (rp *RedisProvider) SessionDestroy(sid string) error {
 func (rp *RedisProvider) SessionDestroy(sid string) error {
-	c := rp.connectInit()
+	c := rp.poollist.Get()
 	c.Do("DEL", sid)
 	c.Do("DEL", sid)
 	return nil
 	return nil
 }
 }