Skip to content

[#1208] Preserve replication history during scaling, recovery and shutdown - #1282

Open
vharseko wants to merge 28 commits into
OpenIdentityPlatform:masterfrom
vharseko:feature/1208-empty-rs-failover
Open

vharseko wants to merge 28 commits into
OpenIdentityPlatform:masterfrom
vharseko:feature/1208-empty-rs-failover

Conversation

@vharseko

@vharseko vharseko commented Nov 7, 2026 •

Copy link
Copy Markdown
Member

During replication recovery, later updates can overtake missing history, a dependency scan can hand one update to two replay threads, and a closing session can delay failover handshakes on a live replication server. This PR preserves ordered history and replay ownership, drains accepted writes during shutdown without blocking unrelated runtime handshakes, and exercises scale-in/scale-out under concurrent writes. Docker fixtures require explicit bootstrap success before resuming rolled writers, retain failure diagnostics and run OpenDJ without the former 512 MiB Docker cap.

Part of #1208; also exercises the empty-RS certificate and failover path tracked in #1188.

Scale scenarios and checks

Topology Retained volume Empty volume
Four directory servers and three replication servers rs534 / scale-rs-kept rs534 / scale-rs-empty
Four combined directory/replication servers combined / scale-kept combined / scale-empty

Each scenario removes one server from REPLICATION_PEERS, rolls the survivors with the shorter list, verifies its removal from their registries and local RS lists, returns it, and rolls the survivors with the full list. Separate-server transitions roll two DS and one RS together, leaving another RS and a writer available. Combined nodes roll individually. A restarted separate-server group must finish the RS and both DS bootstraps before either writer resumes or the next group rolls; a combined node must finish its own bootstrap before resuming. Surviving writers remain active throughout these waits. Missing or failed bootstrap, failed load workers and workload deadlines still abort the scenario. Checkpoints precede stops, and writes on a surviving DS are verified while the group is stopped.

While the removed server is absent, a dedicated client applies 50,001 distinct modifications. Every surviving RS must contain the complete CSN interval before the server returns. After scale-out and membership verification, every DS must complete a newly started load segment before the workload ends. Checks cover indexed LDAP results, matching offline LDIF exports, index verification, changelog continuity, RS mesh connectivity and replication errors. The existing rs534 / empty-rs row also tests failover in both directions after rebuilding an RS while a DS is offline.

Scale load has a 2700-second ceiling and starts the disturbance at 120 seconds. Targets remain 100 modifications and 20 adds/deletes per second per DS, with error-free clients and a duration-weighted minimum of 10% of each target. Fifty-second segments rotate through three indexed surnames per DS. Other rows retain their 900-second load. The scale job and scenario step retain 75- and 70-minute limits respectively. Convergence budgets are 900 seconds for combined / scale-kept, 600 seconds for combined / scale-empty, and 300 seconds for both separate-server scale rows. Convergence still requires three complete zero-lag samples spanning more than the 60-second monitor period plus five seconds.

Host-side checkpoint and membership queries use a lightweight LDAP reader through loopback-only admin ports, with explicit deadlines and complete-result checks. Artifacts retain checkpoints, full backlog coverage, pre-restart changelogs, offline-state snapshots, bootstrap timings, prior container logs, CSN traces and post-load convergence samples. Failed workers abort pending waits; failed snapshots or Docker commands cannot count as successful progress.

Replication correctness and bootstrap

  • Replay ownership: stop each ADD/MODIFY/DELETE/MODDN dependency scan after the first matching predecessor. getNextUpdate() already waits for all earlier pending changes, so repeated parking is unnecessary and can race with another replay thread taking ownership. Parking requires the same pending-change object and current replay owner; a stale scan after a clear/re-delivery or ownership transfer cannot hand out the CSN again. This prevents the reproduced double-handoff path ending in error 9 when the original replay commits.
  • Offline-only sequence gaps: complete CSN allocation traces can distinguish an offline notification from a lost update. Classification requires an offline allocation and no local-operation allocation for the same domain, server ID and sequence in any recorded process generation, including outside the load interval. Every expected generation, end marker, record count and checksum must validate. Failed copies invalidate eligibility, and the changelog checker validates the traces again. offline.state snapshots alone remain diagnostic; incomplete traces and sequences reused by local operations cannot excuse a gap.
  • RS shutdown: stop connected DS handlers, close admission of direct DS updates, and cross a read/write barrier that also covers readers already removed from the connection map by concurrent teardown. Before closing RS writers, wait for accepted updates to be written to peer sessions, using one 30-second deadline across all domains and peers. Track selected-but-unwritten records until their socket-write callbacks complete. Skipping an exact peer receipt cannot credit an older pending write. Filtered updates retain a per-origin delivery barrier tied to the local changelog generation: a peer-only generation change cannot erase missing delivery, while a local reset retires the old obligation. A delayed discard report from an old selection cannot create a barrier in the new generation. Expiration is logged. The existing collocated-DS offline-message shutdown synchronization remains in place. A two-domain regression holds both peer send windows closed and checks that the direct-update drain uses one deadline and logs a warning for each undelivered target.
  • Peer teardown: unregister the old handler, stop accepting work and remove its name-based monitors while holding the domain lock. Release the lock before both Session.close() and reader/writer joins: closing drains queued socket writes and can block on a slow peer, while a reader applying its final topology message can need the same domain lock. Neither wait may delay another peer's failover handshake. Reacquire the lock before generation and topology decisions. Topology messages from removed or replaced handlers are ignored; replacement monitors cannot be deleted by late cleanup of the old handler. Receipt cleanup remains after session closure and joins, and the full-server accepted-write delivery barrier remains in place. Offline-message dispatch, socket-write confirmation, and teardown now identify the recipient by a per-connection token. The token does not retain the handler or session. The shutdown continues to wait for a replacement with the same server ID after the old connection finishes closing.
  • Peer receipts and catch-up: incoming RS updates contribute to monitoring state separately from the outgoing cursor. A migrating DS can publish a newer CSN through a peer while older records remain queued locally, so the incoming maximum proves neither the older history nor its delivery. During ordered traversal, suppress only exact cached receipts and preserve older unknown records. The receipt cache is bounded by the existing queue capacity; eviction may cause a conservative resend. Peer generation changes and shutdown clear receipt knowledge. This fixes catch-up returning a peer's own DeleteMsg when its assured sender expects an acknowledgement.
  • History received through peers: record the newest peer update of each origin on the domain before changelog publication. This state is shared with newly registering RS handlers, so registration between receipt and persistence cannot hide a missing prefix. Before sending a queued direct update, compare its origin with peer history and reread the available prefix when needed. A still newer peer receipt cannot excuse older missing records. Local generation changes clear the history marker; covered markers avoid a full domain-state snapshot, and unavailable old-generation history cannot cause a retry loop. Idle peers and direct writes from another origin do not trigger generic third-party forwarding.
  • Local session closure: a blocked socket read can wake with SocketException after a local Session.close() but before the handler is marked shutting down. The reader now checks the session's close state, consistently with its EOF path and the writer. A genuine remote TCP reset still reports error 181; unexpected EOF from modern peers also remains an error. The harness does not broadly suppress shutdown disconnects.
  • Empty-RS recovery: only rs534 / scale-rs-empty sets REPLICATION_RECOVER_FROM_RS=1 on the returning RS. After scale-in has verified endpoint removal from every DS, bootstrap selects only ready, trusted RS peers and enables cn=admin data, leaving the new endpoint out of existing DS data-domain lists. Missing or unreadable sources are retried without falling back to a DS; source role and state are checked again under the join lock. A retained-history checkpoint must pass before scale-out DS restarts expose the endpoint. Final offline checks still compare every CSN. The mode is off by default, preserving ordinary bootstrap peer order and endpoint advertisement. ready remains a membership signal; the caller must enforce the history barrier.
  • Bootstrap cost: sequential administrative searches share one JVM while each request creates a fresh LDAP connection and parser. Positive, negative and stale JVM DNS caching are disabled for this worker so recreated peers are resolved afresh. Private FIFOs preserve arguments, output and LDAP status codes. A failed, malformed or timed-out worker is disabled and reads fall back to ordinary ldapsearch. Genuine LDAP errors retain their status. Existing batching of dsconfig changes and immediate one-use membership snapshots remain in place; topology data is not cached across mutations.
  • Partial bootstrap recovery: disable local replication using the local root account, without relying on an incomplete global-admin registry or changing remote peers. Verify that no local replication-domain/server configuration remains before enabling again. A persistent pending-reset marker keeps retries on the cleanup path even if a failed disable already removed the data domain. Disable, verification and join-lock release failures propagate; write and readiness gates stay closed during repair. A terminal bootstrap marker aborts harness waits, while ordinary predicate and Docker transport failures remain retryable. Failure artifacts retain filtered regular setup/replication/status tool logs.
  • Docker startup: run setup with --doNotStart, let its JVM exit, then start the server explicitly. This removes the setup/server/waiter memory overlap reproduced as an OOM kill at 512 MiB without swap. Preserve the final launcher probe output/status, an already-exited child status, container state and cgroup memory/OOM counters when startup fails.
  • Bootstrap completion: the entrypoint clears .bootstrap-finished on every start, including retained-container restarts, and creates it only after successful setup/upgrade and the requested background join. Both test harnesses require this positive result and give .bootstrap-failed priority. An absent join process during setup no longer counts as completion. Health remains separate so retained volumes preserve OrderedReady behavior while membership repair runs.
  • Stopped-container diagnostics: waits guard the nodes required by the current phase and abort if one exits or dies. Docker transport failures remain retryable, and deliberately stopped peers are excluded from these guards. The error trap preserves the original failure while collecting Docker exit/OOM state, container logs, server logs and filtered tool logs through docker cp, including from stopped containers. It avoids command-line/password-file dumps. Replication fixtures enable bootstrap timing and upload diagnostics in artifacts named by image flavor and workflow attempt.
  • Docker CI memory: remove the 512 MiB cap from 23 docker run sites in the replication fixture and Docker workflow, including failed-bootstrap and upgrade cases, and remove the two unused memory variables. OpenDJ test containers now use the memory available on the runner without a replacement Docker cap. The persistent search worker and all correctness checks remain enabled; removing the Docker cap does not change the JVM arguments or workload ceiling. The small non-Java shared-memory holder retains its separate 64 MiB cap. Scale scenarios already ran without the 512 MiB Docker cap.
  • Transient errors and convergence: a rolling startup timeout must occur before CORE135, and the same DS ID and domain must subsequently connect to a verified eligible RS before the log boundary captured after successful bootstrap in the recorded rolling window. Recovery may occur after CORE135. Require exactly one startup and one of the data, admin-data or schema domains; unknown peers/domains, later unrelated restarts, incomplete bootstrap and unrecovered timeouts remain failures. Record the exact timeout text and absolute log line; the filter accepts only that proven line, including recovered cn=admin data timeouts. During a separate-server roll, a surviving DS disconnect is accepted only for the stopped RS address and after a later successful connection to a verified eligible RS in the same domain and rolling window. The returned RS becomes eligible only during scale-out; accepted intervening timeouts must name the successful destination. Scale certificate warnings 119 and 105 also require recovery evidence for the returned RS. For 119, the same DS ID and domain must connect to that RS after the warning and by the end of scale-out. For 105, the pre-roll DS IP and a DS-side warning in the same logged second identify candidate paths, each of which must recover in a later second. The allowance applies to the exact warning line inside the original return window. RS certificate warning 312 requires a later 313 for the same RS ID, peer and domain inside the explicit replacement window. Unrecovered warnings and shutdown error 181 remain failures. The longer convergence budgets apply only to the two combined scale variants; the stable-zero criteria are unchanged.

CSN tracing and bootstrap timing are opt-in. The four scale rows and rs534 / empty-rs enable allocation traces; scale rows also enable bootstrap timing. Missing or unclosed traces fail validation. Failure collection first preserves the live state, then normally stops DS processes in parallel to close their traces; KEEP=1 leaves the containers running.

Validation

Review follow-up at 6ca519583a

  • The JDK 21 Maven reactor passed 162 selected tests with zero failures, errors, or skips. The replacement-session regression failed before the fix because the old teardown cleared the outstanding forward, then passed with per-session ownership.
  • The two-domain direct-update test recorded both timeout warnings and completed the forwarding wait in about 2.1 seconds with a shared 2-second budget. The LDAP test used a listener returning an entry followed by sizeLimitExceeded (4) and verified output, status and the next worker request. The shell fixture also compares partial LDIF byte for byte and verifies that the worker result does not trigger a fallback.
  • All 27 replication self-test files and the launcher self-test passed on macOS. The error filter passed 137 cases, including cross-domain, wrong-peer and out-of-window recovery checks. The launcher fixture checks exit 2, diagnostics with a still-running child, and that the final startability probe is skipped. git diff --check passed.
  • The new scale certificate checks were exercised with fixtures and archived logs. The full Docker convergence matrix has not yet been run on this head.

Previous validation at 7451e3f79f

Build 43994616243, attempt 1, on head 7451e3f79f, passed all 33 jobs. All nine Maven jobs, both Docker replication/upgrade fixture jobs, and all 13 convergence scenarios passed. CodeQL also passed on its first attempt. The scale scenarios completed the workload and online/offline checks within their configured limits:

Scenario Load Convergence phase
rs534 / scale-rs-kept 1036 s 108 s
rs534 / scale-rs-empty 1114 s 101 s
combined / scale-kept 1304 s 131 s
combined / scale-empty 1944 s 194 s

The previously failing rs534 / empty-rs scenario also passed. The Trivy check is neutral: GitHub could not compare alerts for trivy-image-alpine and trivy-image-latest because those configurations from master were not found on the PR.

The completed Build 43914906507, attempt 1, at preceding head 1cb60c42f9, finished with 29 successful jobs and four failures. Both complete Docker replication/upgrade fixture jobs and all nine Maven jobs passed. Head 7451e3f79f addressed the four failing rows:

Scenario Result at 1cb60c42f9 Corresponding correction
combined / scale-empty Passed all checks; workload 1746 s The previous 99-record gap and unexpected error 181 did not recur in this run.
combined / scale-kept Workload 2218 s; stable-zero phase completed in 510 s within the 900-second budget; final data/index/history checks passed, but one replay error 9 failed the row Prevent dependency re-parking after replay ownership transfers.
rs534 / scale-rs-kept Workload 2185 s; final data/index/history checks passed, but a recovered admin-data startup timeout failed the row Record exact same-DS/domain recovery after CORE135 and before observed successful bootstrap.
rs534 / scale-rs-empty Aborted during scaling after 715 s of load: a 50-second add segment averaged about 1.72 operations/s, below the 2/s floor, with zero LDAP errors while bootstrap commands were still running Complete the whole restarted group's bootstrap before resuming measured load.
rs534 / empty-rs A surviving RS handshake timed out during failover; DS writes were rejected with LDAP result 53 before reconnection Release the live RS domain lock before session closure can block on draining accepted writes.

Local verification at 7451e3f79f:

  • The combined 12-class Java run passed 242 tests, with zero failures or skips, in 136 seconds. It covers pending-change ownership, dependency ordering, selected replay-unwind paths, historical ordering, RS/session shutdown, reader/writer disconnects, missed-update recovery, catch-up and send-window handling. Existing disabled or excluded tests are not counted as executed; this is a targeted regression suite, not the full Maven suite.
  • Twelve new deterministic ownership cases failed before the fix and passed afterward, across ADD/MODIFY/DELETE/MODDN. They cover double handoff, clear plus same-CSN re-delivery and stale foreign-owner scans. Removing either the identity guard or the owner guard independently causes four expected failures.
  • Two new tests use real sessions and a real broker handshake while another DS or RS session's close is deliberately held in a socket flush. Both timed out before the lifecycle split and passed afterward. Reader-join, replacement-monitor and concurrent full-shutdown regressions also pass. The drain remains graceful; no new broker retry suppression or timeout increase was introduced.
  • All 27 replication shell/Python self-test files passed on macOS and Linux. Bootstrap tests cover every member of the group, active surviving writers, positive completion, terminal failure, retryable transport errors, worker failure and deadline exhaustion. Timeout tests reject mismatched domains/DSs, unknown peers, unrelated restarts, incomplete bootstrap and out-of-window recovery. Four harness mutations fail their intended assertions.
  • Replaying the saved CI bootstrap log changes the recovered-timeout result from zero accepted records to exactly one: DS8716, cn=admin data, with the original error text and line retained as evidence. Shell syntax, copyright checks and git diff --check pass.

The exact CI thread interleavings were not captured; the regressions reproduce concrete ownership and handshake-blocking mechanisms consistent with the failures. Bootstrap overlap is established by the saved timing logs; the new scheduling completed all four scale workloads within 2700 seconds in the CI run above. No heavy local OpenDJ/Docker load run was repeated on the busy host.

The 2700-second scale workload ceiling, 900/600/300-second convergence budgets, throughput floors and strict data/index/history/error checks remain unchanged. Longer bootstrap waits fail within those bounds rather than bypassing them.

@vharseko vharseko added enhancement docker CI replication tests Test suites: fixing, enabling, un-disabling data-loss Data integrity / loss of entries labels Nov 7, 2026
@vharseko vharseko changed the title [#1208] Test failover after rebuilding an RS while a DS is offline [#1208] Test replication failover and scaling under load Nov 8, 2026
@vharseko
vharseko force-pushed the feature/1208-empty-rs-failover branch from 9532545 to 79d77e0 Compare November 8, 2026 13:02
@vharseko vharseko added the performance Performance / concurrency / lock-contention work label Nov 9, 2026
@vharseko
vharseko force-pushed the feature/1208-empty-rs-failover branch 2 times, most recently from 2a7270a to 4b54dff Compare November 13, 2026 12:49
@vharseko vharseko added the java Changes to Java sources label Nov 13, 2026
@vharseko
vharseko force-pushed the feature/1208-empty-rs-failover branch 2 times, most recently from d4976d2 to 24d0455 Compare November 14, 2026 15:42
@vharseko vharseko changed the title [#1208] Test replication failover and scaling under load [#1208] Test replication scaling and drain updates during shutdown Nov 14, 2026
@vharseko vharseko changed the title [#1208] Test replication scaling and drain updates during shutdown [#1208] Preserve replication history during scaling and shutdown Nov 15, 2026
@vharseko vharseko added bug concurrency Thread-safety / race-condition bugs labels Nov 15, 2026
@vharseko vharseko changed the title [#1208] Preserve replication history during scaling and shutdown [#1208] Preserve replication history during scaling, recovery and shutdown Nov 15, 2026
@vharseko
vharseko force-pushed the feature/1208-empty-rs-failover branch from 5e6aef2 to 1cb60c4 Compare November 16, 2026 17:06
@vharseko
vharseko requested a review from maximthomas November 17, 2026 06:43

@maximthomas maximthomas left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

praise: The PR adds concrete ownership and delivery assertions around the concurrency paths it changes.

  • RemotePendingChanges.addDependency checks both pending-object identity and replay ownership before parking; each matching dependency branch stops immediately.
  • ReplicationServerShutdownSyncTest.shutdownForwardsRemoteDirectoryUpdatesToEveryPeer compares the exact delivered CSN sequence on both peers, including a peer held behind its send window.

issue (blocking): Old RS teardown can cancel the replacement handler's offline-message obligation.

opendj-server-legacy/src/main/java/org/opends/server/replication/server/ReplicationServerDomain.java:1393, :1361, :1375 — F-fe34bc52eb532c7384c0.

The new unlocked awaitShutdown() interval lets a same-ID replacement register and receive a freshly announced ReplicaOfflineMsg while the old handler is still closing. When the old wait finishes, its unconditional cleanup cancels current obligations using only the numeric ID:

localReplicationServer.getDSRSShutdownSync()
    .replicaOfflineMsgNotForwarded(baseDN, rsHandler.getServerId());

That can release collocated-DS shutdown before the replacement forwards its message. The new direct-update barrier cannot compensate because ReplicaOfflineMsg.contributesToDomainState() is false. The ID-only race existed in a narrow post-unlock interval at BASE; this PR expands it across potentially slow close/join operations.

Preserve handler/session ownership when cancelling forwarding obligations, or retire the old obligation atomically before replacement registration becomes possible. Pin: hold old teardown, connect a same-ID replacement, dispatch a fresh offline announcement with its send window closed, then release only the old teardown; DSRSShutdownSync.canShutdown(baseDN) must remain false until the replacement forwards or the real grace period expires. Independently verified by source tracing; not dynamically reproduced.


suggestion (non-blocking): Scale certificate allowances do not establish recovery of the affected DS-to-RS path.

.github/scripts/replication/assert-converged.sh:358, .github/scripts/replication/selftest-replication-errors.sh:207 — F-9571107b938a5f38cb07.

DS119 and RS105 warnings are accepted from their in-window node/endpoint match without a later successful connection. The existing fixture explicitly accepts a warning alone:

case_ new-cert-exact 0 1 '[ cert:n0:cv-r1' "$WBAD_RS" ']'

Scale membership and convergence can succeed through another RS; unlike disturb-empty-rs.sh, the scale rows do not force every DS onto the returned RS afterward. Pin: keep the warning as an error without a later same-DS/domain connection to that RS, and reject recovery records for another RS/domain. No persistent TLS defect or failing CI run is claimed.


suggestion (non-blocking): The new direct-forwarding deadline has no expiration regression across domains.

opendj-server-legacy/src/test/java/org/opends/server/replication/server/ReplicationServerShutdownSyncTest.java:552, :2520 — F-876871837fb39d9f4960.

The direct-update test releases the slow peer before asserting completion:

slow.openSendWindow(10);
stopped.get(SOCKET_TIMEOUT_MS, TimeUnit.MILLISECONDS);

The existing two-domain elapsed-time test arms DSRSShutdownSync without direct updates, so it exercises the separate offline-message grace period. Pin: populate direct-update targets in two domains, hold delivery, pass one short absolute deadline to both drains, and assert combined elapsed time plus timeout warnings; also protect the production caller's single deadline creation. The current production code passes the same deadline correctly by inspection.


suggestion (non-blocking): Worker tests do not cover LDAP entries followed by a failing final result.

opendj-ldap-toolkit/src/test/java/com/forgerock/opendj/ldap/tools/BootstrapSearchTestCase.java:38 — F-825a39aabf856b56f997.

The Java test only sends argument-parser/help requests, while the shell self-test substitutes a synthetic worker:

String input = request("--invalid-option") + request("--help");

Pin: use a controlled LDAP endpoint returning an entry followed by sizeLimitExceeded (4); compare output/status with ordinary ldapsearch, assert no fallback, and check a subsequent successful request in the same worker contains only its own entries. Source inspection supports the current output/status implementation; no current loss or false-success defect is claimed.


suggestion (non-blocking): Launcher tests do not cover a failed waiter while the server child remains alive.

.github/scripts/selftest-start-ds.sh:38 — F-01fcfa7cdf40cb627857.

The waiter stub always waits for child termination and succeeds:

while kill -0 "$(cat "$INSTANCE_ROOT/logs/server.pid")" 2>/dev/null; do sleep 0.01; done
exit 0

Pin: return waiter status 2 while a controlled child remains alive; assert bounded launcher completion, exit 2, WaitForFileDelete diagnostics with child status running, and no final checkStartability probe. Clean up the child afterward. The current implementation preserves this behavior by inspection; no runtime hang or status defect is established.

…recovery

Track peer history across RS registration and generation changes, and replay a missing prefix before a later direct update can advance the outgoing cursor. Ignore socket-read failures caused by a local session close while retaining unexpected peer-loss errors. Add ordering, registration, generation-reset and socket-close regressions.

Allow 900 seconds for retained combined-node convergence based on the observed CI backlog drain. Preserve the 2700-second workload ceiling and strict data, history and throughput checks.
@vharseko
vharseko force-pushed the feature/1208-empty-rs-failover branch from 7451e3f to 6ca5195 Compare November 18, 2026 07:28
@vharseko

Copy link
Copy Markdown
Member Author

@maximthomas I addressed all five points in 6ca519583a.

  1. Offline forwarding ownership. The dispatch, write callback, and cancellation now use a per-connection token. The regression holds the old teardown, connects a replacement with the same ID, and keeps its send window closed. Before the fix, releasing the old teardown made canShutdown() return true. With the fix, it stays false until the replacement forwards the message.
  2. Scale TLS checks. A 119 allowance now requires a later connection from the same DS ID and domain to the returned RS by the end of scale-out. For 105, the RS-side warning must correlate by DS IP and logged second with a DS-side warning to that endpoint. Every matching path must then recover in a later second. Allowances apply to the exact warning lines in the original replacement window.
  3. Shared forwarding deadline. The new test holds a direct-update backlog in two domains and exercises the drain used by production shutdown. Both domains warn after one shared 2-second budget.
  4. Partial LDAP result. A real test listener returns an entry followed by sizeLimitExceeded (4). The worker preserves the ordinary LDAP search output and status, and a subsequent request returns only its own entry. The shell fixture verifies exact LDIF bytes and the absence of a fallback.
  5. Failed launcher waiter. The self-test returns 2 from the waiter while the child is still alive and checks the launcher exit status, the status running diagnostic, and that no final startability probe runs.

The targeted JDK 21 reactor passed 162 tests. All 27 replication self-tests and the launcher self-test passed. The full Docker convergence matrix has yet to run on this head.

@vharseko
vharseko requested a review from maximthomas November 18, 2026 07:29
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

bug CI concurrency Thread-safety / race-condition bugs data-loss Data integrity / loss of entries docker enhancement java Changes to Java sources performance Performance / concurrency / lock-contention work replication tests Test suites: fixing, enabling, un-disabling

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants