fix: Require only runtime packages on Linux, and check ICU and tzdata the way the runtime does (#2561 )

## Why

ModernUO mandated `-dev` packages on production servers for exactly one reason: `DllImport` never
asks for a versioned SONAME, so `libdeflate.so.0` and `libargon2.so.1` sitting in `/usr/lib` went
unfound, and the `-dev` package's unversioned symlink was the only thing making resolution work.
The `-dev` packages ship no library of their own — operators were installing headers and a static
lib on machines that compile nothing.

Fixed in the binding packages (modernuo/LibDeflate.Bindings#4, modernuo/Argon2.Bindings#13), so
this picks them up and stops asking.

```
LibDeflate.Bindings 1.0.3  -> 1.0.4
Argon2.Bindings     1.17.0 -> 1.19.0
```

## zstd is dropped too, on every platform

ZstdNet bundles `libzstd` for `linux-x64`, `linux-arm64`, `osx-x64`, `osx-arm64` and win, and
nothing shells out to the CLI. Verified: the 15 `ManagedArchive` round-trip tests pass in a
container with no `zstd` package installed and `which zstd` empty. Removed from the README, the
macOS `brew install`, and CI — so the macOS runners now prove it rather than us assuming it.

## NativeLibraryChecker asks a different question

It asked *"is package X installed"* via `dpkg -l` / `rpm -q`. That is what forced `-dev`, and no
hardcoded name works for ICU anyway — its apt package is release-specific (`libicu70` on Ubuntu
22.04, `libicu76` on Debian 13). It now asks *"will the loader find this"*: `NativeLibrary.TryLoad`
on the unversioned name, then `libfoo.so.N` descending through the range the runtime accepts.

It deliberately does not consult a package database or `ldconfig -p`. Both answer a different
question than "will `dlopen` succeed" — see the ICU section below for how that bit.

## What was wrong with the ICU check

`libicuuc` was **inherited, not derived**. It came from translating the old package-name check into
a library probe, without establishing which library that should be. Reviewing it turned up three
defects, all of which could report ICU present on a host where the runtime then refuses to start:

- **`libicui18n` was never probed.** The only ICU names in `libSystem.Globalization.Native.so` are
  `libicuuc` and `libicui18n`. `libicudata` arrives as a dependency of `libicuuc`, and
  `libicuio`/`libicutu`/`libicutest` are never referenced — so that is the complete list, and both
  are checked now.
- **No version floor.** The runtime's `MinICUVersion` is 60, but the probe accepted down to
  `.so.0`. RHEL/CentOS 7 ships ICU 50, which passed and then aborted at startup.
- **The `ldconfig` fast path bypassed the range.** A cache line for `libicuuc.so.50` still matches a
  `libicuuc.so` prefix test, so the floor was unenforceable through it. It also trusts a stale
  cache — observed reporting a deleted `libdeflate` as present. Removed in favour of asking the
  loader directly, which reads the same cache but answers the real question, and which also deletes
  the musl special-case (`ldconfig -p` exits 0 on musl while producing nothing usable).

Worth knowing when this goes wrong in the field: **missing ICU does not throw, it `FailFast`s** —
SIGABRT, exit 134, uncatchable. The process starts cleanly and dies later at whatever line first
touches a culture, so the stack rarely implicates ICU.

## tzdata is a separate prerequisite, and nothing was checking it

The event scheduler resolves configured zone IDs through `TimeZoneInfo`, which reads
`/usr/share/zoneinfo`. It is data rather than a library, so no loader probe finds it, and slim
container images routinely omit it. Without it every lookup except `UTC` throws
`TimeZoneNotFoundException` and `GetSystemTimeZones()` returns 1 entry instead of ~419.

There is no per-zone packaging to opt into — it is ~2 MB for the whole set. The one split that does
exist is a trap rather than an optimization: Debian 12 and Ubuntu 24.04 move the legacy aliases into
`tzdata-legacy`, so plain `tzdata` has `America/New_York` and `EST5EDT` but is **missing
`US/Eastern` and `Asia/Calcutta`**. A shard configured with a legacy alias throws even though tzdata
is installed. Documented, with both fixes.

## Why `InvariantGlobalization` stays false

Dropping ICU entirely by turning on invariant mode looks tempting and is not safe. Because
`Directory.Build.props` also sets `PredefinedCulturesOnly=false`, invariant mode does **not** throw
`CultureNotFoundException` — it silently hands back invariant data. Measured on .NET 10:

| Behaviour | With ICU | Invariant mode |
|---|---|---|
| `new CultureInfo("de-DE")` | real culture | succeeds, returns invariant data |
| de-DE decimal separator | `,` | `.` |
| `1234.5` as de-DE | `1.234,5` | `1,234.5` |
| `string.Compare("a", "B", InvariantCulture)` | `-1` (linguistic) | `31` (ordinal) |
| sort `[b, A, a, B]` | `a, A, b, B` | `A, B, a, b` |
| `FindSystemTimeZoneById("Eastern Standard Time")` on Linux | resolves | `TimeZoneNotFoundException` |
| UTF-8 round-trip of non-ASCII | unaffected | unaffected |

Number parsing and formatting produce wrong values with no error, and culture-sensitive sort order
silently becomes ordinal. Encoding is not the mechanism — UTF-8 round-trips fine either way.

## Documentation

The rationale now lives in `dev-docs/platform-prerequisites.md` rather than in comments, so it is
discoverable without reading the build tool: what each dependency is for, what breaks without it,
per-distro package names, the ICU floor, the `tzdata-legacy` split, and why the check asks the
loader instead of the package manager.

README drops `libicu-dev`. Matching the runtime package by pattern (`'^libicu[0-9]+$'`) is
version-independent without pulling in headers, so **no `-dev` package is required on any supported
distribution** — which was the point of the whole change.

## CI now proves the claim instead of contradicting it

The dnf job already installed runtime packages only. The apt job installed `libicu-dev`, which ships
the unversioned `libicuuc.so` symlink — so every probe succeeded on the first attempt and the
versioned-SONAME fallback this PR depends on was never exercised. Switched to the pattern match,
verified to resolve exactly one package on jammy (70), bookworm (72), noble (74) and trixie (76).

Added an assertion that the unversioned symlinks are absent. Without it the suite silently stops
testing anything the moment a base image starts shipping one. Verified against all eight matrix
distributions — none ship them — and confirmed the step fails as intended when a symlink is planted.

## Audit of every other native entry point

Checked whether anything else has the same hazard. It does not:

| Import | Verdict |
|---|---|
| `ws2_32.dll` — `SocketHelper` | Always present on Windows |
| `libc` — `SocketHelper` | **Verified safe**, see below |
| ZstdNet → `libzstd` | Bundled for every RID |
| IORingGroup | No native library; raw syscalls |
| ICU | Loaded by the .NET runtime itself, which probes versioned suffixes |

`libc` deserved a hard look, because `libc.so` *is* a `libc6-dev` linker script while the real
library is `libc.so.6` — the same shape as the bug being fixed. It is not affected. Measured in a
container with no `libc6-dev`:

```
/usr/lib/x86_64-linux-gnu/libc.so   ABSENT
/lib/x86_64-linux-gnu/libc.so.6     present
TryLoad("libc")     LOADED      <- resolves where "libdeflate" would not
TryLoad("libc.so")  not found
getpid() -> DllImport("libc") WORKS
```

Confirmed on Alpine/musl as well. No code in this repo registers a `DllImportResolver`, and nothing
else P/Invokes.

## `--check-prereqs`

New flag. `Program.cs` only ran the SDK check in non-interactive mode — `NativeLibraryChecker` was
reachable only through the Spectre-driven guided flow, so there was no way to verify a deployment
target from a script or a container. It is what made the container verification below possible, and
it prints the exact ICU package for the running release via `apt-cache`.

It renders through the same `PrerequisiteChecker` the guided menu uses, rather than a second
hand-rolled table that could drift from it. Spectre drops ANSI styling on its own when stdout is not
a terminal, so redirected output stays clean; the console width is widened in that case so the
install hints, which are shell commands meant to be copied, do not gain a newline mid-command.

```
╭───────────────────────────╮
│ Checking native libraries │
╰───────────────────────────╯

  ✔ libicuuc (Found)
  ✔ libicui18n (Found)
  ❌ libdeflate (Not found)
  ❌ tzdata (Not found — every zone except UTC will throw)

  ⚠️ Install the missing dependencies. The -dev/-devel packages are not required:
   sudo apt-get install -y libicu74 libdeflate0 tzdata
```

Exit code carries the machine-readable half: 0 when everything resolves, 1 when anything is missing.

## Verification

Against 1.0.4 and 1.19.0: build plus **810 Server.Tests and 642 UOContent.Tests**, on Windows and
on Linux with **only** `libdeflate0` and `libargon2-1` installed — with the absence of the
unversioned symlink asserted first so the run could not pass for the wrong reason.

`--check-prereqs` verified in containers on Debian and Alpine across every state that matters: all
present, each dependency removed individually, tzdata removed, a deliberately stale `ldconfig`
cache, and ICU downgraded to `.so.50` to confirm the floor rejects it. Package resolution and the
absence of unversioned symlinks checked on all eight CI distributions.

2026-08-07 15:03:08 -07:00

6.7 KiB

Raw Blame History

Platform Prerequisites

OS-level dependencies ModernUO needs at runtime, why each one is required, and what breaks without it. This page is about software packages, not hardware sizing.

Run ./build-tool --check-prereqs from the repository root to check the current machine. It prints the exact install command for the detected distribution.

What is required

Dependency	Platform	Why
.NET 10 Runtime	all	—
ICU (`libicuuc`, `libicui18n`)	Linux, macOS	The runtime refuses to start without it; see below
tzdata	Linux	Time zone lookups; see below
`libdeflate`	all	`LibDeflate.Bindings`
`libargon2`	all	`Argon2.Bindings` (password hashing)
VC++ Redistributable v14	Windows	Native bindings

Not required, despite appearances:

zstd — ZstdNet bundles libzstd for every RID.
liburing — IORingGroup issues io_uring syscalls directly. It imports only libc, libSystem.dylib, kernel32.dll, kernelbase.dll and ws2_32.dll.
-dev / -devel packages — see "Runtime packages only" below.

Install

# Debian / Ubuntu   (ICU has no stable package alias, so match it by pattern)
sudo apt-get install -y '^libicu[0-9]+$' libdeflate0 libargon2-1 tzdata

# Fedora / RHEL
sudo dnf install -y libdeflate libargon2 libicu tzdata

# Alpine
apk add --no-cache libdeflate argon2-libs icu-libs tzdata

# macOS
brew install icu4c libdeflate argon2

CentOS additionally needs EPEL and CRB:

sudo dnf install -y epel-release epel-next-release && sudo dnf config-manager --set-enabled crb

Runtime packages only

Only the runtime packages are needed. The -dev/-devel packages are not required.

They used to be, because .NET's DllImport probing looks for the unversioned libfoo.so, and on Linux that bare symlink ships only in the development package. The runtime package ships the versioned SONAME (libdeflate.so.0, libargon2.so.1). The binding packages now probe the versioned names as well, so the runtime package is sufficient.

Anything still documenting libicu-dev or libdeflate-dev as a requirement is out of date.

ICU

Directory.Build.props sets InvariantGlobalization=false, so ICU is mandatory. Without it the runtime does not throw — it FailFasts:

Couldn't find a valid ICU package installed on the system. Please install libicu (or icu-libs)
using your package manager and try again.

That is SIGABRT (exit 134) and it cannot be caught. Note the process starts cleanly and aborts later, at whatever line first touches a culture, so the crash rarely points at the cause.

Why invariant mode is not an option

InvariantGlobalization=true would remove the ICU dependency, but it changes behaviour in ways that corrupt data silently. Measured on .NET 10 with the repository's settings:

Behaviour	With ICU	Invariant mode
`new CultureInfo("de-DE")`	real culture	succeeds, returns invariant data
de-DE decimal separator	`,`	`.`
`1234.5` as de-DE	`1.234,5`	`1,234.5`
`string.Compare("a", "B", InvariantCulture)`	`-1` (linguistic)	`31` (ordinal)
sort `[b, A, a, B]`	`a, A, b, B`	`A, B, a, b`
`FindSystemTimeZoneById("Eastern Standard Time")` on Linux	resolves	`TimeZoneNotFoundException`
UTF-8 round-trip of non-ASCII	unaffected	unaffected

The dangerous row is the first. Because Directory.Build.props also sets PredefinedCulturesOnly=false, constructing a culture in invariant mode succeeds instead of throwing CultureNotFoundException, and hands back an object populated with invariant data. Number parsing and formatting then produce wrong values with no error, and culture-sensitive sort order silently becomes ordinal.

Encoding is not affected — UTF-8 round-trips correctly in both modes.

Version floor

The runtime accepts libicuuc.so.60 and above (MinICUVersion in pal_icushim.c). The prerequisite checker enforces the same floor, so a host carrying only an older ICU is reported missing rather than passing and then aborting at startup. RHEL/CentOS 7 ships ICU 50 and is affected.

ICU tracks its own release train, so the SONAME digit varies widely by distribution — .so.74 on Ubuntu 24.04, .so.76 on Alpine, .so.77 on Fedora, .so.78 on openSUSE. There is no stable package alias on Debian and Ubuntu, which is why the checker resolves the name via apt-cache instead of hardcoding one.

Only libicuuc and libicui18n are used; those are the two names libSystem.Globalization.Native.so loads. libicudata arrives as a dependency of libicuuc, and libicuio/libicutu/libicutest are never referenced. Every distribution ships all of them in a single package, so installing ICU at all satisfies both.

tzdata

The event scheduler resolves configured zone IDs through TimeZoneInfo, which reads /usr/share/zoneinfo on Linux. This is separate from ICU: it is data, not a library, so no loader probe finds it, and slim container images routinely omit it.

Without tzdata every lookup except UTC throws:

TimeZoneNotFoundException: The time zone ID 'America/New_York' was not found on the local computer.

TimeZoneInfo.GetSystemTimeZones() returns 1 entry instead of ~419, and TimeZoneInfo.Local falls back to UTC.

There is no per-zone subset

Distributions do not package individual zones — it is one tzdata package, about 2 MB installed for the full set. Subsetting is not worth pursuing.

The one split that does exist is tzdata-legacy on Debian 12 and Ubuntu 24.04, which carries the deprecated aliases. With plain tzdata alone:

Zone ID	`tzdata`	`tzdata-legacy`
`America/New_York`	present	—
`Europe/Kyiv`	present	—
`EST5EDT`	present	—
`US/Eastern`	missing	present
`Asia/Calcutta`	missing	present

So a shard configured with a legacy alias such as US/Eastern throws on a current Debian or Ubuntu even though tzdata is installed. Either install tzdata-legacy or switch the configured value to the canonical ID (America/New_York, Asia/Kolkata).

TZDIR is honoured if the data lives somewhere non-standard.

How the check works

--check-prereqs asks the loader directly — NativeLibrary.TryLoad on the unversioned name, then libfoo.so.N descending through the accepted range.

It deliberately does not consult a package database or ldconfig -p. Both answer a different question than "will dlopen succeed":

Package queries need a hardcoded name, which does not exist for ICU.
ldconfig's cache can be stale, omits LD_LIBRARY_PATH, and carries no version information to enforce the ICU floor against. On musl it exits successfully while producing nothing usable.

6.7 KiB Raw Blame History