tina4ruby 3.13.36 → 3.13.38

data/lib/tina4/rack_app.rb

@@ -351,9 +351,12 @@ module Tina4
       env["tina4.request"] = request  # Store for session save after response
       response = Tina4::Response.new
 
-      # Run global middleware (block-based + class-based before_* methods)
+      # Run global middleware (block-based + class-based before_* methods).
+      # M2 — AFTER-ON-4xx RULE: when a before_* short-circuits (4xx/skip) or
+      # throws (clean 500), the after-pass STILL runs so after_* can add
+      # headers/logging — consistent across all 4 frameworks.
       unless Tina4::Middleware.run_before(Tina4::Middleware.global_middleware, request, response)
-        # Middleware halted the request -- return whatever response was set
+        Tina4::Middleware.run_after(Tina4::Middleware.global_middleware, request, response)
         return response.to_rack
       end
 
@@ -885,18 +888,23 @@ module Tina4
       # Wire the route handler into the WebSocket engine events
       handler = ws_route.handler
 
-      # Create a dedicated WebSocket engine for this route so handlers stay isolated
+      # Create a dedicated WebSocket *event* engine for this route so each
+      # upgrade keeps its own isolated open/message/close handlers (the engine's
+      # on() appends handlers, so a single shared event engine would cross-wire
+      # routes).
       ws = Tina4::WebSocket.new
 
-      # The dev-reload channel is held by a process-wide shared manager so a
-      # broadcast from POST /__dev/api/reload reaches every browser, not just
-      # the connections of this one isolated per-socket engine. Mirrors
-      # Python's single _ws_manager keyed on the /__dev_reload path.
+      # The connection itself is OWNED by a process-wide shared manager so that
+      # broadcasts, rooms, the multi-instance backplane and the idle reaper span
+      # every route's connections — not just this one per-socket event engine.
+      # Mirrors Python's single WebSocketManager. The dev-reload channel uses its
+      # own shared manager (Tina4::DevReload) so POST /__dev/api/reload reaches
+      # every browser.
       dev_reload = ws_route.path == "/__dev_reload"
+      manager = dev_reload ? Tina4::DevReload.manager : @websocket_engine
 
       ws.on(:open) do |connection|
         connection.params = ws_params
-        Tina4::DevReload.add(connection) if dev_reload
         handler.call(connection, :open, nil)
       end
 
@@ -905,7 +913,6 @@ module Tina4
       end
 
       ws.on(:close) do |connection|
-        Tina4::DevReload.remove(connection) if dev_reload
         handler.call(connection, :close, nil)
       end
 
@@ -913,7 +920,7 @@ module Tina4
         Tina4::Log.error("WebSocket error on #{ws_route.path}: #{error.message}")
       end
 
-      ws.handle_upgrade(env, socket)
+      ws.handle_upgrade(env, socket, manager: manager)
 
       # Return async response (-1 signals Rack the response is handled via hijack)
       [-1, {}, []]

data/lib/tina4/response.rb

@@ -347,18 +347,38 @@ module Tina4
         gen = @_stream_generator
         blk = @_stream_block
         body = Enumerator.new do |yielder|
-          if gen
-            if gen.respond_to?(:each)
-              # Enumerator / array / any Enumerable of string chunks
-              gen.each { |chunk| yielder << chunk }
-            elsif gen.respond_to?(:call)
-              # Callable that receives the yielder, like the block form
-              gen.call(yielder)
-            else
-              yielder << gen.to_s
+          # SSE hardening: a streaming source that raises mid-stream (a
+          # generator/block error, or the client disconnecting and the server
+          # tearing the body down) must NEVER crash the worker. We catch the
+          # error, log it, and end the stream cleanly — the chunks emitted
+          # before the failure are still delivered.
+          #
+          # A client disconnect surfaces in a hijack/Puma streaming body as a
+          # write-side IOError/Errno on the socket; that is propagated up as a
+          # normal stop and re-raised so Rack/Puma can close the connection,
+          # while a *source* error is swallowed after logging.
+          begin
+            if gen
+              if gen.respond_to?(:each)
+                # Enumerator / array / any Enumerable of string chunks
+                gen.each { |chunk| yielder << chunk }
+              elsif gen.respond_to?(:call)
+                # Callable that receives the yielder, like the block form
+                gen.call(yielder)
+              else
+                yielder << gen.to_s
+              end
+            elsif blk
+              blk.call(yielder)
             end
-          elsif blk
-            blk.call(yielder)
+          rescue IOError, Errno::EPIPE, Errno::ECONNRESET => e
+            # Client disconnected mid-stream — stop cleanly, do not crash, and
+            # do not log loudly (a normal browser closing an SSE stream).
+            Tina4::Log.debug("SSE/stream client disconnected: #{e.class}: #{e.message}") if defined?(Tina4::Log)
+          rescue StandardError => e
+            # The source (generator/block) itself raised mid-stream. Log it and
+            # end the stream cleanly rather than crashing the handler/worker.
+            Tina4::Log.error("SSE/stream source error: #{e.class}: #{e.message}") if defined?(Tina4::Log)
           end
         end
         return [@status_code, final_headers, body]