session

The session middleware provides user session management for Flame instances, supporting various storage backends, including memory, file, PostgreSQL, MySQL, Redis and MongoDB.

You can read source code of this middleware on GitHubsession - 图1open in new window and API documentation on pkg.go.devsession - 图2open in new window.

Installation

The minimum requirement of Go is 1.16.

  1. go get github.com/flamego/session

Storage backends

WARNING

Examples included in this section is to demonstrate the usage of the session middleware, by no means illustrates the idiomatic or even correct way of doing user authentication.

Memory

The session.Sessionersession - 图3open in new window works out-of-the-box with an optional session.Optionssession - 图4open in new window and uses memory as the storage backend:

  1. package main
  3. import (
  4.     "strconv"
  6.     "github.com/flamego/flamego"
  7.     "github.com/flamego/session"
  8. )
  10. func main() {
  11.     f := flamego.Classic()
  12.     f.Use(session.Sessioner())
  13.     f.Get("/set", func(s session.Session) string {
  14.         s.Set("user_id", 123)
  15.         return "Succeed"
  16.     })
  17.     f.Get("/get", func(s session.Session) string {
  18.         userID, ok := s.Get("user_id").(int)
  19.         if !ok || userID <= 0 {
  20.             return "Not authenticated"
  21.         }
  22.         return "Authenticated as " + strconv.Itoa(userID)
  23.     })
  24.     f.Get("/clear", func(s session.Session) string {
  25.         s.Delete("user_id")
  26.         return "Cleared"
  27.     })
  28.     f.Run()
  29. }

Because the memory is volatile, session data do not survive over restarts. Choose other storage backends if you need to persist session data.

File

The session.FileInitersession - 图5open in new window is the function to initialize a file storage backend, used together with session.FileConfigsession - 图6open in new window to customize the backend:

  1. package main
  3. import (
  4.     "os"
  5.     "path/filepath"
  6.     "strconv"
  8.     "github.com/flamego/flamego"
  9.     "github.com/flamego/session"
  10. )
  12. func main() {
  13.     f := flamego.Classic()
  14.     f.Use(session.Sessioner(
  15.         session.Options{
  16.             Initer: session.FileIniter(),
  17.             Config: session.FileConfig{
  18.                 RootDir: filepath.Join(os.TempDir(), "sessions"),
  19.             },
  20.         },
  21.     ))
  22.     f.Get("/set", func(s session.Session) string {
  23.         s.Set("user_id", 123)
  24.         return "Succeed"
  25.     })
  26.     f.Get("/get", func(s session.Session) string {
  27.         userID, ok := s.Get("user_id").(int)
  28.         if !ok || userID <= 0 {
  29.             return "Not authenticated"
  30.         }
  31.         return "Authenticated as " + strconv.Itoa(userID)
  32.     })
  33.     f.Get("/clear", func(s session.Session) string {
  34.         s.Delete("user_id")
  35.         return "Cleared"
  36.     })
  37.     f.Run()
  38. }

PostgreSQL

The postgres.Initersession - 图7open in new window is the function to initialize a PostgreSQL storage backend, used together with postgres.Configsession - 图8open in new window to customize the backend:

  1. package main
  3. import (
  4.     "os"
  5.     "strconv"
  7.     "github.com/flamego/flamego"
  8.     "github.com/flamego/session"
  9.     "github.com/flamego/session/postgres"
  10. )
  12. func main() {
  13.     f := flamego.Classic()
  15.     dsn := os.ExpandEnv("postgres://$PGUSER:$PGPASSWORD@$PGHOST:$PGPORT/$PGDATABASE?sslmode=$PGSSLMODE")
  16.     f.Use(session.Sessioner(
  17.         session.Options{
  18.             Initer: postgres.Initer(),
  19.             Config: postgres.Config{
  20.                 DSN:       dsn,
  21.                 Table:     "sessions",
  22.                 InitTable: true,
  23.             },
  24.         },
  25.     ))
  26.     f.Get("/set", func(s session.Session) string {
  27.         s.Set("user_id", 123)
  28.         return "Succeed"
  29.     })
  30.     f.Get("/get", func(s session.Session) string {
  31.         userID, ok := s.Get("user_id").(int)
  32.         if !ok || userID <= 0 {
  33.             return "Not authenticated"
  34.         }
  35.         return "Authenticated as " + strconv.Itoa(userID)
  36.     })
  37.     f.Get("/clear", func(s session.Session) string {
  38.         s.Delete("user_id")
  39.         return "Cleared"
  40.     })
  41.     f.Run()
  42. }

MySQL

The mysql.Initersession - 图9open in new window is the function to initialize a MySQL storage backend, used together with mysql.Configsession - 图10open in new window to customize the backend:

  1. package main
  3. import (
  4.     "os"
  5.     "strconv"
  7.     "github.com/flamego/flamego"
  8.     "github.com/flamego/session"
  9.     "github.com/flamego/session/mysql"
  10. )
  12. func main() {
  13.     f := flamego.Classic()
  15.     dsn := os.ExpandEnv("$MYSQL_USER:$MYSQL_PASSWORD@tcp($MYSQL_HOST:$MYSQL_PORT)/$MYSQL_DATABASE?charset=utf8&parseTime=true")
  16.     f.Use(session.Sessioner(
  17.         session.Options{
  18.             Initer: mysql.Initer(),
  19.             Config: mysql.Config{
  20.                 DSN:       dsn,
  21.                 Table:     "cache",
  22.                 InitTable: true,
  23.             },
  24.         },
  25.     ))
  26.     f.Get("/set", func(s session.Session) string {
  27.         s.Set("user_id", 123)
  28.         return "Succeed"
  29.     })
  30.     f.Get("/get", func(s session.Session) string {
  31.         userID, ok := s.Get("user_id").(int)
  32.         if !ok || userID <= 0 {
  33.             return "Not authenticated"
  34.         }
  35.         return "Authenticated as " + strconv.Itoa(userID)
  36.     })
  37.     f.Get("/clear", func(s session.Session) string {
  38.         s.Delete("user_id")
  39.         return "Cleared"
  40.     })
  41.     f.Run()
  42. }

