foruiman 0.1.2 → 0.3.0

data/lib/foruiman/engine.rb

@@ -11,29 +11,39 @@ class Foruiman::Engine
   TERM_TIMEOUT = 5.0
   READ_CHUNK = 4096
   READ_BUDGET = 64 * 1024
+  INPUT_BUDGET = 64 * 1024
   State = Struct.new(:name, :process, :port, :pid, :pgid, :status, :exit_status,
                      :generation, :restart_pending, :deadline, :reaped, :group_gone,
+                     :input, :input_buffer,
                      keyword_init: true)
   Event = Data.define(:type, :name, :pid, :status, :record, :message)
 
-  attr_reader :logs, :env, :processes, :root, :procfile_path
+  attr_reader :logs, :env, :processes, :root, :procfile_path, :term_timeout, :exit_on
 
-  def initialize(procfile: nil, root: Dir.pwd, env: ENV.to_h, port: 5000, log_lines: 10_000,
-                 term_timeout: TERM_TIMEOUT)
+  def initialize(procfile: nil, root: Dir.pwd, env: ENV.to_h, input: $stdin, port: 5000, log_lines: 10_000,
+                 term_timeout: TERM_TIMEOUT, exit_on: :all)
     raise Foruiman::Error, "port must be an integer in 1..65535" unless port.is_a?(Integer) && (1..65_535).cover?(port)
     raise Foruiman::Error, "log-lines must be a positive integer" unless log_lines.is_a?(Integer) && log_lines.positive?
+    unless term_timeout.is_a?(Numeric) && term_timeout.real? && term_timeout.finite? && term_timeout >= 0
+      raise Foruiman::Error, "timeout must be a finite nonnegative number"
+    end
+    raise Foruiman::Error, "exit-on must be all, any, or failure" unless %i[all any failure].include?(exit_on)
 
     @root = File.expand_path(root)
     raise Foruiman::Error, "working directory does not exist: #{@root}" unless File.directory?(@root)
 
     @env = env.dup.freeze
+    @input = input
+    @managed_input = false
     @base_port = port
     @log_lines = log_lines
     @term_timeout = term_timeout
+    @exit_on = exit_on
     @processes = []
     @names = {}
     @running = {}
     @readers = {}
+    @inputs = {}
     @listeners = []
     @shutdown = false
     @explicit_shutdown = false
@@ -57,7 +67,8 @@ class Foruiman::Engine
     Foruiman::Procfile.new[name] = command
     process = Foruiman::Process.new(command, cwd: root, env: env)
     state = State.new(name: name.freeze, process: process, port: @base_port + (processes.size * 100),
-                      status: :pending, generation: 0, restart_pending: false, reaped: true, group_gone: true)
+                      status: :pending, generation: 0, restart_pending: false, reaped: true, group_gone: true,
+                      input_buffer: +"".b)
     @names[name] = state
     processes << state
     state
@@ -100,6 +111,16 @@ class Foruiman::Engine
     self
   end
 
+  # Give every child a dedicated pseudo-terminal for stdin. The TUI remains the
+  # sole reader of the real terminal and explicitly forwards input to one child.
+  def manage_input!
+    raise Foruiman::Error, "cannot change input mode after startup" if @started
+
+    require "pty"
+    @managed_input = true
+    self
+  end
+
   def start(name = nil)
     raise Foruiman::Error, "supervisor is closed" if @closed
     return if @shutdown
@@ -145,6 +166,33 @@ class Foruiman::Engine
     terminate(entry)
   end
 
+  def write_input(name, bytes)
+    entry = state(name)
+    return false unless entry.status == :running && entry.input && !entry.input.closed?
+    return false if entry.input_buffer.bytesize + bytes.bytesize > INPUT_BUDGET
+
+    entry.input_buffer << bytes.b
+    flush_input(entry)
+  rescue IOError, SystemCallError
+    false
+  end
+
+  def interrupt_process(name)
+    entry = state(name)
+    return unless entry.pgid
+
+    signal_group(entry, :INT)
+    self
+  end
+
+  def resize_inputs(rows, columns)
+    processes.each do |entry|
+      entry.input&.winsize = [rows, columns]
+    rescue IOError, SystemCallError
+      nil
+    end
+  end
+
   def shutdown(explicit: true)
     @explicit_shutdown ||= explicit
     return if @shutdown
