// New returns a session for the given name without adding it to the registry.
func (m *MongoStore) New(r *http.Request, name string) (
*sessions.Session, error) {
session := sessions.NewSession(m, name)
session.Options = &sessions.Options{
Path: m.Options.Path,
MaxAge: m.Options.MaxAge,
Domain: m.Options.Domain,
Secure: m.Options.Secure,
HttpOnly: m.Options.HttpOnly,
}
session.IsNew = true
var err error
if cook, errToken := m.Token.GetToken(r, name); errToken == nil {
err = securecookie.DecodeMulti(name, cook, &session.ID, m.Codecs...)
if err == nil {
err = m.load(session)
if err == nil {
session.IsNew = false
} else {
err = nil
}
}
}
return session, err
}
func (s *RedisStore) New(r *http.Request, name string) (*sessions.Session, error) {
session := sessions.NewSession(s, name)
session.Options = &(*s.Options)
session.IsNew = true
var err error
if c, errCookie := r.Cookie(name); errCookie == nil {
// TEMP: Check if previous CookieStore
err = securecookie.DecodeMulti(name, c.Value, &session.Values, s.Codecs...)
if err == nil {
err = s.save(session)
if err == nil {
session.IsNew = false
}
} else {
err = securecookie.DecodeMulti(name, c.Value, &session.ID, s.Codecs...)
if err == nil {
err = s.load(session)
if err == nil {
session.IsNew = false
}
}
}
}
return session, err
}
func (s *Store) New(r *http.Request, name string) (*sessions.Session, error) {
sess := sessions.NewSession(s, name)
sess.ID = s.id(r)
RLock(sess)
defer RUnlock(sess)
rows, err := s.Query(`
SELECT key, value
FROM `+SqlTableName+`
WHERE id = $1 AND name = $2
`, []byte(sess.ID), name)
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
var k, v string
if err := rows.Scan(&k, &v); err != nil {
return nil, err
}
sess.Values[k] = v
}
if err := rows.Err(); err != nil {
return nil, err
}
return sess, nil
}
func init() {
sessionSecret = []byte("12345678901234567890123456789012")
sessionStore = sessions.NewCookieStore(sessionSecret)
session = sessions.NewSession(sessionStore, "loginSession")
flag.Parse()
pool = newPool(*redisServer, *redisPassword)
}
// RegenerateSession creates a new session and sets it to current context.
func RegenerateSession(c *web.C) {
o := GetSessionObject(c)
opts := *o.Options
n := sessions.NewSession(o.Store(), o.Name())
n.Options = &opts
n.IsNew = true
c.Env[envKey] = n
o.Options.MaxAge = -1
o.Save(nil, make(noopResponseWriter))
}
func (fs *FakeSessionStore) New(r *http.Request, name string) (*sessions.Session, error) {
if fs.Error {
return nil, fmt.Errorf("Error creating session")
}
s := sessions.NewSession(gothic.Store, name)
s.Values[gothic.SessionName] = `{"session":"exists"}`
s.Values["User"] = "******"
s.Values["Membership"] = map[string]interface{}{"Groups": []interface{}{"fakeGroup1", "fakeGroup2"}}
s.Options = &sessions.Options{MaxAge: 60}
return s, nil
}
// New fetches the session from this store. name is the name of the cookie
// holding the session ID. Get calls New if the session is not already cached
// in the request's context. This implementation of New never returns a non-nil
// error if client is storing sessions data in a *RamSessions instance.
func (s *RAMStore) New(r *http.Request, name string) (*sessions.Session, error) {
session := sessions.NewSession(s, name)
defaultOptions := *s.Options
session.Options = &defaultOptions
session.IsNew = true
if c, errCookie := r.Cookie(name); errCookie == nil {
session.ID = c.Value
if err := s.load(session); err != nil {
return session, err
}
}
return session, nil
}
// ResetSessionData zero initializes the MockSessionStore and then will copy the input session data into it.
func (store *MockSessionStore) ResetSessionData(data map[string]interface{}, sessionName string) {
store.Options = &sessions.Options{
Path: "/",
MaxAge: 86400 * 30,
}
// Initialize the map to empty.
store.Session = sessions.NewSession(store, sessionName)
for key, value := range data {
store.Session.Values[key] = value
}
store.currentSessionName = sessionName
opts := *store.Options
store.Session.Options = &opts
}
// New returns a session for the given name without adding it to the registry.
func (s *RethinkStore) New(r *http.Request, name string) (*sessions.Session, error) {
var err error
session := sessions.NewSession(s, name)
session.Options = &(*s.Options)
session.IsNew = true
if c, errCookie := r.Cookie(name); errCookie == nil {
err = securecookie.DecodeMulti(name, c.Value, &session.ID, s.Codecs...)
if err == nil {
ok, err := s.load(session)
session.IsNew = !(err == nil && ok) // not new if no error and data available
}
}
return session, err
}
// New returns a session for the given name without adding it to the registry.
//
// See gorilla/sessions FilesystemStore.New().
func (s *RediStore) New(r *http.Request, name string) (*sessions.Session, error) {
var err error
session := sessions.NewSession(s, name)
session.Options = &(*s.Options)
session.IsNew = true
if c, errCookie := r.Cookie(name); errCookie == nil {
err = securecookie.DecodeMulti(name, c.Value, &session.ID, s.Codecs...)
if err == nil {
err = s.load(session)
if err == nil {
session.IsNew = false
}
}
}
return session, err
}
// New returns a session for the given name without adding it to the registry.
func (d *dalStore) New(r *http.Request, name string) (*gSessions.Session, error) {
var err error
session := gSessions.NewSession(d, name)
options := *d.options
session.Options = &options
session.IsNew = true
if cook, errToken := d.Token.GetToken(r, name); errToken == nil {
err = securecookie.DecodeMulti(name, cook, &session.ID, d.Codecs...)
if err == nil {
ok, err := d.load(session)
session.IsNew = !(err == nil && ok) // not new if no error and data available
}
}
return session, err
}
// 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 (s *SentinelFailoverStore) New(r *http.Request, name string) (*sessions.Session, error) {
session := sessions.NewSession(s, name)
opts := *s.Options
session.Options = &opts
session.IsNew = true
var err error
if c, errCookie := r.Cookie(name); errCookie == nil {
err = securecookie.DecodeMulti(name, c.Value, &session.ID, s.Codecs...)
if err == nil {
err = s.load(session)
if err == nil {
session.IsNew = false
}
}
}
return session, err
}
// New returns a session for the given name without adding it to the registry.
func (m *mongoStore) New(r *http.Request, name string) (*gSessions.Session, error) {
session := gSessions.NewSession(m, name)
session.Options = &gSessions.Options{
Path: m.options.Path,
MaxAge: m.options.MaxAge,
}
session.IsNew = true
var err error
if cook, errToken := m.Token.GetToken(r, name); errToken == nil {
err = securecookie.DecodeMulti(name, cook, &session.ID, m.Codecs...)
if err == nil {
ok, err := m.load(session)
session.IsNew = !(err == nil && ok) // not new if no error and data available
}
}
return session, err
}
// New returns a new session for the given name w/o adding it to the registry.
func (db *DatabaseStore) New(r *http.Request, name string) (*sessions.Session, error) {
session := sessions.NewSession(db, name)
session.Options = &(*db.Options)
session.IsNew = true
var err error
if c, errCookie := r.Cookie(name); errCookie == nil {
err = securecookie.DecodeMulti(name, c.Value, &session.ID, db.Codecs...)
if err == nil {
err = db.load(session)
if err == nil {
session.IsNew = false
}
}
}
return session, err
}
// New returns a session for the given name without adding it to the registry.
//
// See CookieStore.New().
func (s *MemcacheStore) New(r *http.Request, name string) (*sessions.Session,
error) {
session := sessions.NewSession(s, name)
session.Options = &(*s.Options)
session.IsNew = true
var err error
if cookie, errCookie := r.Cookie(name); errCookie == nil {
err = securecookie.DecodeMulti(name, cookie.Value, &session.ID,
s.Codecs...)
if err == nil {
c := appengine.NewContext(r)
err = loadFromMemcache(c, session)
if err == nil {
session.IsNew = false
}
}
}
return session, err
}
// New returns a session for the given name without adding it to the registry.
//
func (s *MemoryStore) New(r *http.Request, name string) (*sessions.Session, error) {
session := sessions.NewSession(s, name)
opts := *s.Options
session.Options = &opts
session.IsNew = true
var err error
if c, errCookie := r.Cookie(name); errCookie == nil {
Log.Info("MemoryStore reading cookie")
err = securecookie.DecodeMulti(name, c.Value, &session.ID, s.Codecs...)
PanicIf(err)
if err == nil {
Log.Info("MemoryStore read cookie success")
err = s.load(session)
if err == nil {
session.IsNew = false
}
}
}
return session, err
}
func (m *SqliteStore) New(r *http.Request, name string) (*sessions.Session, error) {
session := sessions.NewSession(m, name)
session.Options = &sessions.Options{
Path: m.Options.Path,
MaxAge: m.Options.MaxAge,
}
session.IsNew = true
var err error
if cook, errCookie := r.Cookie(name); errCookie == nil {
err = securecookie.DecodeMulti(name, cook.Value, &session.ID, m.Codecs...)
if err == nil {
err = m.load(session)
if err == nil {
session.IsNew = false
} else {
err = nil
}
}
}
return session, err
}
func (s *leveldbStore) New(r *http.Request, name string) (*sessions.Session, error) {
session := sessions.NewSession(s, name)
opts := *s.options
// if remember, set MaxAge 1 Year
opts.MaxAge = 0
if "on" == r.Form.Get("remember") {
opts.MaxAge = 86400 * 365
}
session.Options = &opts
session.IsNew = true
var err error
if c, errCookie := r.Cookie(name); errCookie == nil {
err = securecookie.DecodeMulti(name, c.Value, &session.ID, s.Codecs...)
if err == nil {
err = s.load(session)
if err != nil {
session.IsNew = true
return session, err
}
}
}
return session, err
}
func (s *Store) New(r *http.Request, name string) (*sessions.Session, error) {
session := sessions.NewSession(s, name)
// Copy default options for new session if we have
var opts = *DefaultSessionOpts
if s.Options != nil {
opts = *s.Options
}
session.Options = &opts
session.IsNew = true
if c, errCookie := r.Cookie(name); errCookie == nil {
decodeErr := securecookie.DecodeMulti(name, c.Value, &session.ID, s.Codecs...)
if decodeErr == nil {
err := s.load(session)
if err == nil {
session.IsNew = false
}
}
}
return session, nil
}
// New returns a new session for the given name w/o adding it to the registry.
func (db *PGStore) New(r *http.Request, name string) (*sessions.Session, error) {
session := sessions.NewSession(db, name)
if session == nil {
return session, nil
}
opts := *db.Options
session.Options = &(opts)
session.IsNew = true
var err error
if c, errCookie := r.Cookie(name); errCookie == nil {
err = securecookie.DecodeMulti(name, c.Value, &session.ID, db.Codecs...)
if err == nil {
err = db.load(session)
if err == nil {
session.IsNew = false
}
}
}
db.MaxAge(db.Options.MaxAge)
return session, err
}
func (p ProviderStore) New(r *http.Request, name string) (*sessions.Session, error) {
s := sessions.NewSession(p, name)
p.Store[r] = s
return s, nil
}
func (tss *testSessionStore) New(r *http.Request, sessName string) (*sessions.Session, error) {
if tss.session == nil {
tss.session = sessions.NewSession(tss, sessName)
}
return tss.session, nil
}