Skip to content

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.kt
index 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 = false
return@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 - rules
wasRunning = 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), a
diff --git a/app/src/test/java/com/excp/podroid/engine/EngineHolderDiffTest.kt b/app/src/test/java/com/excp/podroid/engine/EngineHolderDiffTest.kt
index 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)
+ }
}