DEV Community

ilya mozerov
ilya mozerov

Posted on

The pin moved. The window didn't

Every deployment check was green. The map on the screen was still running an
older release. Both statements were true, because they were about different
things.

What the pin actually promises

A release pin is a pointer to one exact set of bytes on disk. Delivery verifies
that pointer and the services that restart on promotion. That is a real check,
and it passed. But a long-lived terminal window is not a service. It starts a
program once and keeps running it. Promoting the pin does not restart that
window, so the process inside it goes on executing the code it loaded days ago,
through any number of promotions.

That is what happened here. Senses noticed a map view still running its old
script several promotions later. Nothing had crashed. The window was drawing a
map, which is what a healthy map view does. There was no error to notice and no
check that asked what the window was executing. The pin was current; the pane
was not.

The gap is structural

It is tempting to call this somebody's mistake — a window that should have been
restarted by hand. But a check that only knows about the pointer and systemd
consumers cannot see this class of failure at all. The window is registered,
alive and unremarkable. Its working directory is the only place that says which
release it started from, and nobody was reading it.

The general lesson is not about this particular plant. A deployment is often
described as "the new version is live," as if a pointer move propagated to every
process. It doesn't. A pointer move is a claim about what a new process will
load. Anything that has been running for a while keeps its old instructions
until something restarts it. Browser tabs, long-lived REPLs, background
observers and terminal panes all sit outside the systemd view.

What was added

A new duty runs every five minutes. For each registered view window it reads
the live pane's working directory through the process boundary, derives the
release that pane started in, and compares that release's view script with the
script at the current pin. The comparison is over file contents, not paths or
timestamps, so a promotion that left the script unchanged cannot raise a false
alarm.

When a pane is running superseded code, the verdict names the window, the
release it came from, the current pin and the exact command to respawn it. A
red result is actionable on its face: it tells you what to restart and how.
When tmux, the registry, the pin, a pane's working directory or a script cannot
be read, the verdict is UNKNOWN. It does not quietly report that nothing was
wrong, because "we could not look" is not the same as "we looked and it was
fine."

What it deliberately does not own

A pane started from the working tree is not release-pinned, so this check does
not judge it; another check owns that case. A missing or dead window belongs
to the window-coverage check. Drawing those boundaries matters: a check that
tries to be the authority for every kind of view ends up being wrong about the
ones it cannot see, and then its green result means less.

The habit worth keeping is narrower and more useful than "check your
deployment." After a promotion, ask what is still running the old bytes. A
green pin tells you the next process will be correct. It says nothing about the
ones already alive.

Top comments (0)