session

README

Session

Middleware support for echo, utilizing by gorilla/sessions.

Installation

go get github.com/hobo-go/echo-mw/session

Usage

package main

import (
    "net/http"

    "github.com/gorilla/context"
    "github.com/labstack/echo"
    "github.com/hobo-go/echo-mw/session"
)

func index(c *echo.Context) error {
    session := session.Default(c)

    var count int
    v := session.Get("count")

    if v == nil {
        count = 0
    } else {
        count = v.(int)
        count += 1
    }

    session.Set("count", count)
    session.Save()

    data := struct {
        Visit int
    }{
        Visit: count,
    }

    return c.JSON(http.StatusOK, data)
}

func main() {
    store := session.NewCookieStore([]byte("secret-key"))
    // store := session.NewFilesystemStore("", []byte("secret-key"))
    // store, err := session.NewRedisStore(32, "tcp", "localhost:6379", "", []byte("secret-key"))
    // if err != nil {
    //     panic(err)
    // }

    e := echo.New()

    // Attach middleware
    e.Use(session.Sessions("ESESSION", store))

    // Routes
    e.Get("/", index)

    // Wrap echo with a context.ClearHandler
    http.ListenAndServe(":8080", context.ClearHandler(e))
}

Documentation

Overview

Session implements middleware for easily using github.com/gorilla/sessions within echo. This package was originally inspired from the https://github.com/ipfans/echo-session package, and modified to provide more functionality

Index

• Constants
• func New(name string, store Store) echo.MiddlewareFunc
• type CookieStore
  • func NewCookieStore(keyPairs ...[]byte) CookieStore
• type FilesystemStore
  • func NewFilesystemStore(path string, keyPairs ...[]byte) FilesystemStore
• type Options
• type RedisStore
  • func NewRedisStore(size int, network, address, password string, keyPairs ...[]byte) (RedisStore, error)
• type Session
  • func Default(c echo.Context) Session
• type Store

Constants

const (
	DefaultKey = "github.com/syntaqx/echo-middleware/session"
)

Functions

func New

func New(name string, store Store) echo.MiddlewareFunc

Types

type CookieStore

type CookieStore interface {
	Store
}

func NewCookieStore

func NewCookieStore(keyPairs ...[]byte) CookieStore

Keys are defined in pairs to allow key rotation, but the common case is to set a single authentication key and optionally an encryption key.

The first key in a pair is used for authentication and the second for encryption. The encryption key can be set to nil or omitted in the last pair, but the authentication key is required in all pairs.

It is recommended to use an authentication key with 32 or 64 bytes. The encryption key, if set, must be either 16, 24, or 32 bytes to select AES-128, AES-192, or AES-256 modes.

type FilesystemStore

type FilesystemStore interface {
	Store
}

func NewFilesystemStore

func NewFilesystemStore(path string, keyPairs ...[]byte) FilesystemStore

NewFilesystemStore returns a new FilesystemStore.

The path argument is the directory where sessions will be saved. If empty it will use os.TempDir().

See NewCookieStore() for a description of the other parameters.

type Options

type Options struct {
	Path   string
	Domain string
	// MaxAge=0 means no 'Max-Age' attribute specified.
	// MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'.
	// MaxAge>0 means Max-Age attribute present and given in seconds.
	MaxAge   int
	Secure   bool
	HttpOnly bool
}

Options stores configuration for a session or session store. Fields are a subset of http.Cookie fields.

type RedisStore

type RedisStore interface {
	Store
}

func NewRedisStore

func NewRedisStore(size int, network, address, password string, keyPairs ...[]byte) (RedisStore, error)

size: maximum number of idle connections. network: tcp or udp address: host:port password: redis-password Keys are defined in pairs to allow key rotation, but the common case is to set a single authentication key and optionally an encryption key.

The first key in a pair is used for authentication and the second for encryption. The encryption key can be set to nil or omitted in the last pair, but the authentication key is required in all pairs.

It is recommended to use an authentication key with 32 or 64 bytes. The encryption key, if set, must be either 16, 24, or 32 bytes to select AES-128, AES-192, or AES-256 modes.

type Session

type Session interface {
	// Get returns the session value associated to the given key.
	Get(key interface{}) interface{}
	// Set sets the session value associated to the given key.
	Set(key interface{}, val interface{})
	// Delete removes the session value associated to the given key.
	Delete(key interface{})
	// Clear deletes all values in the session.
	Clear()
	// AddFlash adds a flash message to the session.
	// A single variadic argument is accepted, and it is optional: it defines the flash key.
	// If not defined "_flash" is used by default.
	AddFlash(value interface{}, vars ...string)
	// Flashes returns a slice of flash messages from the session.
	// A single variadic argument is accepted, and it is optional: it defines the flash key.
	// If not defined "_flash" is used by default.
	Flashes(vars ...string) []interface{}
	// Options sets confuguration for a session.
	Options(Options)
	// Save saves all sessions used during the current request.
	Save() error
}

Wraps thinly gorilla-session methods. Session stores the values and optional configuration for a session.

func Default

func Default(c echo.Context) Session

shortcut to get session

type Store

type Store interface {
	sessions.Store
	Options(Options)
}