sessions

package module
v0.2.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 23, 2024 License: BSD-3-Clause Imports: 11 Imported by: 26

README

Gorilla Sessions

[!IMPORTANT] The latest version of this repository requires go 1.23 because of the new partitioned attribute. The last version that is compatible with older versions of go is v1.3.0.

testing codecov godoc sourcegraph

Gorilla Logo

gorilla/sessions provides cookie and filesystem sessions and infrastructure for custom session backends.

The key features are:

  • Simple API: use it as an easy way to set signed (and optionally encrypted) cookies.
  • Built-in backends to store sessions in cookies or the filesystem.
  • Flash messages: session values that last until read.
  • Convenient way to switch session persistency (aka "remember me") and set other attributes.
  • Mechanism to rotate authentication and encryption keys.
  • Multiple sessions per request, even using different backends.
  • Interfaces and infrastructure for custom session backends: sessions from different stores can be retrieved and batch-saved using a common API.

Let's start with an example that shows the sessions API in a nutshell:

	import (
		"net/http"
		"github.com/gorilla/sessions"
	)

	// Note: Don't store your key in your source code. Pass it via an
	// environmental variable, or flag (or both), and don't accidentally commit it
	// alongside your code. Ensure your key is sufficiently random - i.e. use Go's
	// crypto/rand or securecookie.GenerateRandomKey(32) and persist the result.
	var store = sessions.NewCookieStore([]byte(os.Getenv("SESSION_KEY")))

	func MyHandler(w http.ResponseWriter, r *http.Request) {
		// Get a session. We're ignoring the error resulted from decoding an
		// existing session: Get() always returns a session, even if empty.
		session, _ := store.Get(r, "session-name")
		// Set some session values.
		session.Values["foo"] = "bar"
		session.Values[42] = 43
		// Save it before we write to the response/return from the handler.
		err := session.Save(r, w)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}

First we initialize a session store calling NewCookieStore() and passing a secret key used to authenticate the session. Inside the handler, we call store.Get() to retrieve an existing session or create a new one. Then we set some session values in session.Values, which is a map[interface{}]interface{}. And finally we call session.Save() to save the session in the response.

More examples are available at package documentation.

Store Implementations

Other implementations of the sessions.Store interface:

License

BSD licensed. See the LICENSE file for details.

Documentation

Overview

Package sessions provides cookie and filesystem sessions and infrastructure for custom session backends.

The key features are:

  • Simple API: use it as an easy way to set signed (and optionally encrypted) cookies.
  • Built-in backends to store sessions in cookies or the filesystem.
  • Flash messages: session values that last until read.
  • Convenient way to switch session persistency (aka "remember me") and set other attributes.
  • Mechanism to rotate authentication and encryption keys.
  • Multiple sessions per request, even using different backends.
  • Interfaces and infrastructure for custom session backends: sessions from different stores can be retrieved and batch-saved using a common API.

Let's start with an example that shows the sessions API in a nutshell: 

import (
	"github.com/admpub/sessions"
	"github.com/webx-top/echo"
)

// Note: Don't store your key in your source code. Pass it via an
// environmental variable, or flag (or both), and don't accidentally commit it
// alongside your code. Ensure your key is sufficiently random - i.e. use Go's
// crypto/rand or securecookie.GenerateRandomKey(32) and persist the result.
// Ensure SESSION_KEY exists in the environment, or sessions will fail.
var store = sessions.NewCookieStore([]byte(os.Getenv("SESSION_KEY")))

func MyHandler(ctx echo.Context) error {
	// Get a session. We're ignoring the error resulted from decoding an
	// existing session: Get() always returns a session, even if empty.
	session, err := store.Get(ctx, "session-name")
	if err != nil {
		return err
	}

	// Set some session values.
	session.Values["foo"] = "bar"
	session.Values[42] = 43
	// Save it before we write to the response/return from the handler.
	session.Save(ctx)
	return nil
}

First we initialize a session store calling NewCookieStore() and passing a secret key used to authenticate the session. Inside the handler, we call store.Get() to retrieve an existing session or a new one. Then we set some session values in session.Values, which is a map[interface{}]interface{}. And finally we call session.Save() to save the session in the response.

Note that in production code, we should check for errors when calling session.Save(r, w), and either display an error message or otherwise handle it.

Save must be called before writing to the response, otherwise the session cookie will not be sent to the client.

That's all you need to know for the basic usage. Let's take a look at other options, starting with flash messages.

Flash messages are session values that last until read. The term appeared with Ruby On Rails a few years back. When we request a flash message, it is removed from the session. To add a flash, call session.AddFlash(), and to get all flashes, call session.Flashes(). Here is an example: 

func MyHandler(ctx echo.Context) error {
	// Get a session.
	session, err := store.Get(ctx, "session-name")
	if err != nil {
		return error
	}

	// Get the previous flashes, if any.
	if flashes := session.Flashes(); len(flashes) > 0 {
		// Use the flash values.
	} else {
		// Set a new flash.
		session.AddFlash("Hello, flash messages world!")
	}
	session.Save(ctx)
	return nil
}

