From d83b751fb11212966457fab2de516a881179f8f4 Mon Sep 17 00:00:00 2001 From: Johan Lindh Date: Wed, 4 Nov 2026 06:43:56 +0100 Subject: [PATCH 1/7] feat(session): refresh grace for HTTP activity --- doc/sessions.md | 5 +++ session.go | 20 +++++++++++ session_test.go | 96 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 121 insertions(+) diff --git a/doc/sessions.md b/doc/sessions.md index 68c81d75..b3346c19 100644 --- a/doc/sessions.md +++ b/doc/sessions.md @@ -64,6 +64,11 @@ grace deadline; detaching a claimed Request refreshes it, while detaching an unclaimed Request leaves it unchanged. Maintenance removes expired Sessions without attached Requests. Cookies have no explicit expiry or MaxAge. +An application using a Session for authenticated HTTP pages without a WebSocket +can call `Session.Touch` after authorizing each request. It extends the grace +window for a current live Session and returns false for an expired, closed, or +replaced Session. Authorization remains the application's responsibility. + `Session.Reload` asks its active pages to reload. `Session.Close` invalidates the Session and queues reloads for its associated pages, including those still waiting to connect. It leaves stored data intact; call `Session.Clear` to remove diff --git a/session.go b/session.go index 29afd899..43eae09f 100644 --- a/session.go +++ b/session.go @@ -143,6 +143,26 @@ func (sess *Session) Set(key string, value any) { } } +// Touch extends the one-minute grace window for a current, live Session. +// It supports authenticated HTTP requests that do not attach a WebSocket. +// An expired, closed, or replaced Session cannot be revived. A concurrent +// Close may invalidate the Session immediately after Touch returns. +func (sess *Session) Touch() bool { + if sess == nil { + return false + } + jw := sess.jw + jw.mu.RLock() + defer jw.mu.RUnlock() + sess.mu.Lock() + defer sess.mu.Unlock() + if jw.sessions[sess.sessionID] != sess || sess.isDeadLocked() { + return false + } + sess.deadline = time.Now().Add(sessionGrace) + return true +} + // ID returns the session ID, a 64-bit random value. func (sess *Session) ID() (id uint64) { if sess != nil { diff --git a/session_test.go b/session_test.go index 187489cd..3929fbe9 100644 --- a/session_test.go +++ b/session_test.go @@ -2097,6 +2097,102 @@ func TestSession_GetSessionExpiredBeforeCleanup(t *testing.T) { } } +func TestSession_TouchExtendsHTTPGraceAndRejectsExpiry(t *testing.T) { + jw, err := New() + if err != nil { + t.Fatal(err) + } + defer jw.Close() + + r := httptest.NewRequest(http.MethodGet, "http://example.test/", nil) + sess := jw.NewSession(httptest.NewRecorder(), r) + if sess == nil { + t.Fatal("expected session") + } + sess.mu.Lock() + soon := time.Now().Add(time.Second) + sess.deadline = soon + sess.mu.Unlock() + if !sess.Touch() { + t.Fatal("current HTTP session was not touched") + } + sess.mu.RLock() + refreshed := sess.deadline + sess.mu.RUnlock() + if !refreshed.After(soon.Add(50*time.Second)) || jw.GetSession(r) != sess { + t.Fatalf("Touch did not extend grace: old=%s new=%s", soon, refreshed) + } + + sess.mu.Lock() + sess.deadline = time.Now().Add(-time.Second) + sess.mu.Unlock() + if sess.Touch() || jw.GetSession(r) != nil { + t.Fatal("Touch revived an expired session") + } + var absent *Session + if absent.Touch() { + t.Fatal("nil Session.Touch succeeded") + } +} + +func TestSession_TouchRejectsReplacedAndClosedSession(t *testing.T) { + jw, err := New() + if err != nil { + t.Fatal(err) + } + defer jw.Close() + + const sessionID = key.Key(0x1122334455667788) + remoteIP := netip.MustParseAddr("192.0.2.1") + stale := newSession(jw, sessionID, remoteIP, false) + jw.mu.Lock() + jw.registerSessionLocked(stale, false) + jw.mu.Unlock() + jw.deleteSessionIfCurrent(stale) + + replacement := newSession(jw, sessionID, remoteIP, false) + jw.mu.Lock() + jw.registerSessionLocked(replacement, false) + jw.mu.Unlock() + if stale.Touch() || !replacement.Touch() { + t.Fatal("Touch accepted stale session or rejected current replacement") + } + replacement.Close() + if replacement.Touch() { + t.Fatal("Touch revived a closed session") + } + if stale.Touch() { + t.Fatal("Touch revived a replaced session after current Close") + } +} + +func TestSession_TouchConcurrentReplacement(t *testing.T) { + jw, err := New() + if err != nil { + t.Fatal(err) + } + defer jw.Close() + go jw.Serve() + + r := httptest.NewRequest(http.MethodGet, "http://example.test/", nil) + old := jw.NewSession(httptest.NewRecorder(), r) + if old == nil { + t.Fatal("expected session") + } + done := make(chan struct{}) + go func() { + defer close(done) + for range 100 { + old.Touch() + } + }() + current := jw.NewSession(httptest.NewRecorder(), r) + <-done + if current == nil || old.Touch() || !current.Touch() || jw.GetSession(r) != current { + t.Fatal("Touch revived the old session during replacement") + } +} + func TestSession_GetSessionRejectsCookieValueWithTail(t *testing.T) { jw, _ := New() defer jw.Close() From e930f287a60189af3429bf03d495616365576b7c Mon Sep 17 00:00:00 2001 From: Johan Lindh Date: Wed, 4 Nov 2026 06:55:55 +0100 Subject: [PATCH 2/7] test(session): cover touch with attached and replacing requests --- doc/sessions.md | 15 ++++++++++- session_test.go | 68 +++++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 72 insertions(+), 11 deletions(-) diff --git a/doc/sessions.md b/doc/sessions.md index b3346c19..213037ec 100644 --- a/doc/sessions.md +++ b/doc/sessions.md @@ -67,7 +67,20 @@ without attached Requests. Cookies have no explicit expiry or MaxAge. An application using a Session for authenticated HTTP pages without a WebSocket can call `Session.Touch` after authorizing each request. It extends the grace window for a current live Session and returns false for an expired, closed, or -replaced Session. Authorization remains the application's responsibility. +replaced Session. Reject the request when it returns false, and prevent shared +caching of every protected response: + +```go +w.Header().Set("Cache-Control", "no-store") +session := jw.GetSession(r) +if session == nil || !authorized(session) || !session.Touch() { + http.Error(w, "Forbidden", http.StatusForbidden) + return +} +``` + +`authorized` is the application's identity and permission check; `Touch` does +not authorize the request. `Session.Reload` asks its active pages to reload. `Session.Close` invalidates the Session and queues reloads for its associated pages, including those still diff --git a/session_test.go b/session_test.go index 3929fbe9..f88733d1 100644 --- a/session_test.go +++ b/session_test.go @@ -8,6 +8,7 @@ import ( "net/http" "net/http/httptest" "net/netip" + "runtime" "slices" "strings" "testing" @@ -2135,6 +2136,34 @@ func TestSession_TouchExtendsHTTPGraceAndRejectsExpiry(t *testing.T) { } } +func TestSession_TouchAttachedRequest(t *testing.T) { + jw, err := New() + if err != nil { + t.Fatal(err) + } + defer jw.Close() + + r := httptest.NewRequest(http.MethodGet, "http://example.test/", nil) + sess := jw.NewSession(httptest.NewRecorder(), r) + if sess == nil { + t.Fatal("expected session") + } + rq := jw.NewRequest(httptest.NewRecorder(), r) + if rq.Session() != sess { + t.Fatal("request did not attach to session") + } + sess.mu.Lock() + sess.deadline = time.Now().Add(-time.Second) + sess.mu.Unlock() + if !sess.Touch() { + t.Fatal("Touch rejected a session kept live by an attached request") + } + jw.recycle(rq) + if got := jw.GetSession(r); got != sess { + t.Fatalf("session expired after unclaimed request detached: got %p, want %p", got, sess) + } +} + func TestSession_TouchRejectsReplacedAndClosedSession(t *testing.T) { jw, err := New() if err != nil { @@ -2172,24 +2201,43 @@ func TestSession_TouchConcurrentReplacement(t *testing.T) { t.Fatal(err) } defer jw.Close() - go jw.Serve() r := httptest.NewRequest(http.MethodGet, "http://example.test/", nil) old := jw.NewSession(httptest.NewRecorder(), r) if old == nil { t.Fatal("expected session") } - done := make(chan struct{}) - go func() { - defer close(done) - for range 100 { - old.Touch() + old.mu.Lock() + touched := make(chan bool, 1) + go func() { touched <- old.Touch() }() + // Hold Touch at the session lock while it owns the registry read lock. + deadline := time.Now().Add(5 * time.Second) + for jw.mu.TryLock() { + jw.mu.Unlock() + if time.Now().After(deadline) { + old.mu.Unlock() + t.Fatal("Touch did not acquire the registry read lock") } - }() - current := jw.NewSession(httptest.NewRecorder(), r) - <-done + runtime.Gosched() + } + replaced := make(chan *Session, 1) + go func() { replaced <- jw.NewSession(httptest.NewRecorder(), r) }() + // A waiting replacement writer blocks new readers until Touch releases it. + for jw.mu.TryRLock() { + jw.mu.RUnlock() + if time.Now().After(deadline) { + old.mu.Unlock() + t.Fatal("replacement did not wait for Touch") + } + runtime.Gosched() + } + old.mu.Unlock() + if !<-touched { + t.Fatal("Touch rejected the current session before replacement") + } + current := <-replaced if current == nil || old.Touch() || !current.Touch() || jw.GetSession(r) != current { - t.Fatal("Touch revived the old session during replacement") + t.Fatal("Touch revived the old session after replacement") } } From 849e128b9a76d9700192c83cc5fc5aabb93a9020 Mon Sep 17 00:00:00 2001 From: Johan Lindh Date: Wed, 4 Nov 2026 06:59:28 +0100 Subject: [PATCH 3/7] test(session): reset replacement wait deadline --- session_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/session_test.go b/session_test.go index f88733d1..7c927be7 100644 --- a/session_test.go +++ b/session_test.go @@ -2223,6 +2223,7 @@ func TestSession_TouchConcurrentReplacement(t *testing.T) { replaced := make(chan *Session, 1) go func() { replaced <- jw.NewSession(httptest.NewRecorder(), r) }() // A waiting replacement writer blocks new readers until Touch releases it. + deadline = time.Now().Add(5 * time.Second) for jw.mu.TryRLock() { jw.mu.RUnlock() if time.Now().After(deadline) { From 40c0851416b268c15f8d886976e662d33941f2b9 Mon Sep 17 00:00:00 2001 From: Johan Lindh Date: Wed, 4 Nov 2026 07:07:15 +0100 Subject: [PATCH 4/7] test(session): bound concurrent touch waits --- session_test.go | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/session_test.go b/session_test.go index 7c927be7..ca20b0c8 100644 --- a/session_test.go +++ b/session_test.go @@ -2200,7 +2200,12 @@ func TestSession_TouchConcurrentReplacement(t *testing.T) { if err != nil { t.Fatal(err) } - defer jw.Close() + closeSafe := true + defer func() { + if closeSafe { + jw.Close() + } + }() r := httptest.NewRequest(http.MethodGet, "http://example.test/", nil) old := jw.NewSession(httptest.NewRecorder(), r) @@ -2216,6 +2221,7 @@ func TestSession_TouchConcurrentReplacement(t *testing.T) { jw.mu.Unlock() if time.Now().After(deadline) { old.mu.Unlock() + closeSafe = false t.Fatal("Touch did not acquire the registry read lock") } runtime.Gosched() @@ -2228,15 +2234,29 @@ func TestSession_TouchConcurrentReplacement(t *testing.T) { jw.mu.RUnlock() if time.Now().After(deadline) { old.mu.Unlock() + closeSafe = false t.Fatal("replacement did not wait for Touch") } runtime.Gosched() } old.mu.Unlock() - if !<-touched { + var wasTouched bool + select { + case wasTouched = <-touched: + case <-time.After(5 * time.Second): + closeSafe = false + t.Fatal("Touch remained blocked during replacement") + } + if !wasTouched { t.Fatal("Touch rejected the current session before replacement") } - current := <-replaced + var current *Session + select { + case current = <-replaced: + case <-time.After(5 * time.Second): + closeSafe = false + t.Fatal("replacement remained blocked after Touch") + } if current == nil || old.Touch() || !current.Touch() || jw.GetSession(r) != current { t.Fatal("Touch revived the old session after replacement") } From 3fbf1ac5f2d5744d14c9d70be2f6f8c7f2596ffe Mon Sep 17 00:00:00 2001 From: Johan Lindh Date: Wed, 4 Nov 2026 07:15:33 +0100 Subject: [PATCH 5/7] docs(session): state HTTP touch lifetime contract --- session.go | 5 +++-- session_test.go | 4 +++- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/session.go b/session.go index 43eae09f..ec4fc0e4 100644 --- a/session.go +++ b/session.go @@ -23,8 +23,9 @@ const sessionGrace = time.Minute // // Sessions live in memory and are bound to the remote IP that created them. // Their cookies have no explicit expiry or MaxAge. A Session starts with a -// one-minute grace deadline; detaching a claimed Request refreshes that deadline, -// while detaching an unclaimed Request leaves it unchanged. It expires once the +// one-minute grace deadline; Touch can extend it for authenticated HTTP activity. +// Detaching a claimed Request refreshes that deadline, while detaching an +// unclaimed Request leaves it unchanged. It expires once the // deadline passes with no attached Requests, and maintenance removes it. // [Jaws.Close] invalidates all Sessions and clears their data. // diff --git a/session_test.go b/session_test.go index ca20b0c8..f12f02c0 100644 --- a/session_test.go +++ b/session_test.go @@ -2114,13 +2114,15 @@ func TestSession_TouchExtendsHTTPGraceAndRejectsExpiry(t *testing.T) { soon := time.Now().Add(time.Second) sess.deadline = soon sess.mu.Unlock() + before := time.Now() if !sess.Touch() { t.Fatal("current HTTP session was not touched") } + after := time.Now() sess.mu.RLock() refreshed := sess.deadline sess.mu.RUnlock() - if !refreshed.After(soon.Add(50*time.Second)) || jw.GetSession(r) != sess { + if refreshed.Before(before.Add(sessionGrace)) || refreshed.After(after.Add(sessionGrace)) || jw.GetSession(r) != sess { t.Fatalf("Touch did not extend grace: old=%s new=%s", soon, refreshed) } From 4584386d93f91203971a7dafc4291893eef55003 Mon Sep 17 00:00:00 2001 From: Johan Lindh Date: Wed, 4 Nov 2026 07:19:05 +0100 Subject: [PATCH 6/7] docs(session): clarify HTTP session state --- session.go | 2 +- session_test.go | 10 ++++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/session.go b/session.go index ec4fc0e4..9c5262eb 100644 --- a/session.go +++ b/session.go @@ -19,7 +19,7 @@ import ( const sessionGrace = time.Minute -// Session stores server-side state shared by one or more Requests. +// Session stores server-side state shared by HTTP handlers and JaWS Requests. // // Sessions live in memory and are bound to the remote IP that created them. // Their cookies have no explicit expiry or MaxAge. A Session starts with a diff --git a/session_test.go b/session_test.go index f12f02c0..6fb437d8 100644 --- a/session_test.go +++ b/session_test.go @@ -2111,8 +2111,7 @@ func TestSession_TouchExtendsHTTPGraceAndRejectsExpiry(t *testing.T) { t.Fatal("expected session") } sess.mu.Lock() - soon := time.Now().Add(time.Second) - sess.deadline = soon + sess.deadline = time.Now().Add(time.Second) sess.mu.Unlock() before := time.Now() if !sess.Touch() { @@ -2122,8 +2121,11 @@ func TestSession_TouchExtendsHTTPGraceAndRejectsExpiry(t *testing.T) { sess.mu.RLock() refreshed := sess.deadline sess.mu.RUnlock() - if refreshed.Before(before.Add(sessionGrace)) || refreshed.After(after.Add(sessionGrace)) || jw.GetSession(r) != sess { - t.Fatalf("Touch did not extend grace: old=%s new=%s", soon, refreshed) + if refreshed.Before(before.Add(sessionGrace)) || refreshed.After(after.Add(sessionGrace)) { + t.Fatalf("Touch deadline outside one-minute grace: before=%s after=%s deadline=%s", before, after, refreshed) + } + if got := jw.GetSession(r); got != sess { + t.Fatalf("touched session not retrievable: got %p, want %p", got, sess) } sess.mu.Lock() From 7eb6de9444d8a0d4b51a41d47e398868fccce407 Mon Sep 17 00:00:00 2001 From: Johan Lindh Date: Wed, 4 Nov 2026 07:26:28 +0100 Subject: [PATCH 7/7] docs(session): define touch result --- session.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/session.go b/session.go index 9c5262eb..6667cd12 100644 --- a/session.go +++ b/session.go @@ -145,9 +145,9 @@ func (sess *Session) Set(key string, value any) { } // Touch extends the one-minute grace window for a current, live Session. -// It supports authenticated HTTP requests that do not attach a WebSocket. -// An expired, closed, or replaced Session cannot be revived. A concurrent -// Close may invalidate the Session immediately after Touch returns. +// Applications can call it after authorizing an HTTP request without a WebSocket. +// It returns true when it extends the deadline, and false for a nil, expired, +// closed, or replaced Session. A concurrent Close may invalidate it immediately. func (sess *Session) Touch() bool { if sess == nil { return false