Both languages read the same values of TS_META_ADDR as no metaserver

[bjmeetsfo]

storage_backend::single_node says of itself:

This is the one implementation of that rule. The datanode decides whether to register with a
metaserver from it … A second copy would let the name in the log drift away from the topology
it claims to describe, which is the failure this function exists to make impossible.

There is a second copy. matrixark_deployment_plan.META_SENTINELS is the same five values of
TS_META_ADDR in python — "", local, none, standalone, off — and nothing compared
them. The python test checks that list against itself, and no test under tools/ mentioned the
rust constant at all, so the two could drift in either direction without a word.

Drift here is not hypothetical

It already happened, in the other direction. matrixark_rust_proxy_impl::open_remote_store
re-derived the rule with is_empty() and got a narrower answer, so a one-box — which sets
TS_META_ADDR=local — handed "local" to the client as a literal socket address:

record_log_remote_execute_failed: http error: io error: invalid socket address

Every write failed, 123,435 of them in one soak, while the sample column read all zeros. That
call site now routes through single_node() and carries the incident in a comment. This checks
the copy that is left — the one in another language, where the compiler cannot help.

What it pins

• The two lists hold the same values. The rust side is read out of the source (it cannot be
  imported from tools/), including its [&str; N] length annotation, so a list that grew
  without the annotation being updated is caught rather than silently trimmed.
• Normalisation, on both sides. The list is only half the rule: rust compares
  value.trim().to_ascii_lowercase() and python compares _clean(...).lower(), so " Local "
  is a sentinel to both. Either side losing that is the same failure as either list changing —
  a value one side calls standalone and the other hands over as an address.

The python half is driven, not read: is_standalone() is called with the spellings a unit
file or a heredoc actually leaves (" local ", "LOCAL", "\tOff\n", "None",
"Standalone").

It discriminates

Checked by perturbing each side and watching it fail, then restoring:

• a sixth spelling added to the rust list alone → fails, printing both lists;
• .trim().to_ascii_lowercase() removed from the rust comparison → fails naming that.

There is a positive control (10.0.0.4:17001 must still read as a real address), without which
every other assertion would pass against a function that answered "standalone" to everything.
And the readability of the constant is asserted first, since the comparisons would otherwise pass
on an empty tuple.

The normalisation check searches with re.search rather than assertRegex, whose failure
message prints the whole haystack — 45 KB of storage_backend.rs to report that one line moved.

No production code changes.

🤖 Generated with Claude Code