6.3 Session storage

We introduced a simple session manager’s working principles in the previous section, and among other things, we defined a session storage interface. In this section, I’m going to show you an example of a memory based session storage engine that implements this interface. You can tailor this to other forms of session storage as well.

  1.     package memory
  3.     import (
  4.         "container/list"
  5.         "github.com/astaxie/session"
  6.         "sync"
  7.         "time"
  8.     )
  10.     var pder = &Provider{list: list.New()}
  12.     type SessionStore struct {
  13.         sid          string                      // unique session id
  14.         timeAccessed time.Time                   // last access time
  15.         value        map[interface{}]interface{} // session value stored inside
  16.     }
  18.     func (st *SessionStore) Set(key, value interface{}) error {
  19.         st.value[key] = value
  20.         pder.SessionUpdate(st.sid)
  21.         return nil
  22.     }
  24.     func (st *SessionStore) Get(key interface{}) interface{} {
  25.         pder.SessionUpdate(st.sid)
  26.         if v, ok := st.value[key]; ok {
  27.             return v
  28.         } else {
  29.             return nil
  30.         }
  31.         return nil
  32.     }
  34.     func (st *SessionStore) Delete(key interface{}) error {
  35.         delete(st.value, key)
  36.         pder.SessionUpdate(st.sid)
  37.         return nil
  38.     }
  40.     func (st *SessionStore) SessionID() string {
  41.         return st.sid
  42.     }
  44.     type Provider struct {
  45.         lock     sync.Mutex               // lock
  46.         sessions map[string]*list.Element // save in memory
  47.         list     *list.List               // gc
  48.     }
  50.     func (pder *Provider) SessionInit(sid string) (session.Session, error) {
  51.         pder.lock.Lock()
  52.         defer pder.lock.Unlock()
  53.         v := make(map[interface{}]interface{}, 0)
  54.         newsess := &SessionStore{sid: sid, timeAccessed: time.Now(), value: v}
  55.         element := pder.list.PushBack(newsess)
  56.         pder.sessions[sid] = element
  57.         return newsess, nil
  58.     }
  60.     func (pder *Provider) SessionRead(sid string) (session.Session, error) {
  61.         if element, ok := pder.sessions[sid]; ok {
  62.             return element.Value.(*SessionStore), nil
  63.         } else {
  64.             sess, err := pder.SessionInit(sid)
  65.             return sess, err
  66.         }
  67.         return nil, nil
  68.     }
  70.     func (pder *Provider) SessionDestroy(sid string) error {
  71.         if element, ok := pder.sessions[sid]; ok {
  72.             delete(pder.sessions, sid)
  73.             pder.list.Remove(element)
  74.             return nil
  75.         }
  76.         return nil
  77.     }
  79.     func (pder *Provider) SessionGC(maxlifetime int64) {
  80.         pder.lock.Lock()
  81.         defer pder.lock.Unlock()
  83.         for {
  84.             element := pder.list.Back()
  85.             if element == nil {
  86.                 break
  87.             }
  88.             if (element.Value.(*SessionStore).timeAccessed.Unix() + maxlifetime) < time.Now().Unix() {
  89.                 pder.list.Remove(element)
  90.                 delete(pder.sessions, element.Value.(*SessionStore).sid)
  91.             } else {
  92.                 break
  93.             }
  94.         }
  95.     }
  97.     func (pder *Provider) SessionUpdate(sid string) error {
  98.         pder.lock.Lock()
  99.         defer pder.lock.Unlock()
  100.         if element, ok := pder.sessions[sid]; ok {
  101.             element.Value.(*SessionStore).timeAccessed = time.Now()
  102.             pder.list.MoveToFront(element)
  103.             return nil
  104.         }
  105.         return nil
  106.     }
  108.     func init() {
  109.         pder.sessions = make(map[string]*list.Element, 0)
  110.         session.Register("memory", pder)
  111.     }

The above example implements a memory based session storage mechanism. It uses its init() function to register this storage engine to the session manager. So how do we register this engine from our main program?

  1.     import (
  2.         "github.com/astaxie/session"
  3.         _ "github.com/astaxie/session/providers/memory"
  4.     )

We use the blank import mechanism (which will invoke the package’s init() function automatically) to register this engine to a session manager. We then use the following code to initialize the session manager:

  1.     var globalSessions *session.Manager
  3.     // initialize in init() function
  4.     func init() {
  5.         globalSessions, _ = session.NewManager("memory", "gosessionid", 3600)
  6.         go globalSessions.GC()
  7.     }