Golang redis.NewPool函數代碼示例

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 "[email protected]: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))
}