Flash messages are useful to set information to be read after a redirection, like after form submissions.

There may also be cases where you want to store a complex datatype within a session, such as a struct. Sessions are serialised using the encoding/gob package, so it is easy to register new datatypes for storage in sessions: 

import(
	"encoding/gob"
	"github.com/admpub/sessions"
	"github.com/webx-top/echo"
)

type Person struct {
	FirstName	string
	LastName 	string
	Email		string
	Age			int
}

type M map[string]interface{}

func init() {

	gob.Register(&Person{})
	gob.Register(&M{})
}

As it's not possible to pass a raw type as a parameter to a function, gob.Register() relies on us passing it a value of the desired type. In the example above we've passed it a pointer to a struct and a pointer to a custom type representing a map[string]interface. (We could have passed non-pointer values if we wished.) This will then allow us to serialise/deserialise values of those types to and from our sessions.

Note that because session values are stored in a map[string]interface{}, there's a need to type-assert data when retrieving it. We'll use the Person struct we registered above: 

func MyHandler(ctx echo.Context) error {
	session, err := store.Get(ctx, "session-name")
	if err != nil {
		return err
	}

	// Retrieve our struct and type-assert it
	val := session.Values["person"]
	var person = &Person{}
	if person, ok := val.(*Person); !ok {
		// Handle the case that it's not an expected type
	}

	// Now we can use our person object

	return nil
}

By default, session cookies last for a month. This is probably too long for some cases, but it is easy to change this and other attributes during runtime. Sessions can be configured individually or the store can be configured and then all sessions saved using it will use that configuration. We access session.Options or store.Options to set a new configuration. The fields are basically a subset of http.Cookie fields. Let's change the maximum age of a session to one week: 

session.Options = &sessions.Options{
	Path:     "/",
	MaxAge:   86400 * 7,
	HttpOnly: true,
}

Sometimes we may want to change authentication and/or encryption keys without breaking existing sessions. The CookieStore supports key rotation, and to use it you just need to set multiple authentication and encryption keys, in pairs, to be tested in order: 

var store = sessions.NewCookieStore(
	[]byte("new-authentication-key"),
	[]byte("new-encryption-key"),
	[]byte("old-authentication-key"),
	[]byte("old-encryption-key"),
)

New sessions will be saved using the first pair. Old sessions can still be read because the first pair will fail, and the second will be tested. This makes it easy to "rotate" secret keys and still be able to validate existing sessions. Note: for all pairs the encryption key is optional; set it to nil or omit it and and encryption won't be used.

Multiple sessions can be used in the same request, even with different session backends. When this happens, calling Save() on each session individually would be cumbersome, so we have a way to save all sessions at once: it's sessions.Save(). Here's an example: 

var store = sessions.NewCookieStore([]byte("something-very-secret"))

func MyHandler(ctx echo.Context) error {
	// Get a session and set a value.
	session1, _ := store.Get(ctx, "session-one")
	session1.Values["foo"] = "bar"
	// Get another session and set another value.
	session2, _ := store.Get(ctx, "session-two")
	session2.Values[42] = 43
	// Save all sessions.
	sessions.Save(ctx)
	return nil
}

This is possible because when we call Get() from a session store, it adds the session to a common registry. Save() uses it to save all registered sessions.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func CookieSameSite added in v0.2.2 

func CookieSameSite(sameSite string) http.SameSite

func EmptyGobSize added in v0.2.3 

func EmptyGobSize() int

func NewCookie 

func NewCookie(ctx echo.Context, name, value string) *http.Cookie

NewCookie returns an http.Cookie with the options set. It also sets the Expires field calculated based on the MaxAge value, for Internet Explorer compatibility.

func RegisterGob added in v0.2.1 

func RegisterGob(v interface{})

func Save 

func Save(ctx echo.Context) error

Save saves all sessions used during the current request.

func SetCookie 

func SetCookie(ctx echo.Context, key string, value string, args ...interface{})

SetCookie for echo @param:ctx,key,value,maxAge(seconds),path(/),domain,secure,httpOnly,sameSite(lax/strict/default)

func SizeIsEmptyGob added in v0.2.2 

func SizeIsEmptyGob(size int64) bool

Types

type CookieStore 

type CookieStore struct {
	Codecs []securecookie.Codec
}

CookieStore stores sessions using secure cookies.

func NewCookieStore 

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

NewCookieStore returns a new 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.

func (*CookieStore) GenerateID 

func (s *CookieStore) GenerateID(ctx echo.Context, session *Session) (string, error)

func (*CookieStore) Get 

func (s *CookieStore) Get(ctx echo.Context, name string) (*Session, error)

Get returns a session for the given name after adding it to the registry.

It returns a new session if the sessions doesn't exist. Access IsNew on the session to check if it is an existing session or a new one.

It returns a new session and an error if the session exists but could not be decoded.

func (*CookieStore) MaxAge 

func (s *CookieStore) MaxAge(age int)

