func (s *S) TestAddRouteCommandFailure(c *check.C) {
r := hipacheRouter{prefix: "hipache", pool: redis.NewPool(fakeConnect, 5)}
addr, _ := url.Parse("http://www.tsuru.io")
err := r.AddBackend("tip")
c.Assert(err, check.IsNil)
conn = &FailingFakeRedisConn{}
r2 := hipacheRouter{prefix: "hipache", pool: redis.NewPool(fakeConnect, 5)}
err = r2.AddRoute("tip", addr)
c.Assert(err, check.FitsTypeOf, &router.RouterError{})
e, ok := err.(*router.RouterError)
c.Assert(ok, check.Equals, true)
c.Assert(e.Err.Error(), check.Equals, "I can't do that.")
c.Assert(e.Op, check.Equals, "routes")
}
func NewStorage(server string) *Storage {
pool := redis.NewPool(func() (conn redis.Conn, err error) {
conn, err = redis.Dial("tcp", server)
return
}, 3)
return &Storage{pool}
}
// Create a new connection pool given a host:port string.
// A password may be supplied as well, on the form "password@host:port".
func NewConnectionPoolHost(hostColonPort string) *ConnectionPool {
// Create a redis Pool
redisPool := redis.NewPool(
// Anonymous function for calling new RedisConnectionTo with the host:port
func() (redis.Conn, error) {
conn, err := newRedisConnectionTo(hostColonPort)
if err != nil {
return nil, err
}
// If a password is given, use it to authenticate
if password, _, ok := twoFields(hostColonPort, "@"); ok {
if password != "" {
if _, err := conn.Do("AUTH", password); err != nil {
conn.Close()
return nil, err
}
}
}
return conn, err
},
// Maximum number of idle connections to the redis database
maxIdleConnections)
pool := ConnectionPool(*redisPool)
return &pool
}
func main() {
// 4 reqs/hour
rate, err := limiter.NewRateFromFormatted("4-H")
if err != nil {
panic(err)
}
// Create a Redis pool.
pool := redis.NewPool(func() (redis.Conn, error) {
c, err := redis.Dial("tcp", ":6379")
if err != nil {
return nil, err
}
return c, err
}, 100)
// Create a store with the pool.
store, err := limiter.NewRedisStore(pool, "limitergjrexample")
if err != nil {
panic(err)
}
mw := limiter.NewHTTPMiddleware(limiter.NewLimiter(store, rate))
http.Handle("/", mw.Handler(http.HandlerFunc(index)))
fmt.Println("Server is running on port 7777...")
log.Fatal(http.ListenAndServe(":7777", nil))
}
func init() {
max := maxConnection()
url := address()
redisPool = redis.NewPool(func() (redis.Conn, error) {
return redisurl.ConnectToURL(url)
}, max)
}
func main() {
pool := redis.NewPool(func() (redis.Conn, error) {
return redis.Dial("tcp", ":6379")
}, 10)
app := redisocket.NewApp(pool)
err := make(chan error)
go func() {
err <- app.Listen()
}()
http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
sub, err := app.NewClient(w, r)
if err != nil {
log.Fatal("Client Connect Error")
return
}
c := &User{app, sub}
err = c.Listen()
log.Println(err, "http point")
return
})
go func() {
err <- http.ListenAndServe(":8888", nil)
}()
select {
case e := <-err:
log.Println(e)
}
}
func (this *RedisProvider) SessionInit(path string, gctime int) error {
this.maxlifetime = gctime
pathArr := strings.Split(path, ",")
if len(pathArr) > 0 {
this.path = pathArr[0]
}
if len(pathArr) > 1 {
ps, err := strconv.Atoi(pathArr[1])
if err != nil || ps <= 0 {
this.poolsize = 200
} else {
this.poolsize = ps
}
} else {
this.poolsize = 200
}
this.pools = redis.NewPool(func() (redis.Conn, error) {
c, err := redis.Dial("tcp", this.path)
if err != nil {
return nil, err
}
_, err = c.Do("SELECT", 0)
if err != nil {
c.Close()
return nil, err
}
return c, nil
}, this.poolsize)
return this.pools.Get().Err()
}
//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]
}
if len(configs) > 1 {
poolsize, err := strconv.Atoi(configs[1])
if err != nil || poolsize <= 0 {
rp.poolsize = MAX_POOL_SIZE
} else {
rp.poolsize = poolsize
}
} else {
rp.poolsize = MAX_POOL_SIZE
}
if len(configs) > 2 {
rp.password = configs[2]
}
rp.poollist = redis.NewPool(func() (redis.Conn, error) {
c, err := redis.Dial("tcp", rp.savePath)
if err != nil {
return nil, err
}
if rp.password != "" {
if _, err := c.Do("AUTH", rp.password); err != nil {
c.Close()
return nil, err
}
}
return c, err
}, rp.poolsize)
return nil
}
func NewMessageServer(redisAddr string, fast bool) (http.Handler, error) {
hostname, err := os.Hostname()
if err != nil {
return nil, err
}
m := &MessageServer{
r: mux.NewRouter(),
name: strings.Replace(hostname, "linuxcon-demo-", "", -1),
pool: redis.NewPool(func() (redis.Conn, error) {
return redis.Dial("tcp", redisAddr)
}, 10),
}
m.r.HandleFunc("/", m.getMessage).Methods("GET")
m.r.HandleFunc("/cache", m.getCache).Methods("GET")
// start filling the cache async on boot
go m.fillCache(redisAddr, fast)
go func() {
for range time.Tick(3 * time.Second) {
if _, err := m.do("SET", fmt.Sprintf("nodes.%s.avg", m.name), requests.Rate1()); err != nil {
logrus.Error(err)
}
}
}()
return m, nil
}
// getPool returns a redis connection pool for a given address
func (p *Pool) getPool(addr string) *redis.Pool {
defer scopedLock(&p.mutx)()
pool, found := p.pools[addr]
if !found {
pool = redis.NewPool(func() (redis.Conn, error) {
return p.dialFunc(addr)
}, maxIdle)
pool.TestOnBorrow = func(c redis.Conn, t time.Time) error {
// for testing - count how many borrows we did
p.numBorrowed++
if time.Since(t) > testOnBorrowInterval {
_, err := c.Do("PING")
return err
}
return nil
}
p.pools[addr] = pool
}
return pool
}
func TestRedisStorageRemoveImagePrefixed(t *testing.T) {
conn := resultCommandConn{
fakeConn: &fakeConn{},
reply: map[string]interface{}{"DEL": int64(1)},
}
var storage redisStorage
storage.pool = redis.NewPool(func() (redis.Conn, error) {
return &conn, nil
}, 3)
storage.prefix = "cluster"
image := "tsuru/python"
err := storage.RemoveImage(image)
if err != nil {
t.Error(err)
}
cmd := conn.cmds[0]
expectedCmd := "DEL"
if cmd.cmd != expectedCmd {
t.Errorf("RemoveImage(%q): want command %q. Got %q.", image, expectedCmd, cmd.cmd)
}
expectedArgs := []interface{}{"cluster:image:" + image}
if !reflect.DeepEqual(cmd.args, expectedArgs) {
t.Errorf("RemoveImage(%q): want args %#v. Got %#v.", image, expectedArgs, cmd.args)
}
}
func NewRedisOption(host string, password string, size int, num int, life int64) (*RedisOption, error) {
ro := &RedisOption{
num: num,
size: size,
life: life,
host: host,
password: password,
}
ro.Pool = redis.NewPool(func() (redis.Conn, error) {
c, err := redis.Dial("tcp", ro.host)
if err != nil {
return nil, err
}
if ro.password != "" {
if _, err := c.Do("AUTH", ro.password); err != nil {
c.Close()
return nil, err
}
}
_, err = c.Do("SELECT", ro.num)
if err != nil {
c.Close()
return nil, err
}
return c, err
}, ro.size)
err := ro.Pool.Get().Err()
if err != nil {
return nil, err
}
return ro, nil
}
func TestRedisStorageRetrieveContainer(t *testing.T) {
conn := resultCommandConn{
fakeConn: &fakeConn{},
reply: map[string]interface{}{"GET": []byte("server0")},
}
var storage redisStorage
storage.pool = redis.NewPool(func() (redis.Conn, error) {
return &conn, nil
}, 3)
container := "affe3022"
host, err := storage.RetrieveContainer(container)
if err != nil {
t.Error(err)
}
expectedHost := "server0"
if host != expectedHost {
t.Errorf("RetrieveContainer(%q): want host %q. Got %q.", container, expectedHost, host)
}
cmd := conn.cmds[0]
expectedCmd := "GET"
if cmd.cmd != expectedCmd {
t.Errorf("RetrieveContainer(%q): want command %q. Got %q.", container, expectedCmd, cmd.cmd)
}
expectedArgs := []interface{}{container}
if !reflect.DeepEqual(cmd.args, expectedArgs) {
t.Errorf("RetrieveContainer(%q): want args %#v. Got %#v.", container, expectedArgs, cmd.args)
}
}
func (rb *Redisbeat) Setup(b *beat.Beat) error {
rb.events = b.Publisher.Connect()
rb.done = make(chan struct{})
// Set up redis pool
redisPool := redis.NewPool(func() (redis.Conn, error) {
c, err := redis.Dial(rb.network, rb.host+":"+strconv.Itoa(rb.port))
if err != nil {
return nil, err
}
return c, err
}, rb.maxConn)
rb.redisPool = redisPool
if rb.auth {
c := rb.redisPool.Get()
defer c.Close()
authed, err := c.Do("AUTH", rb.pass)
if err != nil {
return err
} else {
logp.Debug("redisbeat", "AUTH %v", authed)
}
}
return nil
}
func main() {
rp = redis.NewPool(func() (redis.Conn, error) {
return redis.Dial("tcp", RedisHost+":"+RedisPort)
}, 1000)
var url = DbUser + ":" + DbPass + "@tcp(" + DbHost + ":" + DbPort + ")/" + DbName
db, _ = sql.Open("mysql", url)
defer db.Close()
// Clear Redis
go func() {
c := rp.Get()
c.Do("FLUSHALL")
}()
go loadAllUser()
go loadAllFood()
router := httprouter.New()
router.POST("/login", LoginController)
router.GET("/foods", FoodController)
router.POST("/carts", NewCartsController)
router.PATCH("/carts/:cart_id", FoodsToCartController)
router.POST("/orders", PlaceOrderController)
router.GET("/orders", ShowOrdersController)
router.GET("/admin/orders", AdminShowOrdersController)
log.Fatal(http.ListenAndServe(AppHost+":"+AppPort, router))
}
// New makes and returns a pointer to a new Connector instance. It sets some
// defaults on the ConnectionParam object, such as the policy, which defaults to
// a LogReconnectPolicy with a base of 10ms. A call to this function does not
// produce a connection.
func New(param ConnectionParam, maxIdle int) (*redis.Pool, ReconnectPolicy) {
if param.Policy == nil {
param.Policy = &LogReconnectPolicy{Base: 10, Factor: time.Millisecond}
}
return redis.NewPool(connect(param), maxIdle), param.Policy
}
func initRedisQueue(option *config.Option) map[string][]*poolwrapper {
redispool := make(map[string][]*poolwrapper, 0)
//创建redis的消费连接
for _, v := range option.QueueHostPorts {
hp := v
pool := redis.NewPool(func() (conn redis.Conn, err error) {
conn, err = redis.DialTimeout("tcp", hp.Host+":"+strconv.Itoa(hp.Port),
time.Duration(hp.Timeout)*time.Second,
time.Duration(hp.Timeout)*time.Second,
time.Duration(hp.Timeout)*time.Second)
return
}, hp.Maxconn/2)
pools, ok := redispool[v.QueueName]
if !ok {
pools = make([]*poolwrapper, 0)
redispool[v.QueueName] = pools
}
poolw := &poolwrapper{}
poolw.hostport = v.HostPort
poolw.rpool = pool
redispool[v.QueueName] = append(pools, poolw)
}
return redispool
}
// NewAutocompleter creates a new Autocompleter with the given host and key name
func NewAutocompleter(addr, name string) *Autocompleter {
return &Autocompleter{
pool: redis.NewPool(func() (redis.Conn, error) {
return redis.Dial("tcp", addr)
}, maxConns),
name: name,
}
}
func NewRedisSender(port, channel string) Sender {
return &redisSender{
redis.NewPool(func() (redis.Conn, error) {
return redis.Dial("tcp", port)
}, 3),
channel,
}
}
func (this *Redis) Init() {
this.pool = redis.NewPool(func() (redis.Conn, error) {
return redis.Dial("tcp", config.GetConfig("redis_host"))
}, 20)
this.pool.IdleTimeout = 45 * time.Second
this.pool.MaxActive = 30
this.pool.MaxIdle = 30
}
func (s *RedismqSuite) SetUpSuite(c *gocheck.C) {
s.pool = redis.NewPool(func() (redis.Conn, error) {
return redis.Dial("tcp", "127.0.0.1:6379")
}, 10)
config.Set("queue", "redis")
q := redismqQ{name: "default", pool: s.pool, prefix: "test", maxSize: 10}
conn := s.pool.Get()
conn.Do("DEL", q.key())
}
func NewPool(network, address string) *redis.Pool {
return redis.NewPool(func() (redis.Conn, error) {
c, err := redis.Dial("tcp", address)
if err != nil {
return nil, err
}
return c, nil
}, REDIS_POOL_SIZE)
}
func newRedisConnectionPool(host string, poolSize int) *redis.Pool {
return redis.NewPool(func() (redis.Conn, error) {
c, err := redis.Dial("tcp", host)
if err != nil {
return nil, err
}
return c, err
}, poolSize)
}
func newConnectionPool(connector Connector, size int) *redis.Pool {
return redis.NewPool(func() (redis.Conn, error) {
conn, err := connector.Connect()
if err != nil {
return nil, err
}
return redis.NewConn(conn, 0, 0), nil
}, size)
}
// newRedisPool returns
func newRedisPool() *redis.Pool {
return redis.NewPool(func() (redis.Conn, error) {
c, err := redis.Dial("tcp", ":6379")
if err != nil {
return nil, err
}
return c, err
}, 100)
}
func InitCache() {
pool = redis.NewPool(initConn, poolSize)
conn := Open()
defer conn.Close()
pong, err := conn.Do("ping")
if err != nil {
log.Panicln("can't connect cache server has error", err)
}
log.Println("reach cache server ", pong)
}
func TestRedisRemoveContainerFailure(t *testing.T) {
var conn failingFakeConn
var storage redisStorage
storage.pool = redis.NewPool(func() (redis.Conn, error) {
return &conn, nil
}, 3)
err := storage.RemoveContainer("affe3022")
if err == nil {
t.Error("Unexpected <nil> error")
}
}
func init() {
var err error
if pool, err = Open("127.0.0.1:6379", 10, 5, time.Duration(10)*time.Second); err != nil {
fmt.Println(err)
os.Exit(1)
}
fn := func() (redigo.Conn, error) {
return redigo.Dial("tcp4", "127.0.0.1:6379")
}
pool1 = redigo.NewPool(fn, 5)
}
func newRedisPool(uri string, maxIdle int, maxOpen int, idleTimout time.Duration) *redis.Pool {
generator := func() (redis.Conn, error) {
return redisurl.ConnectToURL(uri)
}
p := redis.NewPool(generator, maxIdle)
p.MaxActive = maxOpen
p.IdleTimeout = idleTimout
return p
}
func connect() redis.Conn {
if pool == nil {
srv, err := config.GetString("hipache:redis-server")
if err != nil {
srv = "localhost:6379"
}
pool = redis.NewPool(func() (redis.Conn, error) {
return redis.Dial("tcp", srv)
}, 10)
}
return pool.Get()
}