A tiny example API written in Go using Martini and Redigo

api.go

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()
}

Now I just need to figure out how to inject the Redis connection pool into a Martini middleware :)

I think you need

   defer c.Close() 

after the pool Get() calls.

@monamousa Yes, thank you :)

@peterhellberg You can inject stuff into Martini with m.Map() https://github.com/codegangsta/martini#services

@rastasheep Thank you. I probably want to inject the pool and then retrieve the connection like I currently do, especially since:

Go's reflection cannot tell that you are trying to map redis.Conn as an interface, that is where you have to use the MapTo method. – Jeremy Saenz

Example on how to create your own little Martini middleware:
Go Advent Day 11 - Build a Christmas List with Martini - Hooking up MongoDB

Thanks for this! I too am trying to figure out how to use MapTo with redigo. I'm still new to Go so maybe that's why I'm having difficulties trying to make it work with MapTo.

You can just use m.Map(redisPool) to map the redis pool into your handlers and then just call redisPool.Get() to retrieve a connection, something like this:

func getFoo(render render.Render, pool *redis.Pool) {
    v, err := redis.Values(redisPool.Get().Do("HGETALL", "foo")) // or any redis command
    if err != nil {
        panic(err)
    }
    render.JSON(200, &v)
}

I too cannot map directly a *redis.Conn (it is backed as a *redis.conn which is not exported) into a handler, I have to use a connection pool, which is after all not a bad thing ;-)

@agrison Thank you, I’ve now updated the example.

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