MaxAge sets the maximum age for the store and the underlying cookie implementation. Individual sessions can be deleted by setting Options.MaxAge = -1 for that session.

func (*CookieStore) New 

func (s *CookieStore) New(ctx echo.Context, name string) (*Session, error)

New returns a session for the given name without adding it to the registry.

The difference between New() and Get() is that calling New() twice will decode the session data twice, while Get() registers and reuses the same decoded session after the first call.

func (*CookieStore) Reload 

func (s *CookieStore) Reload(ctx echo.Context, session *Session) error

func (*CookieStore) Remove added in v0.1.0 

func (s *CookieStore) Remove(sessionID string) error

func (*CookieStore) Save 

func (s *CookieStore) Save(ctx echo.Context, session *Session) error

Save adds a single session to the response.

type FilesystemStore 

type FilesystemStore struct {
	Codecs []securecookie.Codec
	// contains filtered or unexported fields
}

FilesystemStore stores sessions in the filesystem.

It also serves as a reference for custom stores.

This store is still experimental and not well tested. Feedback is welcome.

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.

func (*FilesystemStore) DeleteExpired added in v0.0.2 

func (s *FilesystemStore) DeleteExpired(maxAge float64, emptyDataAge float64) error

func (*FilesystemStore) Get 

func (s *FilesystemStore) Get(ctx echo.Context, name string) (*Session, error)

Get returns a session for the given name after adding it to the registry.

See CookieStore.Get().

func (*FilesystemStore) MaxAge 

func (s *FilesystemStore) MaxAge(age int)

MaxAge sets the maximum age for the store and the underlying cookie implementation. Individual sessions can be deleted by setting Options.MaxAge = -1 for that session.

func (*FilesystemStore) MaxLength 

func (s *FilesystemStore) MaxLength(l int)

MaxLength restricts the maximum length of new sessions to l. If l is 0 there is no limit to the size of a session, use with caution. The default for a new FilesystemStore is 4096.

func (*FilesystemStore) New 

func (s *FilesystemStore) New(ctx echo.Context, name string) (*Session, error)

New returns a session for the given name without adding it to the registry.

See CookieStore.New().

func (*FilesystemStore) Reload 

func (s *FilesystemStore) Reload(ctx echo.Context, session *Session) error

func (*FilesystemStore) Remove added in v0.1.0 

func (s *FilesystemStore) Remove(sessionID string) error

func (*FilesystemStore) Save 

func (s *FilesystemStore) Save(ctx echo.Context, session *Session) error

Save adds a single session to the response.

type IDGenerator 

type IDGenerator interface {
	GenerateID(ctx echo.Context, session *Session) (string, error)
}

IDGenerator session id generator

type MultiError 

type MultiError []error

MultiError stores multiple errors.

Borrowed from the App Engine SDK.

func (MultiError) Error 

func (m MultiError) Error() string

type Registry 

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

Registry stores sessions used during a request.

func GetRegistry 

func GetRegistry(ctx echo.Context) (registry *Registry)

GetRegistry returns a registry instance for the current request.

func (*Registry) Get 

func (s *Registry) Get(store Store, name string) (session *Session, err error)

Get registers and returns a session for the given name and session store.

It returns a new session if there are no sessions registered for the name.

func (*Registry) Save 

func (s *Registry) Save(ctx echo.Context) error

Save saves all sessions registered for the current request.

type Session 

type Session struct {
	// The ID of the session, generated by stores. It should not be used for
	// user data.
	ID string
	// Values contains the user-data for the session.
	Values map[interface{}]interface{}
	IsNew  bool
	// contains filtered or unexported fields
}

Session stores the values and optional configuration for a session.

func NewSession 

func NewSession(store Store, name string) *Session

NewSession is called by session stores to create a new session instance.

func (*Session) AddFlash 

func (s *Session) AddFlash(value interface{}, vars ...string)

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.

func (*Session) Flashes 

func (s *Session) Flashes(vars ...string) []interface{}

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.

func (*Session) Name 

func (s *Session) Name() string

Name returns the name used to register the session.

func (*Session) Reload 

func (s *Session) Reload(ctx echo.Context) error

Reload reload session data

func (*Session) Save 

func (s *Session) Save(ctx echo.Context) error

Save is a convenience method to save this session. It is the same as calling store.Save(request, response, session). You should call Save before writing to the response or returning from the handler.

func (*Session) Store 

func (s *Session) Store() Store

Store returns the session store used to register the session.

type Store 

type Store interface {
	// Get should return a cached session.
	Get(ctx echo.Context, name string) (*Session, error)

	// New should create and return a new session.
	//
	// Note that New should never return a nil session, even in the case of
	// an error if using the Registry infrastructure to cache the session.
	New(ctx echo.Context, name string) (*Session, error)
	Reload(ctx echo.Context, s *Session) error

	// Save should persist session to the underlying store implementation.
	Save(ctx echo.Context, s *Session) error
	// Remove server-side data
	Remove(sessionID string) error
}

Store is an interface for custom session stores.

See CookieStore and FilesystemStore for examples.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.