Fixes #39208 - Cache global registration script in smart-proxy

[pablomh]

Problem

GET /register returns the same shell script for all hosts sharing the same registration parameters (org, location, hostgroup, activation keys). Under bulk registration — 100+ hosts hitting the same capsule simultaneously — this endpoint is called once per host, each time proxying to Foreman and waiting for the ERB template to render (~103ms in profiling). With WEBrick's MaxClients=100, all threads can be held waiting for identical Foreman responses.

Solution

Cache the rendered script in memory (5-minute TTL) keyed on a canonical form of the request query string (parameters sorted alphabetically, so requests differing only in parameter order share the same cache entry).

Per-key double-checked locking prevents the thundering herd on a cold cache while allowing concurrent requests for genuinely different keys (e.g. different activation keys) to fetch from Foreman in parallel without blocking each other:

• Fast path: unsynchronised Concurrent::Map read, no lock acquired
• Slow path: key-specific Mutex serialises only competing threads; re-checks under lock before fetching from Foreman

The per-key Mutex is evicted from KEY_MUTEXES immediately after the script is written to cache, so KEY_MUTEXES is empty under steady state and bounded to in-flight fetches only.

Only 2xx responses are cached — errors never poison the cache. SCRIPT_CACHE uses Concurrent::Map (already a smart-proxy dependency) for lock-free reads that are safe on all Ruby VMs.

Test plan

• Cache hit: Foreman called once for repeated identical requests
• Per-key isolation: different parameter sets cached independently
• Parameter order independence: requests differing only in param order share the same cache entry
• TTL expiry: expired entries are not served; Foreman is re-called
• Mutex eviction: KEY_MUTEXES is empty after a successful cache write
• Error non-caching: Foreman is called on every request when it errors

Fixes #39208

[ekohl]

In Ruby you can pass blocks and that creates a nice abstraction mechanism. In somewhat pseudo-code:

CACHE = {}
MUTEX = Mutex.new

def cache(key, &block)
  if (value = CACHE[key])
    value
  else
    MUTEX.synchronize do
      CACHE[key] = block.call
    end
  end
end 

def get_value(query)
  cache(query) do
    real_call_here(query)
  end
end

You may need to do something like raising an exception to handle errors from Foreman code (in handle_response) so it doesn't get cached.

[ekohl]

If this is HTTP 201 or 202 I wouldn't expect it to be cached. Only HTTP 200.