A rootless Android app that boots Alpine Linux: run containers (Podman/Docker/LXC) and GUI desktop apps.
fix(engine): keep implicit forwards out of the rule-diff removal
ExTv5c5757ee02c7
diff --git a/app/src/main/java/com/excp/podroid/engine/EngineHolder.kt b/app/src/main/java/com/excp/podroid/engine/EngineHolder.ktindex 8c54251..a80a186 100644--- a/app/src/main/java/com/excp/podroid/engine/EngineHolder.kt+++ b/app/src/main/java/com/excp/podroid/engine/EngineHolder.kt@@ -94,6 +94,16 @@ class EngineHolder @Inject constructor(// removed during the boot window is still torn down.@Volatile private var launchRules: Set<PortForwardRule> = emptySet()+ // Always-on forwards that PodroidService injects into the launch set but+ // never persists to the DataStore (SSH 9922→22 when enabled, plus the X11+ // viewer's VNC 5900 and audio 4713). They live in launchRules but not in the+ // DataStore `rules`, so a diff of `desired = rules` computes them as removed+ // on the first →Running edge and tears them down — racing the engine's own+ // initial setup, which surfaced as intermittent SSH/VNC/audio dropout.+ // Captured once on the →Running edge (launchRules - rules) and folded into+ // `desired` so they are never removed; explicit user rules still diff live.+ @Volatile private var implicitRules: Set<PortForwardRule> = emptySet()+// The engine instance started during the current selection cycle. @Singleton// engines retain their last terminal state (e.g. Stopped) across a swap, so a// freshly (re)selected engine that hasn't been started this cycle must surface@@ -138,6 +148,7 @@ class EngineHolder @Inject constructor(}.collect { (eng, rules, state) ->if (state !is VmState.Running) {appliedRules = emptySet()+ implicitRules = emptySet()wasRunning = falsereturn@collect}@@ -146,9 +157,19 @@ class EngineHolder @Inject constructor(// launch cmdline, so treat them as applied. Unchanged boot →// added/removed empty; a rule removed mid-boot → removed.appliedRules = launchRules+ // The implicit always-on forwards (in launchRules but never+ // persisted to the DataStore) must never be torn down by the+ // diff. Capture them once here so they can be folded into+ // `desired` below — without this they'd be computed as+ // removed and race the engine's initial setup.+ implicitRules = launchRules - ruleswasRunning = true}- val (added, removed) = computeRuleDiff(applied = appliedRules, desired = rules)+ // Persisted user rules plus the implicit always-on forwards, so+ // SSH/VNC/audio are never in `removed`. User rules still add and+ // remove live as the DataStore changes.+ val desired = rules + implicitRules+ val (added, removed) = computeRuleDiff(applied = appliedRules, desired = desired)// Track what is actually live so a transient add/remove failure// doesn't permanently desync appliedRules from the engine: a// failed add isn't recorded as applied (retried next diff), adiff --git a/app/src/test/java/com/excp/podroid/engine/EngineHolderDiffTest.kt b/app/src/test/java/com/excp/podroid/engine/EngineHolderDiffTest.ktindex e4c7ad7..d160f6d 100644--- a/app/src/test/java/com/excp/podroid/engine/EngineHolderDiffTest.kt+++ b/app/src/test/java/com/excp/podroid/engine/EngineHolderDiffTest.kt@@ -59,4 +59,35 @@ class EngineHolderDiffTest {assertEquals(desired, added)assertEquals(emptySet<PortForwardRule>(), removed)}++ @Test+ fun `implicit always-on forwards are never removed`() {+ // SSH/VNC/audio are injected into the launch set by PodroidService but+ // never persisted to the DataStore, so they appear in launchRules yet+ // not in `rules`. The diff loop folds them back in (desired = rules ++ // implicit) so they are never computed as removed. Without that fold the+ // first →Running diff tore them down, racing the engine's own initial+ // setup and surfacing as intermittent SSH/VNC/audio dropout.+ val ssh = rule(9922, 22); val vnc = rule(5900); val audio = rule(4713)+ val launch = setOf(ssh, vnc, audio) // appliedRules at →Running+ val persisted = emptySet<PortForwardRule>() // DataStore: no user rules+ val implicit = launch - persisted // captured at →Running edge+ val desired = persisted + implicit // the fold+ val (added, removed) = computeRuleDiff(applied = launch, desired = desired)+ assertEquals(emptySet<PortForwardRule>(), removed)+ assertEquals(emptySet<PortForwardRule>(), added)+ }++ @Test+ fun `user rule removed mid-session is torn down while implicit forwards survive`() {+ val ssh = rule(9922, 22)+ val user = rule(8000)+ val launch = setOf(ssh, user)+ val implicit = launch - setOf(user) // = {ssh}, captured at →Running+ // user later deletes 8000 → DataStore now empty+ val desired = emptySet<PortForwardRule>() + implicit+ val (added, removed) = computeRuleDiff(applied = launch, desired = desired)+ assertEquals(setOf(user), removed) // user rule gone; ssh not removed+ assertEquals(emptySet<PortForwardRule>(), added)+ }}