taski 0.8.2 → 0.9.0

data/lib/taski/execution/task_output_router.rb

@@ -22,10 +22,10 @@ module Taski
       READ_BUFFER_SIZE = 4096
       MAX_RECENT_LINES = 30 # Maximum number of recent lines to keep per task
 
-      def initialize(original_stdout, execution_context = nil)
+      def initialize(original_stdout, execution_facade = nil)
         super()
         @original = original_stdout
-        @execution_context = execution_context
+        @execution_facade = execution_facade
         @pipes = {}         # task_class => TaskOutputPipe
         @thread_map = {}    # Thread => task_class
         @recent_lines = {}  # task_class => Array<String>
@@ -50,27 +50,22 @@ module Taski
         end
       end
 
-      # Stop the background polling thread
       def stop_polling
         synchronize { @polling = false }
         @poll_thread&.join(0.5)
         @poll_thread = nil
       end
 
-      # Start capturing output for the current thread
-      # Creates a new pipe for the task and registers the thread mapping
-      # @param task_class [Class] The task class being executed
       def start_capture(task_class)
         synchronize do
           pipe = TaskOutputPipe.new(task_class)
           @pipes[task_class] = pipe
           @thread_map[Thread.current] = task_class
-          debug_log("Started capture for #{task_class} on thread #{Thread.current.object_id}")
+          Taski::Logging.debug(Taski::Logging::Events::OUTPUT_ROUTER_START_CAPTURE, task: task_class.name)
         end
       end
 
-      # Stop capturing output for the current thread
-      # Closes the write end of the pipe and drains remaining data
+      # Closes the write end and drains remaining data.
       def stop_capture
         task_class = nil
         pipe = nil
@@ -78,41 +73,20 @@ module Taski
         synchronize do
           task_class = @thread_map.delete(Thread.current)
           unless task_class
-            debug_log("Warning: stop_capture called for unregistered thread #{Thread.current.object_id}")
+            Taski::Logging.debug(Taski::Logging::Events::OUTPUT_ROUTER_STOP_CAPTURE_UNREGISTERED)
             return
           end
 
           pipe = @pipes[task_class]
           pipe&.close_write
-          debug_log("Stopped capture for #{task_class} on thread #{Thread.current.object_id}")
+          Taski::Logging.debug(Taski::Logging::Events::OUTPUT_ROUTER_STOP_CAPTURE, task: task_class.name)
         end
 
         # Drain any remaining data from the pipe after closing write end
         drain_pipe(pipe) if pipe
       end
 
-      # Drain all remaining data from a pipe
-      # Called after close_write to ensure all output is captured
-      def drain_pipe(pipe)
-        return if pipe.read_closed?
-
-        loop do
-          data = pipe.read_io.read_nonblock(READ_BUFFER_SIZE)
-          debug_log("drain_pipe read #{data.bytesize} bytes for #{pipe.task_class}")
-          store_output_lines(pipe.task_class, data)
-        rescue IO::WaitReadable
-          # Check if there's more data with a very short timeout
-          ready, = IO.select([pipe.read_io], nil, nil, 0.001)
-          break unless ready
-        rescue IOError
-          # All data has been read (EOFError) or pipe was closed by another thread
-          synchronize { pipe.close_read }
-          break
-        end
-      end
-
-      # Poll all open pipes for available data
-      # Should be called periodically from the display thread
+      # Called periodically from the display thread.
       def poll
         readable_pipes = synchronize do
           @pipes.values.reject { |p| p.read_closed? }.map(&:read_io)
@@ -129,25 +103,21 @@ module Taski
 
           read_from_pipe(pipe)
         end
-      rescue IOError
+      rescue IOError, Errno::EBADF
         # Pipe was closed by another thread (drain_pipe), ignore
       end
 
-      # Get the last output line for a task
-      # @param task_class [Class] The task class
-      # @return [String, nil] The last output line
       def last_line_for(task_class)
         synchronize { @recent_lines[task_class]&.last }
       end
 