@@ -165,7 +213,9 @@ class Foruiman::Engine
   end
 
   def exit_code
-    @explicit_shutdown || !@failed ? 0 : 1
+    return 0 if @explicit_shutdown
+
+    @policy_exit_code || (@failed ? 1 : 0)
   end
 
   def run(keep_open: false)
@@ -189,9 +239,11 @@ class Foruiman::Engine
     shutdown if @signal_requested
     reap_children
     advance_groups
-    ready = IO.select([@self_reader, *@readers.keys], nil, nil, timeout)&.first || []
+    writable = processes.filter_map { |entry| entry.input unless entry.input_buffer.empty? }
+    ready, writable = IO.select([@self_reader, *@readers.keys], writable, nil, timeout) || [[], []]
     drain_signal_pipe if ready.delete(@self_reader)
     shutdown if @signal_requested
+    writable.each { |input| flush_input(@inputs.fetch(input)) if @inputs.key?(input) }
     read_output(ready)
     reap_children
     advance_groups
@@ -224,16 +276,20 @@ class Foruiman::Engine
 
     stdout_reader, stdout_writer = create_pipe
     stderr_reader, stderr_writer = create_pipe
+    input_master, input_slave = create_managed_input if @managed_input
     begin
       pid = entry.process.run(output: stdout_writer, error: stderr_writer,
+                              input: input_slave || @input,
                               env: { "PORT" => entry.port.to_s, "PS" => "#{entry.name}.1" })
     rescue SystemCallError => e
       stdout_reader.close
       stderr_reader.close
+      input_master&.close
       entry.status = :failed
       entry.restart_pending = false
       @failed = true
       lifecycle(entry, :failed, "failed to start: #{e.message}")
+      apply_exit_policy(1)
       return
     end
     entry.pid = entry.pgid = pid
@@ -243,12 +299,19 @@ class Foruiman::Engine
     entry.restart_pending = false
     entry.deadline = nil
     entry.reaped = entry.group_gone = false
+    entry.input = input_master
+    entry.input_buffer.clear
     @running[pid] = entry
     [[stdout_reader, :stdout], [stderr_reader, :stderr]].each do |reader, stream|
       @readers[reader] = [entry, Foruiman::Output.new(logs, name: entry.name, stream: stream, pid: pid)]
     end
+    if input_master
+      @inputs[input_master] = entry
+      @readers[input_master] = [entry, Foruiman::Output.new(logs, name: entry.name, stream: :stdin, pid: pid)]
+    end
     lifecycle(entry, :started, "started with pid #{pid} (generation #{entry.generation})")
   ensure
+    input_slave&.close
     stdout_writer&.close
     stderr_writer&.close
     [stdout_reader, stderr_reader].compact.each do |reader|
@@ -278,13 +341,22 @@ class Foruiman::Engine
       entry.reaped = true
       entry.exit_status = result.last
       success = entry.exit_status.success?
-      @failed ||= !success && !%i[stopping restarting].include?(entry.status)
-      entry.status = success ? :exited : :failed unless %i[stopping restarting].include?(entry.status)
+      transitioning = %i[stopping restarting].include?(entry.status)
+      @failed ||= !success && !transitioning
+      entry.status = success ? :exited : :failed unless transitioning
       lifecycle(entry, :exited, termination_message_for(entry.exit_status))
+      apply_exit_policy(entry.exit_status.exitstatus || (128 + entry.exit_status.termsig)) unless transitioning
       terminate(entry)
     end
   end
 
+  def apply_exit_policy(code)
+    return if @shutdown || exit_on == :all || (exit_on == :failure && code.zero?)
+
+    @policy_exit_code = code
+    shutdown(explicit: false)
+  end
+
   def advance_groups
     processes.each do |entry|
       next unless entry.pgid
@@ -299,6 +371,7 @@ class Foruiman::Engine
       next unless entry.reaped && entry.group_gone
       next if @readers.any? { |_reader, (owner, _output)| owner.equal?(entry) }
 
+      close_input(entry)
       entry.pgid = nil
       entry.deadline = nil
       entry.status = :stopped if entry.status == :stopping
@@ -328,16 +401,19 @@ class Foruiman::Engine
       break if budget <= 0
 
       entry, output = @readers.fetch(reader)