Redis

The redis.Initersession - 图11open in new window is the function to initialize a Redis storage backend, used together with redis.Configsession - 图12open in new window to customize the backend:

  1. package main
  3. import (
  4.     "os"
  5.     "strconv"
  7.     "github.com/flamego/flamego"
  8.     "github.com/flamego/session"
  9.     "github.com/flamego/session/redis"
  10. )
  12. func main() {
  13.     f := flamego.Classic()
  15.     f.Use(session.Sessioner(
  16.         session.Options{
  17.             Initer: redis.Initer(),
  18.             Config: redis.Config{
  19.                 Options: &redis.Options{
  20.                     Addr: os.ExpandEnv("$REDIS_HOST:$REDIS_PORT"),
  21.                     DB:   15,
  22.                 },
  23.             },
  24.         },
  25.     ))
  26.     f.Get("/set", func(s session.Session) string {
  27.         s.Set("user_id", 123)
  28.         return "Succeed"
  29.     })
  30.     f.Get("/get", func(s session.Session) string {
  31.         userID, ok := s.Get("user_id").(int)
  32.         if !ok || userID <= 0 {
  33.             return "Not authenticated"
  34.         }
  35.         return "Authenticated as " + strconv.Itoa(userID)
  36.     })
  37.     f.Get("/clear", func(s session.Session) string {
  38.         s.Delete("user_id")
  39.         return "Cleared"
  40.     })
  41.     f.Run()
  42. }

MongoDB

The mongo.Initersession - 图13open in new window is the function to initialize a MongoDB storage backend, used together with mongo.Configsession - 图14open in new window to customize the backend:

  1. package main
  3. import (
  4.     "os"
  5.     "strconv"
  7.     "github.com/flamego/flamego"
  8.     "github.com/flamego/session"
  9.     "github.com/flamego/session/mongo"
  10.     "go.mongodb.org/mongo-driver/mongo/options"
  11. )
  13. func main() {
  14.     f := flamego.Classic()
  16.     f.Use(session.Sessioner(
  17.         session.Options{
  18.             Initer: mongo.Initer(),
  19.             Config: mongo.Config{
  20.                 Options:    options.Client().ApplyURI(os.Getenv("MONGODB_URI")),
  21.                 Database:   os.Getenv("MONGODB_DATABASE"),
  22.                 Collection: "cache",
  23.             },
  24.         },
  25.     ))
  26.     f.Get("/set", func(s session.Session) string {
  27.         s.Set("user_id", 123)
  28.         return "Succeed"
  29.     })
  30.     f.Get("/get", func(s session.Session) string {
  31.         userID, ok := s.Get("user_id").(int)
  32.         if !ok || userID <= 0 {
  33.             return "Not authenticated"
  34.         }
  35.         return "Authenticated as " + strconv.Itoa(userID)
  36.     })
  37.     f.Get("/clear", func(s session.Session) string {
  38.         s.Delete("user_id")
  39.         return "Cleared"
  40.     })
  41.     f.Run()
  42. }

Flash messages

The session middleware provides a mechanism for flash messages, which are always retrieved on the next access of the same session, once and only once (i.e. flash messages get deleted upon retrievals).

A flash message could just be a string in its simplest form:

  1. package main
  3. import (
  4.     "github.com/flamego/flamego"
  5.     "github.com/flamego/session"
  6. )
  8. func main() {
  9.     f := flamego.Classic()
  10.     f.Use(session.Sessioner())
  11.     f.Get("/set", func(s session.Session) string {
  12.         s.SetFlash("This is a flash message")
  13.         return "Succeed"
  14.     })
  15.     f.Get("/get", func(f session.Flash) string {
  16.         s, ok := f.(string)
  17.         if !ok || s == "" {
  18.             return "No flash message"
  19.         }
  20.         return s
  21.     })
  22.     f.Run()
  23. }

The session.Flashsession - 图15open in new window is just the value holder of the flash message, and it could be any type that fits your application’s needs, and doesn’t even have to be the same type for different routes in the same application!

  1. package main
  3. import (
  4.     "fmt"
  6.     "github.com/flamego/flamego"
  7.     "github.com/flamego/session"
  8. )
  10. func main() {
  11.     f := flamego.Classic()
  12.     f.Use(session.Sessioner())
  14.     f.Get("/set-simple", func(s session.Session) string {
  15.         s.SetFlash("This is a flash message")
  16.         return "Succeed"
  17.     })
  18.     f.Get("/get-simple", func(f session.Flash) string {
  19.         s, ok := f.(string)
  20.         if !ok || s == "" {
  21.             return "No flash message"
  22.         }
  23.         return s
  24.     })
  26.     type Flash struct {
  27.         Success string
  28.         Error   string
  29.     }
  30.     f.Get("/set-complex", func(s session.Session) string {
  31.         s.SetFlash(Flash{
  32.             Success: "It worked!",
  33.         })
  34.         return "Succeed"
  35.     })
  36.     f.Get("/get-complex", func(f session.Flash) string {
  37.         s, ok := f.(Flash)
  38.         if !ok {
  39.             return "No flash message"
  40.         }
  41.         return fmt.Sprintf("%#v", s)
  42.     })
  43.     f.Run()
  44. }

In the above example, we use different types of flash messages (string and Flash) for different routes and both of them work!