All files and memory storage tests pass

session.go

@@ -143,7 +143,7 @@ func (manager *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (se
 			return nil, fmt.Errorf("Session cookie decode error: %v", err)
 		}
 		if session, err = manager.provider.Load(sid); err != nil {
-			return nil, fmt.Errorf("Session provider read error: %w", err)
+			return nil, fmt.Errorf("Session provider load error: %w", err)
 		}
 	}
 	return
@@ -153,7 +153,7 @@ func (manager *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (se
 func (manager *Manager) SessionDestroy(w http.ResponseWriter, r *http.Request) (err error) {
 	var cookie *http.Cookie
 	if cookie, err = r.Cookie(manager.sessOpts.CookieName); err != nil || cookie.Value == "" {
-		return fmt.Errorf("Get cookie from request failed: %v", err)
+		return fmt.Errorf("get cookie from request failed: %v", err)
 	}
 
 	manager.provider.Destroy(cookie.Value)

storage/files/files.go

@@ -5,13 +5,13 @@ import (
 	"bytes"
 	"container/list"
 	"encoding/gob"
-	"errors"
 	"fmt"
+	"log"
 	"os"
+	"path"
 	"sync"
 	"time"
 
-	//"git.mtux.eu/darkgopher/session"
 	"git.mtux.eu/darkgopher/session"
 	"github.com/djherbis/atime"
 )
@@ -21,10 +21,10 @@ const (
 	sessExt string = "gsd"
 )
 
-var pder *ProviderFiles
+var pder = &ProviderFiles{li: list.New()}
 
 func init() {
-	pder = &ProviderFiles{}
+	pder.sessions = make(map[string]*list.Element, 0)
 	session.Register("files", pder)
 }
 
@@ -36,8 +36,8 @@ func ckdirpath(sid string) string {
 // ProviderFiles implement filesystem session provider
 type ProviderFiles struct {
 	lock     sync.Mutex
+	li       *list.List //or gc
 	sessions map[string]*list.Element
-	list     *list.List //or gc
 	sessPath string
 }
 
@@ -56,15 +56,19 @@ func (pder *ProviderFiles) SetParams(p any) (err error) {
 	if p != nil {
 		if s, ok := p.(string); ok {
 			pder.sessPath = s
+			sdir := path.Join(pder.sessPath, sessDir)
+			if err = os.MkdirAll(sdir, 0o700); err != nil {
+				return fmt.Errorf("make session directory path: %s failed: %v", sdir, err)
+			}
 			return
 		}
 		return fmt.Errorf("parameter for files session provider is not string")
 	}
-	return fmt.Errorf("parameter for files session provider must be provided, not nil")
+	return fmt.Errorf("parameter for files session provider must be provided")
 }
 
 // Init create empty session file if not exists and retturn *Session
-func (pder *ProviderFiles) Init(sid string) (sess session.Session, err error) {
+func (pder *ProviderFiles) Init(sid string) (ses session.Session, err error) {
 	pder.lock.Lock()
 	defer pder.lock.Unlock()
 	var fd *os.File
@@ -73,8 +77,8 @@ func (pder *ProviderFiles) Init(sid string) (sess session.Session, err error) {
 		return nil, fmt.Errorf("create session file: %s failed with err: %w", ckf, err)
 	}
 	defer fd.Close()
-	sess = &SessionFile{sid}
+	sess := &SessionFile{sid}
-	ssel := pder.list.PushBack(sess)
+	ssel := pder.li.PushBack(sess)
 	pder.sessions[sid] = ssel
 	return sess, nil
 }
@@ -84,7 +88,9 @@ func (pder *ProviderFiles) Load(sid string) (sess session.Session, err error) {
 	pder.lock.Lock()
 	defer pder.lock.Unlock()
 	if pder.Exists(sid) {
-		return pder.sessions[sid].Value.(*SessionFile), nil
+		if sesel, ok := pder.sessions[sid]; ok {
+			return sesel.Value.(*SessionFile), nil
+		}
 	}
 	return pder.Init(sid)
 }
@@ -96,7 +102,7 @@ func (pder *ProviderFiles) Destroy(sid string) (err error) {
 	if pder.Exists(sid) {
 		ssel := pder.sessions[sid]
 		delete(pder.sessions, sid)
-		pder.list.Remove(ssel)
+		pder.li.Remove(ssel)
 		return os.Remove(ckdirpath(sid))
 	}
 	return
@@ -108,7 +114,7 @@ func (pder *ProviderFiles) ChangeID(oldsid, newsid string) (err error) {
 		ckfold := ckdirpath(oldsid)
 		ckfnew := ckdirpath(newsid)
 		if err = os.Rename(ckfold, ckfnew); err != nil {
-			return fmt.Errorf("Rename cookie file: %s to: %s failed: %v", ckfold, ckfnew, err)
+			return fmt.Errorf("rename cookie file: %s to: %s failed: %v", ckfold, ckfnew, err)
 		}
 		ssel.Value.(*SessionFile).sid = newsid
 		delete(pder.sessions, oldsid)
@@ -117,21 +123,29 @@ func (pder *ProviderFiles) ChangeID(oldsid, newsid string) (err error) {
 	return
 }
 
-// Exists check if session sid exists in storage
+// Exists return true if session with sid exists
+func (pder *ProviderFiles) Exists(sid string) (ex bool) {
+	if _, ex := pder.sessions[sid]; ex {
+		return ex
+	}
+	return
+}
+
+/*// Exists check if session sid exists in storage
 func (pder *ProviderFiles) Exists(sid string) bool {
 	ckf := ckdirpath(sid)
 	if _, err := os.Stat(ckf); errors.Is(err, os.ErrExist) {
 		return false
 	}
 	return true
-}
+}*/
 
 // GC periodically remove old sessions rom storages
 func (pder *ProviderFiles) GC(maxlifetime int64) {
 	pder.lock.Lock()
 	defer pder.lock.Unlock()
 	for {
-		ssel := pder.list.Back()
+		ssel := pder.li.Back()
 		if ssel == nil {
 			break
 		}
@@ -142,10 +156,13 @@ func (pder *ProviderFiles) GC(maxlifetime int64) {
 			continue
 		}
 		if at.UnixMilli()+(maxlifetime*session.MilisPerSec()) < time.Now().UnixMilli() {
-			pder.list.Remove(ssel)
+			log.Printf("GC remove session: %s atime: %v now: %v", sid, at, time.Now())
+			pder.li.Remove(ssel)
 			delete(pder.sessions, sid)
 			ckf := ckdirpath(sid)
 			os.Remove(ckf)
+		} else {
+			break
 		}
 	}
 }
@@ -159,6 +176,7 @@ type SessionFile struct {
 func (sf *SessionFile) loadFromFile() (data map[any]any, err error) {
 	var sb []byte
 	sfp := ckdirpath(sf.sid)
+	data = make(map[any]any, 0)
 	if sb, err = os.ReadFile(sfp); err != nil {
 		return nil, fmt.Errorf("session file: %s read error: %v", sf.sid, err)
 	}
@@ -166,9 +184,12 @@ func (sf *SessionFile) loadFromFile() (data map[any]any, err error) {
 	if _, err = gobdata.Write(sb); err != nil {
 		return nil, fmt.Errorf("load session file: %s into buffer err: %v", sf.sid, err)
 	}
+	if gobdata.Len() == 0 {
+		return data, nil
+	}
 	dec := gob.NewDecoder(&gobdata)
 	if err = dec.Decode(&data); err != nil {
-		return nil, fmt.Errorf("decode gob data from file: %s error: %v", sf.sid, err)
+		return nil, fmt.Errorf("decode gob data: %d from file: %s error: %v", gobdata.Len(), sf.sid, err)
 	}
 	return
 }

storage/memory/memory.go

@@ -10,7 +10,7 @@ import (
 	"git.mtux.eu/darkgopher/session/util"
 )
 
-var pder = &ProviderMemory{list: list.New()}
+var pder = &ProviderMemory{li: list.New()}
 
 func init() {
 	pder.sessions = make(map[string]*list.Element, 0)
@@ -21,7 +21,7 @@ func init() {
 type ProviderMemory struct {
 	lock     sync.Mutex
 	sessions map[string]*list.Element //save to RAM
-	list     *list.List               //for GC
+	li       *list.List               //for GC
 }
 
 func (pder *ProviderMemory) updateAtime(sid string) {
@@ -29,7 +29,7 @@ func (pder *ProviderMemory) updateAtime(sid string) {
 	defer pder.lock.Unlock()
 	if ssel, ok := pder.sessions[sid]; ok {
 		ssel.Value.(*SessionMemory).atime = time.Now()
-		pder.list.MoveToFront(ssel)
+		pder.li.MoveToFront(ssel)
 	}
 }
 
@@ -44,25 +44,17 @@ func (pder *ProviderMemory) Init(sid string) (ses session.Session, err error) {
 	defer pder.lock.Unlock()
 	data := make(map[any]any, 0)
 	sess := &SessionMemory{sid, time.Now(), data}
-	sessel := pder.list.PushBack(sess)
+	sessel := pder.li.PushBack(sess)
 	pder.sessions[sid] = sessel
 	return sess, nil
 }
 
-// Exists return true if session with sid exists
-func (pder *ProviderMemory) Exists(sid string) (ex bool) {
-	if _, ex := pder.sessions[sid]; ex {
-		return ex
-	}
-	return
-}
-
 // Load return existing unexpired session or create new
 func (pder *ProviderMemory) Load(sid string) (ses session.Session, err error) {
 	pder.lock.Lock()
 	defer pder.lock.Unlock()
-	if ssel, ok := pder.sessions[sid]; ok {
+	if pder.Exists(sid) {
-		return ssel.Value.(*SessionMemory), nil
+		return pder.sessions[sid].Value.(*SessionMemory), nil
 	}
 	return pder.Init(sid)
 }
@@ -72,7 +64,7 @@ func (pder *ProviderMemory) Destroy(sid string) (err error) {
 	pder.lock.Lock()
 	defer pder.lock.Unlock()
 	if ssel, ok := pder.sessions[sid]; ok {
-		pder.list.Remove(ssel)
+		pder.li.Remove(ssel)
 		delete(pder.sessions, sid)
 		return nil
 	}
@@ -91,17 +83,25 @@ func (pder *ProviderMemory) ChangeID(oldsid, newsid string) (err error) {
 	return
 }
 
+// Exists return true if session with sid exists
+func (pder *ProviderMemory) Exists(sid string) (ex bool) {
+	if _, ex := pder.sessions[sid]; ex {
+		return ex
+	}
+	return
+}
+
 // GC iterate all sessions and delete expired
 func (pder *ProviderMemory) GC(maxlifetime int64) {
 	pder.lock.Lock()
 	defer pder.lock.Unlock()
 	for {
-		ssel := pder.list.Back()
+		ssel := pder.li.Back()
 		if ssel == nil {
 			break
 		}
 		if ssel.Value.(*SessionMemory).atime.UnixMilli()+(maxlifetime*session.MilisPerSec()) < time.Now().UnixMilli() {
-			pder.list.Remove(ssel)
+			pder.li.Remove(ssel)
 			delete(pder.sessions, ssel.Value.(*SessionMemory).sid)
 		} else {
 			break

tests/t_test.go

@@ -22,11 +22,11 @@ import (
 	"golang.org/x/net/publicsuffix"
 
 	//all impls imports here ...
+	_ "git.mtux.eu/darkgopher/session/storage/files"
 	_ "git.mtux.eu/darkgopher/session/storage/memory"
 )
 
 const sid = "sid"
-const lifet = 180
 
 var sm *session.Manager         //current session impl.
 var testserver *httptest.Server //httptest server h2
@@ -65,9 +65,9 @@ func (ts *TestServer) destroySession(w http.ResponseWriter, r *http.Request) {
 	if _, err = sm.SessionStart(w, r); err != nil {
 		io.WriteString(w, err.Error())
 	}
-	if err = sm.SessionDestroy(w, r); err != nil {
+	/*if err = sm.SessionDestroy(w, r); err != nil {
 		io.WriteString(w, err.Error())
-	}
+	}*/
 	io.WriteString(w, "OK")
 }
 
@@ -209,7 +209,7 @@ func CheckRequestOK(path string) (err error) {
 		return fmt.Errorf("Make request: %s failed: %v", path, err)
 	}
 	if string(res) != "OK" {
-		return fmt.Errorf("Response from test request not OK, but: %s", res)
+		return fmt.Errorf("Response not 'OK' is: %s", res)
 	}
 	return
 }
@@ -282,18 +282,23 @@ func t9(t *testing.T) {
 func TestRunAll(t *testing.T) {
 	ts := &TestServer{}
 	ts.Serve()
-	//all impls. subtests
-	for _, pn := range session.ProviderNames() {
-		var err error
-		jar, _ := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
-		testclient.Jar = jar
 
 	sessopts := &session.SessOpts{
 		CookieName:  sid,
 		MaxLifetime: 180, Ssl: true,
 	}
 
-		if sm, err = session.NewManager(pn, sessopts, nil); err != nil {
+	addopts := map[string]any{
+		"memory": nil, "files": "/tmp",
+	}
+	//all impls. subtests
+	for _, pn := range session.ProviderNames() {
+		var err error
+		jar, _ := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+		testclient.Jar = jar
+
+		adopt := addopts[pn]
+		if sm, err = session.NewManager(pn, sessopts, adopt); err != nil {
 			t.Errorf("Session provider %s failed initialize err: %v", pn, err)
 		}