-      bytes = reader.read_nonblock(READ_CHUNK, exception: false)
-      if bytes.nil? || (bytes == :wait_readable && entry.group_gone)
-        @readers.delete(reader)
-        reader.close
-        output.feed("", eof: true)
-      elsif bytes != :wait_readable
-        budget -= bytes.bytesize
-        output.feed(bytes)
-        # Rotate serviced readers to the back for the next select.
-        @readers[reader] = @readers.delete(reader)
+      begin
+        bytes = reader.read_nonblock(READ_CHUNK, exception: false)
+        if bytes.nil? || (bytes == :wait_readable && entry.group_gone)
+          finish_reader(reader, entry, output)
+        elsif bytes != :wait_readable
+          budget -= bytes.bytesize
+          output.feed(bytes)
+          # Rotate serviced readers to the back for the next select.
+          @readers[reader] = @readers.delete(reader)
+        end
+      rescue Errno::EIO
+        # PTY masters report EIO when the child closes the slave side.
+        finish_reader(reader, entry, output)
       end
     end
     # A daemon that escaped the group may still hold a pipe open. Drain available
@@ -346,10 +422,48 @@ class Foruiman::Engine
       entry, output = @readers.fetch(reader)
       next unless entry.group_gone && !ready.include?(reader)
 
-      @readers.delete(reader)
-      reader.close
-      output.feed("", eof: true)
+      finish_reader(reader, entry, output)
+    end
+  end
+
+  def create_managed_input
+    master, slave = PTY.open
+    [master, slave].each do |io|
+      io.binmode
+      io.close_on_exec = true
     end
+    [master, slave]
+  end
+
+  def flush_input(entry)
+    return if entry.input_buffer.empty? || !entry.input
+
+    written = entry.input.write_nonblock(entry.input_buffer, exception: false)
+    entry.input_buffer.slice!(0, written) if written.is_a?(Integer)
+    true
+  rescue IOError, SystemCallError
+    reader = entry.input
+    finish_reader(reader, entry, @readers.fetch(reader).last) if reader && @readers.key?(reader)
+    false
+  end
+
+  def finish_reader(reader, entry, output)
+    @readers.delete(reader)
+    @inputs.delete(reader)
+    entry.input = nil if entry.input.equal?(reader)
+    reader.close unless reader.closed?
+    output.feed("", eof: true)
+  end
+
+  def close_input(entry)
+    input = entry.input
+    return unless input
+
+    @inputs.delete(input)
+    @readers.delete(input)
+    input.close unless input.closed?
+    entry.input = nil
+    entry.input_buffer.clear
   end
 
   def lifecycle(entry, type, message)

data/lib/foruiman/env.rb

@@ -28,8 +28,11 @@ class Foruiman::Env
   def self.load(root: Dir.pwd, file: nil, dotenv: true, inherited: ENV.to_h)
     env = inherited.dup
     default = File.join(root, ".env")
-    env.merge!(new(default).to_h) if dotenv && File.file?(default)
-    env.merge!(new(file).to_h) if file
+    if file
+      Array(file).each { |filename| env.merge!(new(filename).to_h) }
+    elsif dotenv && File.file?(default)
+      env.merge!(new(default).to_h)
+    end
     env.transform_values { |value| value.dup.freeze }.freeze
   end
 end

data/lib/foruiman/output.rb

@@ -8,7 +8,7 @@ class Foruiman::Output
   def initialize(logs, name:, stream:, pid:)
     @logs = logs
     @metadata = { name: name, stream: stream, pid: pid }
-    @decoder = Foruiman::ANSI::Decoder.new
+    @decoder = Foruiman::ANSI::Decoder.new(line_controls: true)
     @styles = Foruiman::ANSI::Styles.new
     @text = +""
     @previous = nil
@@ -18,20 +18,25 @@ class Foruiman::Output
 
   def feed(bytes, eof: false)
     decoded = @decoder.feed(bytes, eof: eof)
