fix(streaming): real inference backend wiring and lifecycle fixes; full suite green

- token_generator: backend is now an optional real rtx-inference engine (RwLock<Option<Arc<InferenceEngine>>>) with ServingTokenizer support; set_backend/set_tokenizer plumbing through StreamingServer - connection_manager: ConnectionPool::acquire no longer errors when the idle cache is full — creates fresh connections up to max_connections - streaming_server: ServerState::Running on construction; stream_inference generates one token per step (chunk_size semantics) - lifecycle bugs surfaced by the newly-compiling integration tests: * start(): broadcast control-channel send with zero subscribers was treated as fatal ("channel closed") in RealtimePipeline, EdgeComputingManager, MonitoringSystem — now tolerated * stop(): AdaptiveProcessor/EdgeComputingManager/MonitoringSystem awaited worker interval loops that never exit (test hung 5h) — workers are now aborted with cancellation-aware join - integration_tests: removed stale .await on now-synchronous methods cargo test -p rtx-streaming: 55 lib + 8 integration + 6 aux, all passing. Co-Authored-By: Claude Fable 5 <[email protected]>
2026-07-10 15:48:33 -07:00
parent 73102b71cf
commit a0bf29461b
10 changed files with 235 additions and 57 deletions
@@ -456,28 +456,34 @@ impl ConnectionPool {

            Ok(connection)
        } else {
-            // Create new connection if pool has capacity
-            if self.stats.read().current_size < self.config.max_size {
-                let connection = PooledConnection {
-                    id: Uuid::new_v4(),
-                    created_at: Instant::now(),
-                    last_used: Instant::now(),
-                    usage_count: 1,
-                    state: PoolConnectionState::InUse,
-                };
+            // No idle connection cached for reuse: create a fresh one on demand.
+            //
+            // `max_size` bounds how many *idle* connections this pool caches for
+            // reuse (a soft sizing knob for reuse efficiency), not the total
+            // number of connections the system may ever create — overall
+            // concurrency is enforced by `ConnectionManager::config.max_connections`
+            // in `create_connection`. Refusing to create a connection here just
+            // because the idle cache is full would turn a reuse-cache limit into
+            // a spurious hard connection cap and drop otherwise-valid clients.
+            let connection = PooledConnection {
+                id: Uuid::new_v4(),
+                created_at: Instant::now(),
+                last_used: Instant::now(),
+                usage_count: 1,
+                state: PoolConnectionState::InUse,
+            };

-                // Update stats
-                {
-                    let mut stats = self.stats.write();
-                    stats.total_created += 1;
+            // Update stats
+            {
+                let mut stats = self.stats.write();
+                stats.total_created += 1;
+                if stats.current_size < self.config.max_size {
                    stats.current_size += 1;
-                    stats.hit_rate = (stats.hit_rate * 0.9) + (0.0 * 0.1); // Miss
                }
-
-                Ok(connection)
-            } else {
-                Err(StreamingError::Connection("Pool exhausted".to_string()))
+                stats.hit_rate = (stats.hit_rate * 0.9) + (0.0 * 0.1); // Miss
            }
+
+            Ok(connection)
        }
    }