-      # Get recent output lines for a task (up to MAX_RECENT_LINES)
-      # @param task_class [Class] The task class
-      # @return [Array<String>] Recent output lines
-      def recent_lines_for(task_class)
-        synchronize { (@recent_lines[task_class] || []).dup }
+      def read(task_class, limit: nil)
+        synchronize do
+          lines = (@recent_lines[task_class] || []).dup
+          limit ? lines.last(limit) : lines
+        end
       end
 
-      # Close all pipes and clean up
       def close_all
         synchronize do
           @pipes.each_value(&:close)
@@ -156,8 +126,6 @@ module Taski
         end
       end
 
-      # Check if there are any active (not fully closed) pipes
-      # @return [Boolean] true if there are active pipes
       def active?
         synchronize do
           @pipes.values.any? { |p| !p.read_closed? }
@@ -219,9 +187,7 @@ module Taski
         @original.winsize
       end
 
-      # Get the write IO for the current thread's pipe
-      # Used by Task#system to redirect subprocess output directly to the pipe
-      # @return [IO, nil] The write IO or nil if not capturing
+      # Used by Task#system to redirect subprocess output to the pipe.
       def current_write_io
         synchronize do
           task_class = @thread_map[Thread.current]
@@ -232,7 +198,6 @@ module Taski
         end
       end
 
-      # Delegate unknown methods to original stdout
       def method_missing(method, ...)
         @original.send(method, ...)
       end
@@ -243,6 +208,24 @@ module Taski
 
       private
 
+      def drain_pipe(pipe)
+        return if pipe.read_closed?
+
+        loop do
+          data = pipe.read_io.read_nonblock(READ_BUFFER_SIZE)
+          Taski::Logging.debug(Taski::Logging::Events::OUTPUT_ROUTER_DRAIN_PIPE, task: pipe.task_class.name, bytes: data.bytesize)
+          store_output_lines(pipe.task_class, data)
+        rescue IO::WaitReadable
+          # Check if there's more data with a very short timeout
+          ready, = IO.select([pipe.read_io], nil, nil, 0.001)
+          break unless ready
+        rescue IOError, Errno::EBADF
+          # All data has been read (EOFError) or pipe was closed by another thread
+          synchronize { pipe.close_read }
+          break
+        end
+      end
+
       def current_thread_pipe
         synchronize do
           task_class = @thread_map[Thread.current]
@@ -256,7 +239,7 @@ module Taski
         store_output_lines(pipe.task_class, data)
       rescue IO::WaitReadable
         # No data available yet
-      rescue IOError
+      rescue IOError, Errno::EBADF
         # Pipe closed by writer (EOFError) or by another thread, close read end
         synchronize { pipe.close_read }
       end
@@ -269,20 +252,20 @@ module Taski
           @recent_lines[task_class] ||= []
           lines.each do |line|
             stripped = line.chomp
-            @recent_lines[task_class] << stripped unless stripped.strip.empty?
+            next if stripped.strip.empty?
+            @recent_lines[task_class] << stripped
+            Taski::Logging.debug(
+              Taski::Logging::Events::TASK_OUTPUT,
+              task: task_class.name,
+              line: stripped
+            )
           end
-          # Keep only the last MAX_RECENT_LINES
           if @recent_lines[task_class].size > MAX_RECENT_LINES
             @recent_lines[task_class] = @recent_lines[task_class].last(MAX_RECENT_LINES)
           end
-          debug_log("store_output_lines: #{task_class} now has #{@recent_lines[task_class].size} lines")
+          Taski::Logging.debug(Taski::Logging::Events::OUTPUT_ROUTER_STORE_LINES, task: task_class.name, line_count: @recent_lines[task_class].size)
         end
       end
-
-      def debug_log(message)
-        return unless ENV["TASKI_DEBUG"]
-        warn "[TaskOutputRouter] #{message}"
-      end
     end
   end
 end