-    decoded.scan(/\e\[[0-9;:]*m|\n|[^\e\n]+/).each do |token|
+    decoded.scan(/\e\[[0-9;:]*[mGCDK]|[\n\r\b]|[^\e\n\r\b]+/).each do |token|
       if token == "\n"
         if @split_boundary && !@dirty && !@previous
           @split_boundary = false
         else
           publish(true)
         end
+      elsif token == "\r" || token == "\b" || token.match?(/\A\e\[\d*[GCDK]\z/)
+        require_relative "output_line"
+        @line ||= Foruiman::OutputLine.new(@text)
+        @line.control(token, limit: MAX_BYTES / 2)
+        @dirty = true
       elsif token.start_with?("\e[")
         split_record if @text.bytesize + token.bytesize > MAX_BYTES
-        @text << token
+        @text << token unless @line
         @styles.apply(token)
         @dirty = true
       else
-        append_text(token)
+        @line ? edit_text(token) : append_text(token)
       end
     end
     if eof
@@ -43,6 +48,17 @@ class Foruiman::Output
 
   private
 
+  def edit_text(text)
+    text.scan(/\X/).each do |character|
+      if @line.cost + character.bytesize + @styles.prefix.bytesize + 4 > MAX_BYTES / 2
+        split_record
+        @line = Foruiman::OutputLine.new(@text)
+      end
+      @line.write(character, @styles.prefix)
+      @dirty = true
+    end
+  end
+
   def append_text(text)
     until text.empty?
       available = MAX_BYTES - @text.bytesize
@@ -66,11 +82,13 @@ class Foruiman::Output
 
   def publish(complete)
     @split_boundary = false
+    @text = @line.to_s if @line
     @previous = @logs.write(**@metadata, text: @text, complete: complete, previous: @previous)
     @dirty = false
     return unless complete
 
     @text = +@styles.prefix
+    @line = nil
     @previous = nil
   end
 end

data/lib/foruiman/output_line.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "unicode/display_width"
+require_relative "ansi"
+
+# A single editable terminal row. Used only after a child emits a horizontal
+# cursor control; ordinary append-only logs keep their fast streaming path.
+class Foruiman::OutputLine
+  attr_reader :cost
+
+  def initialize(text)
+    @cells = []
+    @cursor = 0
+    @cost = 0
+    styles = Foruiman::ANSI::Styles.new
+    text.scan(/\e\[[0-9;:]*m|\X/).each do |token|
+      if token.match?(Foruiman::ANSI::SGR)
+        styles.apply(token)
+      else
+        write(token, styles.prefix)
+      end
+    end
+  end
+
+  def write(character, style)
+    width = Unicode::DisplayWidth.of(character, emoji: :all)
+    if width.zero? && @cursor.positive?
+      index = @cursor - 1
+      index -= 1 while index.positive? && @cells[index] == :continuation
+      @cells[index][0] += character if @cells[index].is_a?(Array)
+    else
+      width.times { |offset| clear_cell(@cursor + offset) }
+      @cells[@cursor] = [character, style]
+      (1...width).each { |offset| @cells[@cursor + offset] = :continuation }
+      @cursor += width
+    end
+    # Conservative, constant-time bound including style transitions.
+    @cost += character.bytesize + style.bytesize + Foruiman::ANSI::RESET.bytesize
+  end
+
+  def control(token, limit:)
+    @cost = to_s.bytesize
+    number = token[/\d+/].to_i
+    amount = [number, 1].max
+    case token
+    when "\r" then @cursor = 0
+    when "\b" then @cursor = [@cursor - 1, 0].max
+    else
+      case token[-1]
+      when "G" then @cursor = (amount - 1).clamp(0, limit)
+      when "C" then @cursor = (@cursor + amount).clamp(0, limit)
+      when "D" then @cursor = [@cursor - amount, 0].max
+      when "K" then erase(number)
+      end
+    end
+  end
+
+  def to_s
+    style = ""
+    @cells.each_with_object(+"") do |cell, text|
+      next if cell == :continuation
+
+      character, next_style = cell || [" ", ""]
+      if next_style != style
+        text << Foruiman::ANSI::RESET unless style.empty?
+        text << next_style
+        style = next_style
+      end
+      text << character
+    end
+  end
+
+  private
+
+  def clear_cell(index)
+    if @cells[index] == :continuation
+      start = index - 1
+      start -= 1 while start.positive? && @cells[start] == :continuation
+      @cells[start] = nil
+    end
+    following = index + 1
+    while @cells[following] == :continuation
+      @cells[following] = nil
+      following += 1
+    end
+    @cells[index] = nil
+  end
+
+  def erase(mode)
+    case mode
+    when 0
+      clear_cell(@cursor) if @cursor < @cells.size
+      @cells.slice!(@cursor..) if @cursor < @cells.size
+    when 1
+      [@cursor + 1, @cells.size].min.times { |index| clear_cell(index) }
+    when 2 then @cells.clear
+    end
+    @cost = to_s.bytesize
+  end
+end

data/lib/foruiman/process.rb

@@ -12,7 +12,7 @@ class Foruiman::Process
 
   def run(options = {})
     ::Process.spawn(env.merge(options.fetch(:env, {})), "/bin/sh", "-c", command,
-                    chdir: cwd, in: File::NULL, out: options.fetch(:output, $stdout),
+                    chdir: cwd, in: options.fetch(:input, $stdin), out: options.fetch(:output, $stdout),
                     err: options.fetch(:error, $stderr), pgroup: true, unsetenv_others: true,
                     close_others: true)
   end

data/lib/foruiman/tui/application.rb

@@ -22,13 +22,16 @@ module Foruiman::TUI
     end
 
     def run
+      @engine.manage_input!
       @terminal.session do
         @engine.run(keep_open: true) do
           rows, columns = @terminal.size
+          @engine.resize_inputs(rows, columns)
+          detach_unavailable_input
           input = @terminal.read
           @engine.shutdown if input.nil?
-          height = [Renderer.log_height(rows: rows, columns: columns), 1].max
-          @keyboard.feed(input.is_a?(String) ? input : "").each { |key| handle(key, height) }
+          height = [Renderer.log_height(rows: rows, columns: columns, input: state.input?), 1].max
+          read_keys(input.is_a?(String) ? input : "", height)
           state.feedback = nil if monotonic >= @feedback_until
           next if monotonic < @next_frame_at && @was_shutting_down == @engine.shutting_down?
 
@@ -66,7 +69,9 @@ module Foruiman::TUI
       when :toggle_follow then state.viewport.toggle(buffer, height)
       when :help then state.help = !state.help
       when :escape then state.help = false
-      when :restart, :stop then control(key)
+      when :restart then control(key)
+      when :stop then toggle_process
+      when :input then begin_input
       when :restart_all, :stop_all
         control_all(key == :restart_all ? :restart : :stop)
       when :quit then @engine.shutdown
@@ -75,6 +80,76 @@ module Foruiman::TUI
 
     private
 
+    def read_keys(bytes, height)
+      @keyboard.feed("").each { |key| handle(key, height) } unless state.input?
+      bytes.bytes.each_with_index do |byte, index|
+        if state.input?
+          forward_input(bytes.byteslice(index..))
+          break
+        end
+        @keyboard.feed(byte.chr).each { |key| handle(key, height) }
+      end
+    end
+
+    def begin_input
+      if state.name == "all"
+        feedback("Select a process before entering input mode")
+      elsif @engine.state(state.name).status != :running
+        feedback("#{state.name} is not running")
+      else
+        state.help = false
+        state.viewport.follow
+        state.input_target = state.name
+        state.feedback = nil
+      end
+    end
+
+    def forward_input(bytes)
+      name = state.input_target
+      state.input_line.feed(bytes).each do |event|
+        case event
+        when :detach
+          state.input_target = nil
+          feedback("Returned from #{name}")
+        when :interrupt then @engine.interrupt_process(name)
+        when :eof then send_input(name, "\x04")
+        when Array then send_input(name, "#{event.last}\n")
+        end
+      end
+    end
+
+    def send_input(name, bytes)
+      return if @engine.write_input(name, bytes)
+
+      state.input_target = nil
+      feedback("Input unavailable for #{name}")
+    end
+
+    def detach_unavailable_input
+      return unless state.input?
+      return if @engine.state(state.input_target).status == :running
+
+      name = state.input_target
+      state.input_target = nil
+      feedback("Input closed for #{name}")
+    end
+
+    def toggle_process
+      if state.name == "all"
+        control_all(:stop)
+        return
+      end
+
+      entry = @engine.state(state.name)
+      if entry.pgid
+        @engine.stop(state.name)
+        feedback("Stopping #{state.name}")
+      else
+        @engine.start(state.name)
+        feedback("Starting #{state.name}")
+      end
+    end
+
     def control(action)
       if state.name == "all"
         if action == :restart