// New creates a RedisStore, and creates a redis connection pool for the
// supplied redis url. Written/read data in the store use the DefaultKeyPrefix
// or the provided key prefix for key retrieval/storage.
func New(redisURL string, keyPrefix ...string) (*RedisStore, error) {
// determine key prefix
keyPrefixVal := ""
if len(keyPrefix) > 0 {
keyPrefixVal = keyPrefix[0]
}
// parse url
u, err := url.Parse(redisURL)
if err != nil {
return nil, err
}
// ensure that its a redis:// url
if u.Scheme != "redis" {
return nil, ErrInvalidScheme
}
// create pool
p, err := pool.NewPool("tcp", u.Host, 1)
if err != nil {
return nil, err
}
return &RedisStore{
KeyPrefix: keyPrefixVal,
Pool: p,
}, nil
}
// Creates a sentinel client. Connects to the given sentinel instance, pulls the
// information for the masters of the given names, and creates an intial pool of
// connections for each master. The client will automatically replace the pool
// for any master should sentinel decide to fail the master over. The returned
// error is a *ClientError.
func NewClient(
network, address string, poolSize int, 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.NewPool("tcp", addr, poolSize)
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,
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 NewRedisDataAccess(network string, addr string, appDomain string, poolSize int) NoDbDataAccess {
da := new(RedisDataAccess)
da.network = network
da.addr = addr
da.appDomain = appDomain
da.zunionOutputKey = da.withDomain("unionoutput")
pool, err := pool.NewPool(network, addr, poolSize)
if err != nil {
panic(err)
}
da.pool = pool
return da
}
// options sample:
// `{ "addr": "127.0.0.1:6389",
// "network":"tcp",
// "db": 0,
// "password": "",
// "pools": 5
// }`
func createRedisPool(options string) {
var (
err error
config struct {
Addr string
Db int
Network string
Password string
Pools int
}
)
if options != "" {
err = json.Unmarshal([]byte(options), &config)
if err != nil {
//println("unmarshal failed:", err.Error())
config.Addr = defaultAddr
config.Network = defaultNetwork
config.Pools = defaultPoolSize
}
}
if config.Pools <= 0 {
config.Pools = defaultPoolSize
}
if config.Addr == "" {
config.Addr = defaultAddr
}
if config.Network == "" {
config.Network = "tcp"
}
_pool, err = pool.NewPool(config.Network, config.Addr, config.Pools)
if err != nil {
panic(err.Error())
}
}
func TestReset(t *T) {
// Simply initializing a cluster proves Reset works to some degree, since
// NewCluster calls Reset
cluster := getCluster(t)
old7000Pool := cluster.pools["127.0.0.1:7000"]
old7001Pool := cluster.pools["127.0.0.1:7001"]
// We make a bogus client and add it to the cluster to prove that it gets
// removed, since it's not needed
p, err := pool.NewPool("tcp", "127.0.0.1:6379", 10)
assert.Nil(t, err)
cluster.pools["127.0.0.1:6379"] = p
// We use resetInnerUsingPool so that we can specifically specify the pool
// being used, so we don't accidentally use the 6379 one (which doesn't have
// CLUSTER commands)
respCh := make(chan bool)
cluster.callCh <- func(c *Cluster) {
err := cluster.resetInnerUsingPool("127.0.0.1:7000", old7000Pool)
assert.Nil(t, err)
respCh <- true
}
<-respCh
// Prove that the bogus client is closed
_, ok := cluster.pools["127.0.0.1:6379"]
assert.Equal(t, false, ok)
// Prove that the remaining two addresses are still in clients, were not
// reconnected, and still work
assert.Equal(t, 2, len(cluster.pools))
assert.Equal(t, old7000Pool, cluster.pools["127.0.0.1:7000"])
assert.Equal(t, old7001Pool, cluster.pools["127.0.0.1:7001"])
assert.Nil(t, cluster.Cmd("GET", "foo").Err)
assert.Nil(t, cluster.Cmd("GET", "bar").Err)
}
