Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

fix(bridge): freeze_idle is re-armed by every access and held off while a request runs, a wedged tab cannot block other thaws, and a failed thaw fails the request (PIN-369)

Luigi Agostib710587b19cf
diff --git a/dashboard/src/pages/settings/DefaultsSettingsSection.tsx b/dashboard/src/pages/settings/DefaultsSettingsSection.tsx
index 3e9b9048..33fea708 100644
--- a/dashboard/src/pages/settings/DefaultsSettingsSection.tsx
+++ b/dashboard/src/pages/settings/DefaultsSettingsSection.tsx
@@ -142,7 +142,7 @@ export function DefaultsSettingsSection({
</SettingRow>
<SettingRow
label="Tab lifecycle"
- description="Optionally close or freeze idle tabs after a /text, /snapshot, or /action response. The timer resets on each subsequent request and is cancelled by /navigate; a frozen tab unfreezes on its next request."
+ description="Close idle closes a tab after a /text, /snapshot, or /action response once the delay passes; /navigate cancels it. Freeze idle freezes any tab no request has touched for the delay and unfreezes it on its next request."
>
<Select
value={backendConfig.instanceDefaults.tabPolicy?.lifecycle ?? "keep"}
diff --git a/docs/core-concepts.md b/docs/core-concepts.md
index e7ea6ef9..62ea68a1 100644
--- a/docs/core-concepts.md
+++ b/docs/core-concepts.md
@@ -193,10 +193,12 @@ curl -X POST http://localhost:9867/close \
By default, tabs use the `keep` lifecycle policy and are not auto-closed after
reads or actions. Set `instanceDefaults.tabPolicy.lifecycle` to `close_idle` to
auto-close a tab after an authorized `/text`, `/snapshot`, or `/action` request
-finishes. Set it to `freeze_idle` to freeze the tab instead: its timers and
-JavaScript stop, while its DOM, session and URL survive, and the next request
-that touches the tab unfreezes it before running. A tab paused for handoff,
-streaming a screencast, or holding network interception rules is never frozen.
+finishes. Set it to `freeze_idle` to freeze a tab that no request has touched
+for the idle delay instead: its timers and JavaScript stop, while its DOM,
+session and URL survive. Every request on the tab restarts that clock and
+unfreezes the tab before running, and a tab is never frozen while a request on
+it is still running (a screencast stream counts), while it is paused for
+handoff, or while it holds network interception rules.
`instanceDefaults.tabPolicy.closeDelaySec` adjusts the idle delay when
`close_idle` or `freeze_idle` is enabled.
diff --git a/docs/reference/config.md b/docs/reference/config.md
index 022bfa52..5029c6fe 100644
--- a/docs/reference/config.md
+++ b/docs/reference/config.md
@@ -511,7 +511,7 @@ You can change or clear that default with `browser.extensionPaths`.
```
- `eviction` controls what happens when `maxTabs` is reached: `close_lru`, `close_oldest`, or `reject`.
-- `lifecycle` controls idle lifecycle behavior: `keep` disables lifecycle auto-close and is the default; `close_idle` auto-closes a tab after it handles an authorized `/text`, `/snapshot`, or `/action` request; `freeze_idle` freezes it at the same point instead (timers and JavaScript stop, the page and session stay), and any later request on the tab unfreezes it first. Tabs paused for handoff, streaming a screencast, or holding network interception rules are never frozen.
+- `lifecycle` controls idle lifecycle behavior: `keep` disables lifecycle auto-close and is the default; `close_idle` auto-closes a tab after it handles an authorized `/text`, `/snapshot`, or `/action` request; `freeze_idle` instead freezes a tab no request has touched for the idle delay (timers and JavaScript stop, the page and session stay); every request restarts that clock and unfreezes the tab first. A tab is never frozen while a request on it is running (including a screencast stream), while it is paused for handoff, or while it holds network interception rules.
- `closeDelaySec` is the idle delay for `close_idle` and `freeze_idle`. The default is `300` seconds when either is enabled.
- `restore` controls whether session tabs are restored on startup. The default is `false`.
diff --git a/internal/bridge/bridge_test.go b/internal/bridge/bridge_test.go
index 45ee8be5..cd2bca28 100644
--- a/internal/bridge/bridge_test.go
+++ b/internal/bridge/bridge_test.go
@@ -291,7 +291,9 @@ func TestMarkAccessedUpdatesCurrentTabAndLastUsed(t *testing.T) {
tm.tabs["tab2"] = &TabEntry{Ctx: context.Background(), CreatedAt: oldTime, LastUsed: oldTime}
tm.currentTab = "tab1"
- tm.markAccessed("tab2")
+ if err := tm.markAccessed("tab2"); err != nil {
+ t.Fatal(err)
+ }
if tm.currentTab != "tab2" {
t.Fatalf("currentTab = %q, want tab2", tm.currentTab)
diff --git a/internal/bridge/bridge_types.go b/internal/bridge/bridge_types.go
index 19967bc2..a0ef988e 100644
--- a/internal/bridge/bridge_types.go
+++ b/internal/bridge/bridge_types.go
@@ -5,6 +5,7 @@ import (
"fmt"
"net"
"strconv"
+ "sync"
"time"
"github.com/pinchtab/pinchtab/internal/browserops"
@@ -25,10 +26,11 @@ type TabEntry struct {
CreatorScope string
UsedByOtherScope bool
- idleTimer *time.Timer
- idleGen uint64
- frozen bool
- awakeHolds int
+ idleTimer *time.Timer
+ idleGen uint64
+ frozen bool
+ awakeHolds int
+ lifecycleMu sync.Mutex
}
type RefTarget struct {
diff --git a/internal/bridge/screencast.go b/internal/bridge/screencast.go
index 55039c61..da9ac740 100644
--- a/internal/bridge/screencast.go
+++ b/internal/bridge/screencast.go
@@ -23,29 +23,10 @@ import (
// mode. Polling is used for headless browsers and providers whose CDP proxy
// does not support Page.startScreencast (e.g. Cloak).
func (b *Bridge) StartScreencast(ctx context.Context, opts ScreencastOpts) (*ScreencastStream, error) {
- release := b.holdTabAwake(ctx)
- start := b.startScreencastEventDriven
if b.shouldUsePollingScreencast() {
- start = b.startScreencastPolling
+ return b.startScreencastPolling(ctx, opts)
}
- stream, err := start(ctx, opts)
- if err != nil {
- release()
- return nil, err
- }
- go func() {
- <-stream.Done()
- release()
- }()
- return stream, nil
-}
-
-func (b *Bridge) holdTabAwake(ctx context.Context) (release func()) {
- c := chromedp.FromContext(ctx)
- if b.TabManager == nil || c == nil || c.Target == nil {
- return func() {}
- }
- return b.HoldAwake(b.IdMgr.TabIDFromCDPTarget(string(c.Target.TargetID)))
+ return b.startScreencastEventDriven(ctx, opts)
}
func (b *Bridge) shouldUsePollingScreencast() bool {
diff --git a/internal/bridge/tab_adopt.go b/internal/bridge/tab_adopt.go
index b55a2a57..83341c6b 100644
--- a/internal/bridge/tab_adopt.go
+++ b/internal/bridge/tab_adopt.go
@@ -123,7 +123,9 @@ func (tm *TabManager) adoptExistingTarget(targetID target.ID, enforceLimit bool)
if entry == nil || entry.Ctx == nil {
return "", fmt.Errorf("tab %s has no active context", tabID)
}
- tm.touchTab(tabID)
+ if err := tm.touchTab(tabID); err != nil {
+ return "", err
+ }
return tabID, nil
}
diff --git a/internal/bridge/tab_freeze.go b/internal/bridge/tab_freeze.go
index 2cd0117e..2fc47973 100644
--- a/internal/bridge/tab_freeze.go
+++ b/internal/bridge/tab_freeze.go
@@ -2,19 +2,29 @@ package bridge
import (
"context"
+ "fmt"
"log/slog"
+ "sync"
"time"
"github.com/chromedp/chromedp"
"github.com/pinchtab/pinchtab/internal/bridge/cdpops"
)
+const lifecycleCallTimeout = 5 * time.Second
+
func setTabFrozen(ctx context.Context, frozen bool) error {
return chromedp.Run(ctx, chromedp.ActionFunc(func(c context.Context) error {
return cdpops.SetPageFrozen(c, frozen)
}))
}
+func (tm *TabManager) applyFrozen(tabCtx context.Context, frozen bool) error {
+ ctx, cancel := context.WithTimeout(tabCtx, lifecycleCallTimeout)
+ defer cancel()
+ return tm.setFrozen(ctx, frozen)
+}
+
func (tm *TabManager) SetFreezeVeto(veto func(tabID string) bool) {
tm.freezeVeto = veto
}
@@ -36,11 +46,25 @@ func (tm *TabManager) HoldAwake(tabID string) (release func()) {
if !ok {
return func() {}
}
+ var once sync.Once
return func() {
- tm.mu.Lock()
- entry.awakeHolds--
- tm.mu.Unlock()
+ once.Do(func() {
+ tm.mu.Lock()
+ entry.awakeHolds--
+ idle := entry.awakeHolds == 0
+ tm.mu.Unlock()
+ if idle {
+ tm.rearmFreeze(tabID)
+ }
+ })
+ }
+}
+
+func (tm *TabManager) HoldAwakeUntil(ctx context.Context, tabID string) {
+ if tm == nil || !tm.freezesIdleTabs() {
+ return
}
+ context.AfterFunc(ctx, tm.HoldAwake(tabID))
}
func (tm *TabManager) TabFrozen(tabID string) bool {
@@ -50,16 +74,27 @@ func (tm *TabManager) TabFrozen(tabID string) bool {
return ok && entry.frozen
}
+func (tm *TabManager) rearmFreeze(tabID string) {
+ if tm.freezesIdleTabs() {
+ tm.ScheduleIdleLifecycle(tabID)
+ }
+}
+
func (tm *TabManager) freezeIdleTab(tabID string, gen uint64) {
if tm.keepsAwake(tabID) {
return
}
- tm.lifecycleMu.Lock()
- defer tm.lifecycleMu.Unlock()
+ tm.mu.RLock()
+ entry, ok := tm.tabs[tabID]
+ tm.mu.RUnlock()
+ if !ok {
+ return
+ }
+ entry.lifecycleMu.Lock()
+ defer entry.lifecycleMu.Unlock()
tm.mu.Lock()
- entry, ok := tm.tabs[tabID]
- if !ok || entry.idleGen != gen || entry.Ctx == nil || entry.awakeHolds > 0 {
+ if entry.idleGen != gen || entry.Ctx == nil || entry.awakeHolds > 0 {
tm.mu.Unlock()
return
}
@@ -68,49 +103,43 @@ func (tm *TabManager) freezeIdleTab(tabID string, gen uint64) {
ctx := entry.Ctx
tm.mu.Unlock()
- if err := tm.setFrozen(ctx, true); err != nil {
- tm.mu.Lock()
- entry.frozen = false
- tm.mu.Unlock()
+ if err := tm.applyFrozen(ctx, true); err != nil {
slog.Debug("freeze idle tab failed", "tabId", tabID, "err", err)
return
}
slog.Info("tab frozen", "tabId", tabID, "reason", "freeze_idle")
}
-func (tm *TabManager) thawTab(tabID string) {
- tm.lifecycleMu.Lock()
- defer tm.lifecycleMu.Unlock()
+func (tm *TabManager) thawTab(tabID string, entry *TabEntry) error {
+ entry.lifecycleMu.Lock()
+ defer entry.lifecycleMu.Unlock()
- tm.mu.Lock()
- entry, ok := tm.tabs[tabID]
- if !ok || !entry.frozen {
- tm.mu.Unlock()
- return
+ tm.mu.RLock()
+ frozen, ctx := entry.frozen, entry.Ctx
+ tm.mu.RUnlock()
+ if !frozen {
+ return nil
+ }
+ if err := tm.applyFrozen(ctx, false); err != nil {
+ return fmt.Errorf("tab %s could not be unfrozen: %w", tabID, err)
}
+ tm.mu.Lock()
entry.frozen = false
- ctx := entry.Ctx
tm.mu.Unlock()
-
- if err := tm.setFrozen(ctx, false); err != nil {
- slog.Warn("unfreeze tab failed", "tabId", tabID, "err", err)
- }
+ return nil
}
-func (tm *TabManager) touchTab(tabID string) {
+func (tm *TabManager) touchTab(tabID string) error {
tm.mu.Lock()
tm.accessed[tabID] = true
entry, ok := tm.tabs[tabID]
- frozen := false
if ok {
entry.LastUsed = time.Now()
- if tm.freezesIdleTabs() {
- entry.stopIdleTimer()
- }
- frozen = entry.frozen
}
tm.mu.Unlock()
- if frozen {
- tm.thawTab(tabID)
+ if !ok {
+ return nil
}
+ tm.rearmFreeze(tabID)
+ return tm.thawTab(tabID, entry)
}
diff --git a/internal/bridge/tab_freeze_browser_test.go b/internal/bridge/tab_freeze_browser_test.go
index 8158c21f..a59babd7 100644
--- a/internal/bridge/tab_freeze_browser_test.go
+++ b/internal/bridge/tab_freeze_browser_test.go
@@ -9,7 +9,6 @@ import (
"github.com/chromedp/cdproto/target"
"github.com/chromedp/chromedp"
"github.com/pinchtab/pinchtab/internal/config"
- "github.com/pinchtab/pinchtab/internal/ids"
"github.com/pinchtab/pinchtab/internal/testbrowser"
)
@@ -54,13 +53,6 @@ func TestFreezeIdleFreezesARealTabAndAnActionUnfreezesIt(t *testing.T) {
tabID := string(raw)
tm.tabs[tabID] = &TabEntry{Ctx: tabCtx, CDPID: tabID, CreatedAt: time.Now(), LastUsed: time.Now()}
- b := &Bridge{TabManager: tm, IdMgr: ids.NewManager()}
- release := b.holdTabAwake(tabCtx)
- if tm.tabs[tabID].awakeHolds != 1 {
- t.Fatal("a screencast on the tab context did not hold the tab awake")
- }
- release()
-
tm.ScheduleIdleLifecycle(tabID)
deadline := time.Now().Add(5 * time.Second)
for !tm.TabFrozen(tabID) && time.Now().Before(deadline) {
diff --git a/internal/bridge/tab_freeze_test.go b/internal/bridge/tab_freeze_test.go
index b6ec49fd..e70d66da 100644
--- a/internal/bridge/tab_freeze_test.go
+++ b/internal/bridge/tab_freeze_test.go
@@ -2,6 +2,9 @@ package bridge
import (
"context"
+ "errors"
+ "reflect"
+ "strings"
"sync"
"testing"
"time"
@@ -51,6 +54,14 @@ func frozenOrTimeout(tm *TabManager, want bool, within time.Duration) bool {
return tm.TabFrozen("tab1") == want
}
+func (r *frozenRecorder) awaitCalls(n int) []bool {
+ deadline := time.Now().Add(time.Second)
+ for len(r.snapshot()) < n && time.Now().Before(deadline) {
+ time.Sleep(5 * time.Millisecond)
+ }
+ return r.snapshot()
+}
+
func freezeNow(t *testing.T, tm *TabManager) {
t.Helper()
tm.mu.RLock()
@@ -67,10 +78,7 @@ func TestFreezeIdleFreezesTheTabAfterTheDelay(t *testing.T) {
tm.ScheduleIdleLifecycle("tab1")
- if !frozenOrTimeout(tm, true, time.Second) {
- t.Fatal("tab was not frozen after closeDelay")
- }
- if got := rec.snapshot(); len(got) != 1 || !got[0] {
+ if got := rec.awaitCalls(1); len(got) != 1 || !got[0] || !tm.TabFrozen("tab1") {
t.Fatalf("lifecycle calls = %v, want [frozen]", got)
}
if _, ok := tm.tabs["tab1"]; !ok {
@@ -123,17 +131,128 @@ func TestEveryAccessPathUnfreezesAFrozenTab(t *testing.T) {
}
}
-func TestAccessCancelsAPendingFreeze(t *testing.T) {
+func TestAnAccessRearmsTheFreeze(t *testing.T) {
tm, rec := newFreezeTM(t, "freeze_idle", 30*time.Millisecond)
- tm.ScheduleIdleLifecycle("tab1")
+ freezeNow(t, tm)
+
+ if _, _, err := tm.TabContext("tab1"); err != nil {
+ t.Fatalf("access: %v", err)
+ }
+
+ if got := rec.awaitCalls(3); !reflect.DeepEqual(got, []bool{true, false, true}) || !tm.TabFrozen("tab1") {
+ t.Fatalf("lifecycle calls = %v, want [frozen active frozen]", got)
+ }
+}
+
+func TestALoneAccessArmsTheFreeze(t *testing.T) {
+ tm, _ := newFreezeTM(t, "freeze_idle", 20*time.Millisecond)
if _, _, err := tm.TabContext("tab1"); err != nil {
t.Fatalf("access: %v", err)
}
- time.Sleep(90 * time.Millisecond)
+
+ if !frozenOrTimeout(tm, true, time.Second) {
+ t.Fatal("an accessed tab never froze")
+ }
+}
+
+func TestARequestHoldKeepsTheTabAwakeUntilTheRequestEnds(t *testing.T) {
+ tm, rec := newFreezeTM(t, "freeze_idle", 20*time.Millisecond)
+ req, endRequest := context.WithCancel(context.Background())
+ tm.HoldAwakeUntil(req, "tab1")
+ tm.ScheduleIdleLifecycle("tab1")
+
+ time.Sleep(80 * time.Millisecond)
+ if got := rec.snapshot(); len(got) != 0 {
+ t.Fatalf("tab frozen while a request held it: %v", got)
+ }
+
+ endRequest()
+ if !frozenOrTimeout(tm, true, time.Second) {
+ t.Fatal("tab never froze after the request ended")
+ }
+}
+
+func TestReleasingAHoldTwiceDoesNotDropAnotherHold(t *testing.T) {
+ tm, rec := newFreezeTM(t, "freeze_idle", 10*time.Millisecond)
+ first := tm.HoldAwake("tab1")
+ tm.HoldAwake("tab1")
+
+ first()
+ first()
+ tm.ScheduleIdleLifecycle("tab1")
+ time.Sleep(60 * time.Millisecond)
if got := rec.snapshot(); len(got) != 0 {
- t.Fatalf("a tab in use was frozen: %v", got)
+ t.Fatalf("tab frozen under a live hold: %v", got)
+ }
+}
+
+type tabKey struct{}
+
+func TestAWedgedTabDoesNotBlockAnotherTabsThaw(t *testing.T) {
+ tm, _ := newFreezeTM(t, "freeze_idle", time.Hour)
+ wedged := make(chan struct{})
+ entered := make(chan bool, 1)
+ defer close(wedged)
+ tm.setFrozen = func(ctx context.Context, frozen bool) error {
+ if ctx.Value(tabKey{}) == "A" {
+ _, bounded := ctx.Deadline()
+ entered <- bounded
+ <-wedged
+ }
+ return nil
+ }
+ for _, id := range []string{"tabA", "tabB"} {
+ tm.tabs[id] = &TabEntry{Ctx: context.WithValue(context.Background(), tabKey{}, id[3:]), frozen: true}
+ }
+
+ go func() { _, _, _ = tm.TabContext("tabA") }()
+ if bounded := <-entered; !bounded {
+ t.Fatal("the lifecycle call runs without a deadline")
+ }
+
+ done := make(chan error, 1)
+ go func() { _, _, err := tm.TabContext("tabB"); done <- err }()
+ select {
+ case err := <-done:
+ if err != nil || tm.TabFrozen("tabB") {
+ t.Fatalf("thaw of tabB: err=%v frozen=%v", err, tm.TabFrozen("tabB"))
+ }
+ case <-time.After(time.Second):
+ t.Fatal("a wedged tabA blocked the thaw of tabB")
+ }
+}
+
+func TestAFailedThawFailsTheRequestAndTheNextAccessRetries(t *testing.T) {
+ tm, rec := newFreezeTM(t, "freeze_idle", time.Hour)
+ freezeNow(t, tm)
+ fail := true
+ tm.setFrozen = func(ctx context.Context, frozen bool) error {
+ _ = rec.set(ctx, frozen)
+ if fail {
+ fail = false
+ return errors.New("renderer busy")
+ }
+ return nil
+ }
+
+ _, _, err := tm.TabContext("tab1")
+ if err == nil || !strings.Contains(err.Error(), "could not be unfrozen") {
+ t.Fatalf("first access err = %v, want could not be unfrozen", err)
+ }
+ if !tm.TabFrozen("tab1") {
+ t.Fatal("a failed thaw was recorded as awake")
+ }
+
+ if _, _, err := tm.TabContext("tab1"); err != nil {
+ t.Fatalf("retry: %v", err)
+ }
+ if tm.TabFrozen("tab1") {
+ t.Fatal("tab still frozen after a successful retry")
+ }
+ if got := rec.snapshot(); len(got) != 3 || got[1] || got[2] {
+ t.Fatalf("lifecycle calls = %v, want [frozen active active]", got)
}
}
@@ -147,8 +266,8 @@ func TestTabsDoingUnpolledWorkAreNeverFrozen(t *testing.T) {
t.Fatal(err)
}
}},
- {"screencast streaming", func(t *testing.T, b *Bridge) {
- t.Cleanup(b.HoldAwake("tab1"))
+ {"request in flight, such as a screencast stream", func(t *testing.T, b *Bridge) {
+ b.HoldAwakeUntil(t.Context(), "tab1")
}},
{"network interception rules", func(t *testing.T, b *Bridge) {
b.routeMgr.mu.Lock()
@@ -174,15 +293,3 @@ func TestTabsDoingUnpolledWorkAreNeverFrozen(t *testing.T) {
})
}
}
-
-func TestReleasedScreencastHoldLetsTheTabFreeze(t *testing.T) {
- tm, _ := newFreezeTM(t, "freeze_idle", 10*time.Millisecond)
- release := tm.HoldAwake("tab1")
- release()
-
- tm.ScheduleIdleLifecycle("tab1")
-
- if !frozenOrTimeout(tm, true, time.Second) {
- t.Fatal("tab never froze after the hold was released")
- }
-}
diff --git a/internal/bridge/tab_lookup.go b/internal/bridge/tab_lookup.go
index 37591f77..3bf30ae8 100644
--- a/internal/bridge/tab_lookup.go
+++ b/internal/bridge/tab_lookup.go
@@ -9,11 +9,11 @@ import (
"github.com/chromedp/cdproto/target"
)
-func (tm *TabManager) markAccessed(tabID string) {
- tm.touchTab(tabID)
+func (tm *TabManager) markAccessed(tabID string) error {
tm.mu.Lock()
tm.currentTab = tabID
tm.mu.Unlock()
+ return tm.touchTab(tabID)
}
func (tm *TabManager) CurrentTabID() string {
@@ -128,8 +128,9 @@ func (tm *TabManager) TabContext(tabID string) (context.Context, string, error)
return nil, "", fmt.Errorf("tab %s has no active context", tabID)
}
- tm.markAccessed(tabID)
-
+ if err := tm.markAccessed(tabID); err != nil {
+ return nil, "", err
+ }
return entry.Ctx, tabID, nil
}
diff --git a/internal/bridge/tab_manager.go b/internal/bridge/tab_manager.go
index 9d5a2cc5..9d0da3ed 100644
--- a/internal/bridge/tab_manager.go
+++ b/internal/bridge/tab_manager.go
@@ -50,7 +50,6 @@ type TabManager struct {
guardOnce sync.Once
guardActive bool
mu sync.RWMutex
- lifecycleMu sync.Mutex
freezeVeto func(tabID string) bool
setFrozen func(ctx context.Context, frozen bool) error
diff --git a/internal/handlers/actions_test.go b/internal/handlers/actions_test.go
index dc02f25f..659b363a 100644
--- a/internal/handlers/actions_test.go
+++ b/internal/handlers/actions_test.go
@@ -481,8 +481,8 @@ func TestHandleAction_AutoCloseArmedAfterActionError(t *testing.T) {
}
}
-func TestHandleAction_IdleLifecycleArmedUnderEveryIdlePolicy(t *testing.T) {
- for _, policy := range []string{"close_idle", "freeze_idle"} {
+func TestHandleAction_OnlyCloseIdleIsArmedByTheHandler(t *testing.T) {
+ for policy, want := range map[string]int{"close_idle": 1, "freeze_idle": 0, "keep": 0} {
t.Run(policy, func(t *testing.T) {
mb := &mockBridge{}
h := New(mb, &config.RuntimeConfig{ActionTimeout: time.Second, TabLifecyclePolicy: policy}, nil, nil, nil)
@@ -490,8 +490,8 @@ func TestHandleAction_IdleLifecycleArmedUnderEveryIdlePolicy(t *testing.T) {
h.HandleAction(httptest.NewRecorder(), req)
- if got := mb.autoCloseArmed; len(got) != 1 || got[0] != "tab1" {
- t.Fatalf("idle timer armed for %#v, want [tab1]", got)
+ if got := len(mb.autoCloseArmed); got != want {
+ t.Fatalf("handler armed the idle timer %d times, want %d", got, want)
}
})
}
diff --git a/internal/handlers/activity_helpers.go b/internal/handlers/activity_helpers.go
index 8416bff6..809ca823 100644
--- a/internal/handlers/activity_helpers.go
+++ b/internal/handlers/activity_helpers.go
@@ -28,6 +28,7 @@ func (h *Handlers) tabContext(r *http.Request, tabID string) (context.Context, s
return nil, "", noCurrentTabError(scope.Description())
}
if err == nil {
+ h.holdTabAwakeForRequest(r, resolvedID)
h.setCurrentTabForRequest(r, resolvedID)
h.recordActivity(r, activity.Update{TabID: resolvedID})
}
@@ -80,6 +81,18 @@ func (h *Handlers) recordResolvedTab(r *http.Request, tabID string) {
h.recordActivity(r, activity.Update{TabID: tabID})
}
+type tabAwakeHolder interface {
+ HoldAwakeUntil(ctx context.Context, tabID string)
+}
+
+var _ tabAwakeHolder = (*bridge.Bridge)(nil)
+
+func (h *Handlers) holdTabAwakeForRequest(r *http.Request, tabID string) {
+ if holder, ok := h.Bridge.(tabAwakeHolder); ok {
+ holder.HoldAwakeUntil(r.Context(), tabID)
+ }
+}
+
type tabScopeTracker interface {
RecordTabScope(tabID, scope string, created bool)
TabsOnlyUsedByCreator(scope string) []string
diff --git a/internal/handlers/handlers.go b/internal/handlers/handlers.go
index 67b70f23..56f83ed9 100644
--- a/internal/handlers/handlers.go
+++ b/internal/handlers/handlers.go
@@ -237,19 +237,19 @@ func (h *Handlers) ensureBrowserOrRespond(w http.ResponseWriter, cfg *config.Run
}
func (h *Handlers) armIdleLifecycle(tabID string) {
- if h.idleLifecycleActive(tabID) {
+ if h.closesIdleTabs(tabID) {
h.Bridge.ScheduleIdleLifecycle(tabID)
}
}
func (h *Handlers) cancelIdleLifecycle(tabID string) {
- if h.idleLifecycleActive(tabID) {
+ if h.closesIdleTabs(tabID) {
h.Bridge.CancelIdleLifecycle(tabID)
}
}
-func (h *Handlers) idleLifecycleActive(tabID string) bool {
- return h != nil && h.Bridge != nil && tabID != "" && h.Config != nil && config.IdleTabLifecycle(h.Config.TabLifecyclePolicy)
+func (h *Handlers) closesIdleTabs(tabID string) bool {
+ return h != nil && h.Bridge != nil && tabID != "" && h.Config != nil && h.Config.TabLifecyclePolicy == "close_idle"
}
// clearTabFrameScope drops any active frame scope on a tab. Call from
diff --git a/internal/handlers/tab_awake_hold_test.go b/internal/handlers/tab_awake_hold_test.go
new file mode 100644
index 00000000..a398b773
--- /dev/null
+++ b/internal/handlers/tab_awake_hold_test.go
@@ -0,0 +1,53 @@
+package handlers
+
+import (
+ "context"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/chromedp/chromedp"
+ "github.com/pinchtab/pinchtab/internal/bridge"
+ "github.com/pinchtab/pinchtab/internal/config"
+ "github.com/pinchtab/pinchtab/internal/testbrowser"
+)
+
+func TestATabResolvedForARequestStaysAwakeUntilTheRequestEnds(t *testing.T) {
+ alloc, cancelAlloc := chromedp.NewExecAllocator(context.Background(), append(
+ chromedp.DefaultExecAllocatorOptions[:],
+ chromedp.ExecPath(testbrowser.Path(t)),
+ chromedp.UserDataDir(testbrowser.ProfileDir(t)),
+ chromedp.Flag("headless", true),
+ chromedp.Flag("no-sandbox", true),
+ )...)
+ t.Cleanup(cancelAlloc)
+ tabCtx, cancelTab := chromedp.NewContext(alloc)
+ t.Cleanup(cancelTab)
+ if err := chromedp.Run(tabCtx); err != nil {
+ t.Fatalf("start browser: %v", err)
+ }
+ cfg := &config.RuntimeConfig{TabLifecyclePolicy: "freeze_idle", TabCloseDelay: 20 * time.Millisecond, StateDir: t.TempDir()}
+ b := bridge.New(context.Background(), tabCtx, cfg)
+ b.RegisterTab("tabA", tabCtx)
+ h := New(b, cfg, nil, nil, nil)
+
+ reqCtx, endRequest := context.WithCancel(context.Background())
+ req := httptest.NewRequest("GET", "/snapshot", nil).WithContext(reqCtx)
+ if _, _, err := h.tabContext(req, "tabA"); err != nil {
+ t.Fatalf("resolve tab: %v", err)
+ }
+
+ time.Sleep(80 * time.Millisecond)
+ if b.TabFrozen("tabA") {
+ t.Fatal("tab froze while its request was still running")
+ }
+
+ endRequest()
+ deadline := time.Now().Add(time.Second)
+ for !b.TabFrozen("tabA") && time.Now().Before(deadline) {
+ time.Sleep(5 * time.Millisecond)
+ }
+ if !b.TabFrozen("tabA") {
+ t.Fatal("tab never froze after its request ended")
+ }
+}