Version 3.0.0-beta cleaned

sessions/providers/redis/redisstore.go

@@ -0,0 +1,176 @@
+package redis
+
+import (
+	"time"
+
+	"github.com/kataras/iris/sessions/store"
+	"github.com/kataras/iris/utils"
+)
+
+/*Notes only for me
+--------
+Here we are setting a structure which keeps the current session's values setted by store.Set(key,value)
+this is the RedisValue struct.
+if noexists
+	RedisValue := RedisValue{sessionid,values)
+
+RedisValue.values[thekey]=thevalue
+
+
+service.Set(store.sid,RedisValue)
+
+because we are using the same redis service for all sessions, and this is the best way to separate them,
+without prefix and all that which I tried and failed to deserialize them correctly if the value is string...
+so again we will keep the current server's sessions into memory
+and fetch them(the sessions) from the redis at each first session run. Yes this is the fastest way to get/set a session
+and at the same time they are keep saved to the redis and the GC will cleanup the memory after a while like we are doing
+with the memory provider. Or just have a values field inside the Store and use just it, yes better simpler approach.
+Ok then, let's convert it again.
+*/
+
+// Values is just a type of a map[interface{}]interface{}
+type Values map[interface{}]interface{}
+
+// Store the redis session store
+type Store struct {
+	sid                string
+	lastAccessedTime   time.Time
+	values             Values
+	cookieLifeDuration time.Duration //used on .Set-> SETEX on redis
+}
+
+var _ store.IStore = &Store{}
+
+// NewStore creates and returns a new store based on the session id(string) and the cookie life duration (time.Duration)
+func NewStore(sid string, cookieLifeDuration time.Duration) *Store {
+	s := &Store{sid: sid, lastAccessedTime: time.Now(), cookieLifeDuration: cookieLifeDuration}
+	//fetch the values from this session id and copy-> store them
+	val, err := redis.GetBytes(sid)
+	if err == nil {
+		err = utils.DeserializeBytes(val, &s.values)
+		if err != nil {
+			//if deserialization failed
+			s.values = Values{}
+		}
+
+	}
+	if s.values == nil {
+		//if key/sid wasn't found or was found but no entries in it(L72)
+		s.values = Values{}
+	}
+
+	return s
+}
+
+// serialize the values to be stored as strings inside the Redis, we panic at any serialization error here
+func serialize(values Values) []byte {
+	val, err := utils.SerializeBytes(values)
+	if err != nil {
+		panic("On redisstore.serialize: " + err.Error())
+	}
+
+	return val
+}
+
+// update updates the real redis store
+func (s *Store) update() {
+	go redis.Set(s.sid, serialize(s.values), s.cookieLifeDuration.Seconds()) //set/update all the values, in goroutine
+}
+
+// GetAll returns all values
+func (s *Store) GetAll() map[interface{}]interface{} {
+	return s.values
+}
+
+// VisitAll loop each one entry and calls the callback function func(key,value)
+func (s *Store) VisitAll(cb func(k interface{}, v interface{})) {
+	for key := range s.values {
+		cb(key, s.values[key])
+	}
+}
+
+// Get returns the value of an entry by its key
+func (s *Store) Get(key interface{}) interface{} {
+	Provider.Update(s.sid)
+
+	if value, found := s.values[key]; found {
+		return value
+	}
+
+	return nil
+}
+
+// GetString same as Get but returns as string, if nil then returns an empty string
+func (s *Store) GetString(key interface{}) string {
+	if value := s.Get(key); value != nil {
+		if v, ok := value.(string); ok {
+			return v
+		}
+	}
+
+	return ""
+}
+
+// GetInt same as Get but returns as int, if nil then returns -1
+func (s *Store) GetInt(key interface{}) int {
+	if value := s.Get(key); value != nil {
+		if v, ok := value.(int); ok {
+			return v
+		}
+	}
+
+	return -1
+}
+
+// Set fills the session with an entry, it receives a key and a value
+// returns an error, which is always nil
+func (s *Store) Set(key interface{}, value interface{}) error {
+	s.values[key] = value
+	Provider.Update(s.sid)
+
+	s.update()
+	return nil
+}
+
+// Delete removes an entry by its key
+// returns an error, which is always nil
+func (s *Store) Delete(key interface{}) error {
+	delete(s.values, key)
+	Provider.Update(s.sid)
+	s.update()
+	return nil
+}
+
+// Clear removes all entries
+// returns an error, which is always nil
+func (s *Store) Clear() error {
+	//we are not using the Redis.Delete, I made so work for nothing.. we wanted only the .Set at the end...
+	for key := range s.values {
+		delete(s.values, key)
+	}
+
+	Provider.Update(s.sid)
+	s.update()
+	return nil
+}
+
+// ID returns the session id
+func (s *Store) ID() string {
+	return s.sid
+}
+
+// LastAccessedTime returns the last time this session has been used
+func (s *Store) LastAccessedTime() time.Time {
+	return s.lastAccessedTime
+}
+
+// SetLastAccessedTime updates the last accessed time
+func (s *Store) SetLastAccessedTime(lastacc time.Time) {
+	s.lastAccessedTime = lastacc
+}
+
+// Destroy deletes entirely the session, from the memory, the client's cookie and the store
+func (s *Store) Destroy() {
+	// remove the whole  value which is the s.values from real redis
+	redis.Delete(s.sid)
+}