-
-
Save peterhellberg/9450839 to your computer and use it in GitHub Desktop.
package main | |
import ( | |
"flag" | |
"fmt" | |
"net/http" | |
"github.com/codegangsta/martini" | |
"github.com/garyburd/redigo/redis" | |
"github.com/martini-contrib/render" | |
) | |
var ( | |
redisAddress = flag.String("redis-address", ":6379", "Address to the Redis server") | |
maxConnections = flag.Int("max-connections", 10, "Max connections to Redis") | |
) | |
func main() { | |
martini.Env = martini.Prod | |
flag.Parse() | |
redisPool := redis.NewPool(func() (redis.Conn, error) { | |
c, err := redis.Dial("tcp", *redisAddress) | |
if err != nil { | |
return nil, err | |
} | |
return c, err | |
}, *maxConnections) | |
defer redisPool.Close() | |
m := martini.Classic() | |
m.Map(redisPool) | |
m.Use(render.Renderer()) | |
m.Get("/", func() string { | |
return "Hello from Martini!" | |
}) | |
m.Get("/set/:key", func(r render.Render, pool *redis.Pool, params martini.Params, req *http.Request) { | |
key := params["key"] | |
value := req.URL.Query().Get("value") | |
c := pool.Get() | |
defer c.Close() | |
status, err := c.Do("SET", key, value) | |
if err != nil { | |
message := fmt.Sprintf("Could not SET %s:%s", key, value) | |
r.JSON(400, map[string]interface{}{ | |
"status": "ERR", | |
"message": message}) | |
} else { | |
r.JSON(200, map[string]interface{}{ | |
"status": status}) | |
} | |
}) | |
m.Get("/get/:key", func(r render.Render, pool *redis.Pool, params martini.Params) { | |
key := params["key"] | |
c := pool.Get() | |
defer c.Close() | |
value, err := redis.String(c.Do("GET", key)) | |
if err != nil { | |
message := fmt.Sprintf("Could not GET %s", key) | |
r.JSON(400, map[string]interface{}{ | |
"status": "ERR", | |
"message": message}) | |
} else { | |
r.JSON(200, map[string]interface{}{ | |
"status": "OK", | |
"value": value}) | |
} | |
}) | |
m.Run() | |
} |
Thank you for the example! I have it working saving some MySQL results, and I've made a middleware handler that seems to work fine:
func SetupRedis() *redis.Pool {
redisPool := redis.NewPool(func() (redis.Conn, error) {
c, err := redis.Dial("tcp", *redisAddress)
PanicIf(err)
return c, err
}, *maxConnections)
return redisPool
}
but when I have defer redisPool.Close()
in the middleware function, it won't run redis commands in the controllers because the connection pool closes. When I remove defer redisPool.Close()
it all works fine, doing some local tests looks like it's reusing the connection as it should without using defer redisPool.Close()
, so I'm not sure if this is really an issue or not, any thoughts on this?
Disregard that last comment, here's what I did that keeps the main
func a bit cleaner.
func SetupRedis() *redis.Pool {
return redis.NewPool(func() (redis.Conn, error) {
c, err := redis.Dial("tcp", *redisAddress)
PanicIf(err)
return c, err
}, *maxConnections)
}
func main() {
...
redisPool := SetupRedis()
defer redisPool.Close()
m.Map(redisPool)
...
}
Use the struct instead of the NewPool function.
NewPool creates a new pool. This function is deprecated. Applications should initialize the Pool fields directly as shown in example.
https://github.com/garyburd/redigo/blob/master/redis/pool.go#L89
@agrison Thank you, I’ve now updated the example.