redisstore

README

redisstore

Package redisstore is a Redis-based storage engine for the SCS session package.

Warning: The redisstore API is not finalized and may change, possibly significantly. The package is fine to use as-is, but it is strongly recommended that you vendor the package to avoid compatibility problems in the future.

Usage

Installation

Either:

$ go get github.com/alexedwards/scs/engine/redisstore

Or (recommended) use use gvt to vendor the engine/redisstore and session sub-packages:

$ gvt fetch github.com/alexedwards/scs/engine/redisstore
$ gvt fetch github.com/alexedwards/scs/session

Example

The redisstore package uses the popular Redigo Redis client.

You should follow the Redigo instructions to setup a connection pool, and pass the pool to redisstore.New() to establish the session storage engine.

package main

import (
    "io"
    "net/http"

    "github.com/alexedwards/scs/engine/redisstore"
    "github.com/alexedwards/scs/session"
    "github.com/garyburd/redigo/redis"
)

func main() {
    // Establish a Redigo connection pool.
    pool := &redis.Pool{
        MaxIdle: 10,
        Dial: func() (redis.Conn, error) {
            return redis.Dial("tcp", "localhost:6379")
        },
    }

    // Create a new RedisStore instance using the connection pool.
    engine := redisstore.New(pool)

    sessionManager := session.Manage(engine)
    http.HandleFunc("/put", putHandler)
    http.HandleFunc("/get", getHandler)
    http.ListenAndServe(":4000", sessionManager(http.DefaultServeMux))
}

func putHandler(w http.ResponseWriter, r *http.Request) {
    err := session.PutString(r, "message", "Hello world!")
    if err != nil {
        http.Error(w, err.Error(), 500)
    }
}

func getHandler(w http.ResponseWriter, r *http.Request) {
    msg, err := session.GetString(r, "message")
    if err != nil {
        http.Error(w, err.Error(), 500)
    }
    io.WriteString(w, msg)
}

Cleaning up expired session data

Redis will automatically remove expired session keys.

Notes

Full godoc documentation: https://godoc.org/github.com/alexedwards/scs/engine/redisstore.

Documentation

Overview

Package redisstore is a Redis-based storage engine for the SCS session package.

Warning: The redisstore API is not finalized and may change, possibly significantly. The package is fine to use as-is, but it is strongly recommended that you vendor the package to avoid compatibility problems in the future.

The redisstore package relies on the the popular Redigo Redis client (https://github.com/garyburd/redigo).

Usage:

func main() {
	// Establish a Redigo connection pool following instructions at
	// https://godoc.org/github.com/garyburd/redigo/redis#Pool
    pool := &redis.Pool{
        MaxIdle: 10,
        Dial: func() (redis.Conn, error) {
            return redis.Dial("tcp", "localhost:6379")
        },
    }

    // Create a new RedisStore instance using the connection pool.
    engine := redisstore.New(pool)

    sessionManager := session.Manage(engine)
    http.ListenAndServe(":4000", sessionManager(http.DefaultServeMux))
}

Index

• Variables
• type RedisStore
  • func New(pool *redis.Pool) *RedisStore
  • func (r *RedisStore) Delete(token string) error
  • func (r *RedisStore) Find(token string) (b []byte, exists bool, err error)
  • func (r *RedisStore) Save(token string, b []byte, expiry time.Time) error

Variables

var Prefix = "scs:session:"

Prefix controls the Redis key prefix. You should only need to change this if there is a naming clash.

Types

type RedisStore

type RedisStore struct {
	// contains filtered or unexported fields
}

RedisStore represents the currently configured session storage engine. It is essentially a wrapper around a Redigo connection pool.

func New

func New(pool *redis.Pool) *RedisStore

New returns a new RedisStore instance. The pool parameter should be a pointer to a Redigo connection pool. See https://godoc.org/github.com/garyburd/redigo/redis#Pool.

func (*RedisStore) Delete

func (r *RedisStore) Delete(token string) error

Delete removes a session token and corresponding data from the ResisStore instance.

func (*RedisStore) Find

func (r *RedisStore) Find(token string) (b []byte, exists bool, err error)

Find returns the data for a given session token from the RedisStore instance. If the session token is not found or is expired, the returned exists flag will be set to false.

func (*RedisStore) Save

func (r *RedisStore) Save(token string, b []byte, expiry time.Time) error

Save adds a session token and data to the RedisStore instance with the given expiry time. If the session token already exists then the data and expiry time are updated.