nat/allocator: extract persistent-lease reuse from allocate_translation (#4409 increment 1)

[psaab]

Addresses #4409 (increment 1: extract reuse_existing_lease_locked from the allocate_translation god-function; further increments / the Phase-1 lock-free change tracked).

What

Pure code-motion. The 57-line #2397 persistent-NAT lease-reuse block is lifted out of PortAllocator::allocate_translation (userspace-dp/src/nat/allocator.rs) into a new private helper:

fn reuse_existing_lease_locked(&self, live: &mut PortAllocatorLiveState,
                               key, flow, persistent_nat_timeout_ns, now_ns)
    -> Option<TranslatedTuple>

Some(tuple) = a still-valid lease was reused (caller returns Ok(tuple)); None = no lease existed, or an expired one was reclaimed and the caller proceeds to a fresh allocation. The inner return Ok(translated) maps to the helper's Some; the call site is now a four-line if let Some(t) = self.reuse_existing_lease_locked(...) { return Ok(t); }.

Why this is pure code-motion (behaviour + lock scope identical)

• Mutation order + side effects unchanged: reuses_total bump, live_by_flow insert, lease-expiration index removal, release_translated_locked, persistent_by_source.remove — all in the same order.
• Lock scope unchanged: allocate_translation still holds its Mutex<PortAllocatorLiveState> guard across the whole call and passes it to the helper by &mut. Nothing runs outside the existing critical section. The only textual change beyond the move is &mut live -> live at the internal helper calls (inside the helper live is already &mut PortAllocatorLiveState).
• NOT the userspace-dp NAT: PortAllocator serializes all fast-path SNAT allocations on one global Mutex — destroys multi-core scaling at high new-flow rates #2852 Phase-1 lock-free contention refactor (a behaviour change, tracked separately — needs full triple-review). This increment is a plain extract-function to shrink the god-function.

Remaining on #4409

• allocator.rs: separate the hot bitmap/allocation state from the cold config/stats/GC state (the harder split flagged as needing /triple-review — hot-path).
• source.rs / tests.rs splits.
• The userspace-dp NAT: PortAllocator serializes all fast-path SNAT allocations on one global Mutex — destroys multi-core scaling at high new-flow rates #2852 Phase-1 lock-free change.

Validation

• Full cargo test: 3830 passed / 0 failed (2 pre-existing ignored). NAT subset (nat::): 205 / 0.
• cargo build clean (warnings all pre-existing).
• rustfmt-clean on the changed lines (the one remaining local-rustfmt diff is the pre-existing use-ordering at line 42, untouched — repo is not fmt-clean under local rustfmt).

🤖 Generated with Claude Code

https://claude.ai/code/session_015oARShYtiJJ2H4UB4nXGqi

[Copilot]

Pull request overview

This PR is a small refactor in the Rust userspace dataplane NAT allocator: it extracts the persistent-NAT “reuse an existing lease if still valid” block out of PortAllocator::allocate_translation into a private helper, reducing the size/complexity of the allocation function while keeping behavior and lock scope the same.

Changes:

• Extracted persistent-lease reuse logic into reuse_existing_lease_locked(...) -> Option<TranslatedTuple>.
• Replaced the inline reuse block in allocate_translation with a short if let Some(...) { return Ok(...) } call.
• Logged the refactor increment in _Log.md.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 1 comment.

File	Description
userspace-dp/src/nat/allocator.rs	Extracts the persistent-lease reuse block into a new private helper and updates the call site.
_Log.md	Adds an entry documenting the refactor increment and touched files.