README

sessions

Go Report Card GoDoc

Echo middleware for session management with multi-backend support:

Usage

Start using it

Download and install it:

$ go get github.com/gokit/echox/sessions

Import it in your code:

import "github.com/gokit/echox/sessions"

Basic Examples

single session
package main

import (
	"github.com/gokit/echox/sessions"
	"github.com/gokit/echox/sessions/cookie"
	"github.com/labstack/echo/v4"
)

func main() {
	r := echo.New()
	store := cookie.NewStore([]byte("secret"))
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/hello", func(c echo.Context) error {
		session := sessions.Default(c)

		if session.Get("hello") != "world" {
			session.Set("hello", "world")
			session.Save()
		}

		c.JSON(200, echo.Map{"hello": session.Get("hello")})

        return nil
	})
	r.Start(":8000")
}
multiple sessions
package main

import (
	"github.com/gokit/echox/sessions"
	"github.com/gokit/echox/sessions/cookie"
	"github.com/labstack/echo/v4"
)

func main() {
	r := echo.New()
	store := cookie.NewStore([]byte("secret"))
	sessionNames := []string{"a", "b"}
	r.Use(sessions.SessionsMany(sessionNames, store))

	r.GET("/hello", func(c echo.Context) error {
		sessionA := sessions.DefaultMany(c, "a")
		sessionB := sessions.DefaultMany(c, "b")

		if sessionA.Get("hello") != "world!" {
			sessionA.Set("hello", "world!")
			sessionA.Save()
		}

		if sessionB.Get("hello") != "world?" {
			sessionB.Set("hello", "world?")
			sessionB.Save()
		}

		c.JSON(200, echo.Map{
			"a": sessionA.Get("hello"),
			"b": sessionB.Get("hello"),
		})
        
        return nil
	})
	r.Start(":8000")
}

Backend examples

package main

import (
	"github.com/gokit/echox/sessions"
	"github.com/gokit/echox/sessions/cookie"
	"github.com/labstack/echo/v4"
)

func main() {
	r := echo.New()
	store := cookie.NewStore([]byte("secret"))
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/incr", func(c echo.Context) error {
		session := sessions.Default(c)
		var count int
		v := session.Get("count")
		if v == nil {
			count = 0
		} else {
			count = v.(int)
			count++
		}
		session.Set("count", count)
		session.Save()
		c.JSON(200, echo.Map{"count": count})
        return nil
	})
	r.Start(":8000")
}
filesystem
package main

import (
	"github.com/gokit/echox/sessions"
	"github.com/gokit/echox/sessions/filesystem"
	"github.com/labstack/echo/v4"
)

func main() {
	r := echo.New()
	store := filesystem.NewStore("/path/to/sessions/", []byte("secret"))
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/incr", func(c echo.Context) error {
		session := sessions.Default(c)
		var count int
		v := session.Get("count")
		if v == nil {
			count = 0
		} else {
			count = v.(int)
			count++
		}
		session.Set("count", count)
		session.Save()
		c.JSON(200, echo.Map{"count": count})
        return nil
	})
	r.Start(":8000")
}
Redis
package main

import (
	"github.com/gokit/echox/sessions"
	"github.com/gokit/echox/sessions/redis"
	"github.com/labstack/echo/v4"
)

func main() {
	r := echo.New()
	store, _ := redis.NewStore(10, "tcp", "localhost:6379", "", []byte("secret"))
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/incr", func(c echo.Context) error {
		session := sessions.Default(c)
		var count int
		v := session.Get("count")
		if v == nil {
			count = 0
		} else {
			count = v.(int)
			count++
		}
		session.Set("count", count)
		session.Save()
		c.JSON(200, echo.Map{"count": count})
        return nil
	})
	r.Start(":8000")
}
Memcached
ASCII Protocol
package main

import (
	"github.com/bradfitz/gomemcache/memcache"
	"github.com/gokit/echox/sessions"
	"github.com/gokit/echox/sessions/memcached"
	"github.com/labstack/echo/v4"
)

func main() {
	r := echo.New()
	store := memcached.NewStore(memcache.New("localhost:11211"), "", []byte("secret"))
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/incr", func(c echo.Context) error {
		session := sessions.Default(c)
		var count int
		v := session.Get("count")
		if v == nil {
			count = 0
		} else {
			count = v.(int)
			count++
		}
		session.Set("count", count)
		session.Save()
		c.JSON(200, echo.Map{"count": count})
        return nil
	})
	r.Start(":8000")
}
Binary protocol (with optional SASL authentication)
package main

import (
	"github.com/gokit/echox/sessions"
	"github.com/gokit/echox/sessions/memcached"
	"github.com/labstack/echo/v4"
	"github.com/memcachier/mc"
)

func main() {
	r := echo.New()
	client := mc.NewMC("localhost:11211", "username", "password")
	store := memcached.NewMemcacheStore(client, "", []byte("secret"))
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/incr", func(c echo.Context) error {
		session := sessions.Default(c)
		var count int
		v := session.Get("count")
		if v == nil {
			count = 0
		} else {
			count = v.(int)
			count++
		}
		session.Set("count", count)
		session.Save()
		c.JSON(200, echo.Map{"count": count})
        return nil
	})
	r.Start(":8000")
}
MongoDB
package main

import (
	"github.com/gokit/echox/sessions"
	"github.com/gokit/echox/sessions/mongo"
	"github.com/labstack/echo/v4"
	"github.com/globalsign/mgo"
)

func main() {
	r := echo.New()
	session, err := mgo.Dial("localhost:27017/test")
	if err != nil {
		// handle err
	}

	c := session.DB("").C("sessions")
	store := mongo.NewStore(c, 3600, true, []byte("secret"))
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/incr", func(c echo.Context) error {
		session := sessions.Default(c)
		var count int
		v := session.Get("count")
		if v == nil {
			count = 0
		} else {
			count = v.(int)
			count++
		}
		session.Set("count", count)
		session.Save()
		c.JSON(200, echo.Map{"count": count})
        return nil
	})
	r.Start(":8000")
}
memstore
package main

import (
	"github.com/gokit/echox/sessions"
	"github.com/gokit/echox/sessions/memstore"
	"github.com/labstack/echo/v4"
)

func main() {
	r := echo.New()
	store := memstore.NewStore([]byte("secret"))
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/incr", func(c echo.Context) error {
		session := sessions.Default(c)
		var count int
		v := session.Get("count")
		if v == nil {
			count = 0
		} else {
			count = v.(int)
			count++
		}
		session.Set("count", count)
		session.Save()
		c.JSON(200, echo.Map{"count": count})
        return nil
	})
	r.Start(":8000")
}
Expand ▾ Collapse ▴

Documentation

Index

Constants

View Source
const (
	DefaultKey = "github.com/gokit/echox/sessions"
)

Variables

This section is empty.

Functions

func Sessions

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

echo

func SessionsByContext

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

echo - store session by context

func SessionsMany

func SessionsMany(names []string, store Store) echo.MiddlewareFunc

echo

func SessionsManyByContext

func SessionsManyByContext(names []string, store Store) echo.MiddlewareFunc

echo - store session by context

Types

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
	// rfc-draft to preventing CSRF: https://tools.ietf.org/html/draft-west-first-party-cookies-07
	//   refer: https://godoc.org/net/http
	//          https://www.sjoerdlangkemper.nl/2016/04/14/preventing-csrf-with-samesite-cookie-attribute/
	SameSite http.SameSite
}

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

func (Options) ToGorillaOptions

func (options Options) ToGorillaOptions() *gsessions.Options

type Session

type Session interface {
	// Get Session ID
	ID() string
	// 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 configuration for a session.
	Options(Options)
	// Save saves all sessions used during the current request.
	Save() error
	// Destory session
	Destory() error
	// Session is new
	IsNew() bool
}

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

func DefaultByContext

func DefaultByContext(r *http.Request) Session

shortcut to get session from context

func DefaultMany

func DefaultMany(c echo.Context, name string) Session

shortcut to get session with given name

func DefaultManyByContext

func DefaultManyByContext(r *http.Request, name string) Session

shortcut to get session with given name from context

type Store

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

Directories

Path Synopsis
cookie
example/cookie
example/filesystem
example/memcached/ascii
example/memcached/binary
example/memstore
example/mongo
example/redis
filesystem
memcached
memstore
mongo
redis
tester Package tester is a package to test each packages of session stores, such as cookie, redis, memcached, mongo, memstore.