Sessions are now in full sync with the registered database, on acquire(init), set, get, delete, clear, visit, len, release(destroy) as requested by almost everyone. https://github.com/kataras/iris/issues/969

Former-commit-id: 49fcdb93106a78f0a24ad3fb4d8725e35e98451a

sessions/sessiondb/redis/database.go

@@ -14,9 +14,17 @@ type Database struct {
 	redis *service.Service
 }
 
+var _ sessions.Database = (*Database)(nil)
+
 // New returns a new redis database.
 func New(cfg ...service.Config) *Database {
 	db := &Database{redis: service.New(cfg...)}
+	db.redis.Connect()
+	_, err := db.redis.PingPong()
+	if err != nil {
+		golog.Debugf("error connecting to redis: %v", err)
+		return nil
+	}
 	runtime.SetFinalizer(db, closeDB)
 	return db
 }
@@ -26,73 +34,119 @@ func (db *Database) Config() *service.Config {
 	return db.redis.Config
 }
 
-// Async is DEPRECATED
-// if it was true then it could use different to update the back-end storage, now it does nothing.
-func (db *Database) Async(useGoRoutines bool) *Database {
-	return db
+// Acquire receives a session's lifetime from the database,
+// if the return value is LifeTime{} then the session manager sets the life time based on the expiration duration lives in configuration.
+func (db *Database) Acquire(sid string, expires time.Duration) sessions.LifeTime {
+	seconds, hasExpiration, found := db.redis.TTL(sid)
+	if !found {
+		// not found, create an entry with ttl and return an empty lifetime, session manager will do its job.
+		if err := db.redis.Set(sid, sid, int64(expires.Seconds())); err != nil {
+			golog.Debug(err)
+		}
+
+		return sessions.LifeTime{} // session manager will handle the rest.
+	}
+
+	if !hasExpiration {
+		return sessions.LifeTime{}
+
+	}
+
+	return sessions.LifeTime{Time: time.Now().Add(time.Duration(seconds) * time.Second)}
 }
 
-// Load loads the values to the underline.
-func (db *Database) Load(sid string) (storeDB sessions.RemoteStore) {
-	// values := make(map[string]interface{})
+const delim = "_"
 
-	if !db.redis.Connected { //yes, check every first time's session for valid redis connection
-		db.redis.Connect()
-		_, err := db.redis.PingPong()
-		if err != nil {
-			golog.Errorf("redis database error on connect: %v", err)
-			return
-		}
+func makeKey(sid, key string) string {
+	return sid + delim + key
+}
+
+// Set sets a key value of a specific session.
+// Ignore the "immutable".
+func (db *Database) Set(sid string, lifetime sessions.LifeTime, key string, value interface{}, immutable bool) {
+	valueBytes, err := sessions.DefaultTranscoder.Marshal(value)
+	if err != nil {
+		golog.Error(err)
+		return
 	}
 
-	// fetch the values from this session id and copy-> store them
-	storeMaybe, err := db.redis.Get(sid)
-	// exists
-	if err == nil {
-		storeB, ok := storeMaybe.([]byte)
-		if !ok {
-			golog.Errorf("something wrong, store should be stored as []byte but stored as %#v", storeMaybe)
-			return
-		}
-
-		storeDB, err = sessions.DecodeRemoteStore(storeB) // decode the whole value, as a remote store
-		if err != nil {
-			golog.Errorf(`error while trying to load session values(%s) from redis:
-			the retrieved value is not a sessions.RemoteStore type, please report that as bug, that should never occur: %v`,
-				sid, err)
-		}
+	if err = db.redis.Set(makeKey(sid, key), valueBytes, int64(lifetime.DurationUntilExpiration().Seconds())); err != nil {
+		golog.Debug(err)
 	}
+}
 
+// Get retrieves a session value based on the key.
+func (db *Database) Get(sid string, key string) (value interface{}) {
+	db.get(makeKey(sid, key), &value)
 	return
 }
 
-// Sync syncs the database.
-func (db *Database) Sync(p sessions.SyncPayload) {
-	db.sync(p)
-}
-
-func (db *Database) sync(p sessions.SyncPayload) {
-	if p.Action == sessions.ActionDestroy {
-		db.redis.Delete(p.SessionID)
-		return
-	}
-	storeB, err := p.Store.Serialize()
+func (db *Database) get(key string, outPtr interface{}) {
+	data, err := db.redis.Get(key)
 	if err != nil {
-		golog.Error("error while encoding the remote session store")
+		// not found.
 		return
 	}
 
-	// not expire if zero
-	seconds := 0
-
-	if lifetime := p.Store.Lifetime; !lifetime.IsZero() {
-		seconds = int(lifetime.Sub(time.Now()).Seconds())
+	if err = sessions.DefaultTranscoder.Unmarshal(data.([]byte), outPtr); err != nil {
+		golog.Debugf("unable to unmarshal value of key: '%s': %v", key, err)
 	}
-
-	db.redis.Set(p.SessionID, storeB, seconds)
 }
 
-// Close shutdowns the redis connection.
+func (db *Database) keys(sid string) []string {
+	keys, err := db.redis.GetKeys(sid + delim)
+	if err != nil {
+		golog.Debugf("unable to get all redis keys of session '%s': %v", sid, err)
+		return nil
+	}
+
+	return keys
+}
+
+// Visit loops through all session keys and values.
+func (db *Database) Visit(sid string, cb func(key string, value interface{})) {
+	keys := db.keys(sid)
+	for _, key := range keys {
+		var value interface{} // new value each time, we don't know what user will do in "cb".
+		db.get(key, &value)
+		cb(key, value)
+	}
+}
+
+// Len returns the length of the session's entries (keys).
+func (db *Database) Len(sid string) (n int) {
+	return len(db.keys(sid))
+}
+
+// Delete removes a session key value based on its key.
+func (db *Database) Delete(sid string, key string) (deleted bool) {
+	err := db.redis.Delete(makeKey(sid, key))
+	if err != nil {
+		golog.Error(err)
+	}
+	return err == nil
+}
+
+// Clear removes all session key values but it keeps the session entry.
+func (db *Database) Clear(sid string) {
+	keys := db.keys(sid)
+	for _, key := range keys {
+		if err := db.redis.Delete(key); err != nil {
+			golog.Debugf("unable to delete session '%s' value of key: '%s': %v", sid, key, err)
+		}
+	}
+}
+
+// Release destroys the session, it clears and removes the session entry,
+// session manager will create a new session ID on the next request after this call.
+func (db *Database) Release(sid string) {
+	// clear all $sid-$key.
+	db.Clear(sid)
+	// and remove the $sid.
+	db.redis.Delete(sid)
+}
+
+// Close terminates the redis connection.
 func (db *Database) Close() error {
 	return closeDB(db)
 }