module CommandRunner

# File lib/command_runner.rb, line 215
def self.create(*args, timeout: nil, environment: {}, allowed_sub_commands: [], debug_log: nil, split_stderr: false, encoding: nil, options: DEFAULT_OPTIONS)
  CommandInstance.new(args, timeout, environment, allowed_sub_commands, debug_log, split_stderr, encoding, options)
end

# File lib/command_runner.rb, line 178
def self.ensure_command_output_encoded(string, command, encoding = nil)
  return '' if !string

  return string if encoding.nil? ||  encoding != :safe

  encodingName = 'UTF-8'

  firstPass = string.force_encoding(encodingName)

  return firstPass if firstPass.valid_encoding?

  encoded = firstPass.encode(encodingName, encodingName,
                        invalid: :replace,
                        undef: :replace,
                        replace: "")

  return encoded if encoded.valid_encoding?

  raise EncodingError, %Q{
    Could not force #{encodingName} encoding on this string:
    #{string}
    which is the output of this command:
    #{command}
  }
end

# File lib/command_runner.rb, line 58
def self.run(*args, timeout: nil, environment: {}, debug_log: nil, split_stderr: false, encoding: nil, options: DEFAULT_OPTIONS)
  if debug_log.nil?
    debug_log = @@global_debug_log
  end

  # If args is an array of strings, allow that as a shorthand for [arg1, arg2, arg3]
  if args.length > 1 && args.all? {|arg| arg.is_a? String}
    args = [args]
  end

  # This could be tweakable through vararg opts
  tick = 0.1

  now = Time.now

  # Build deadline_sequence. A list of deadlines and corresponding actions to take
  if timeout
    if timeout.is_a? Numeric
      deadline_sequence = [{:deadline => now + timeout, :action => 'KILL'}]
    elsif timeout.is_a? Hash
      deadline_sequence = timeout.collect do |t, action|
        unless action.is_a? Integer or action.is_a? String or action.is_a? Proc
            raise "Unsupported action type '#{action.class}'. Must be Integer, String, or Proc"
        end
        unless t.is_a? Numeric
          raise "Unsupported timeout value '#{t}'. Must be a Numeric"
        end
        {:deadline => now + t, :action => action}
      end.sort! { |a, b| a[:deadline] <=> b[:deadline]}
    else
      raise "Unsupported type for timeout paramter: #{timeout.class}"
    end
  else
    deadline_sequence = [{:deadline => MAX_TIME, :action => 0}]
  end

  if split_stderr
    err_r, err_w = IO.pipe
    errbuf = ""
    options = options.merge({:err => err_w})
  end

  # Spawn child, merging stderr into stdout
  io = IO.popen(environment, *args, options)
  debug_log.puts("CommandRunnerNG spawn: args=#{args}, timeout=#{timeout}, encoding=#{encoding}, options: #{options}, PID: #{io.pid}") if debug_log.respond_to?(:puts)
  data = ""

  err_w.close if split_stderr

  # Run through all deadlines until command completes.
  # We could merge this block into the selecting block above,
  # but splitting like this saves us a Process.wait syscall per iteration.
  eof = false
  deadline_sequence.each do |point|
    while Time.now < point[:deadline]
      if Process.wait(io.pid, Process::WNOHANG)
        read_nonblock_safe!(io, data, tick)
        read_nonblock_safe!(err_r, errbuf, 0) if split_stderr
        result = {:out => ensure_command_output_encoded(data, args.join(" "), encoding), :status => $?, pid: io.pid}
        if split_stderr
          result[:err] = ensure_command_output_encoded(errbuf, args.join(" "), encoding)
          err_r.close
        end
        debug_log.puts("CommandRunnerNG exit: PID: #{io.pid}, code: #{result[:status].exitstatus}") if debug_log.respond_to?(:puts)
        io.close
        return result
      elsif !eof
        eof = read_nonblock_safe!(io, data, tick)
        read_nonblock_safe!(err_r, errbuf, 0) if split_stderr
      end
    end

    # Deadline for this point reached. Fire the action.
    action = point[:action]
    debug_log.puts("CommandRunnerNG timeout: PID: #{io.pid}, action: #{action}") if debug_log.respond_to?(:puts)
    if action.is_a? String or action.is_a? Integer
      Process.kill(action, io.pid)
    elsif action.is_a? Proc
      begin
        action.call(io.pid)
      rescue => e
        # If the action block throws and error, clean up and rethrow
        begin
          Process.kill('KILL', io.pid)
        rescue
          # process already dead
        end
        Process.wait(io.pid)
        io.close
        raise e
      end
    else
      # Given the assertions when building the deadline_sequence this should never be reached
      raise "Internal error in CommandRunnerNG. Child may be left unattended!"
    end
  end

  # Either we didn't have a deadline, or none of the deadlines killed off the child.
  loop do
    dead = read_nonblock_safe!(io, data, tick)
    read_nonblock_safe!(err_r, errbuf, 0) if split_stderr
    break if dead
  end
  Process.wait(io.pid)

  result = {:out => ensure_command_output_encoded(data, args.join(" "), encoding), :status => $?, pid: io.pid}
  if split_stderr
    result[:err] = ensure_command_output_encoded(errbuf, args.join(" "), encoding)
    err_r.close
  end

  debug_log.puts("CommandRunnerNG exit: PID: #{io.pid}, code: #{result[:status].exitstatus}") if debug_log.respond_to?(:puts)

  io.close

  result
end

# File lib/command_runner.rb, line 221
def self.set_debug_log!(logger)
  if logger.respond_to?(:puts) || logger.nil?
    @@global_debug_log = logger
  else
    raise ArgumentError.new("Logger '#{logger}' not responding to :puts")
  end
end

# File lib/command_runner.rb, line 283
def self.read_nonblock_safe!(io, data_out, tick)
  IO.select([io], nil, nil, tick)
  begin
    # Read all available data until EAGAIN or EOF
    loop do
      data_out << io.read_nonblock(4096)
    end
  rescue IO::WaitReadable
    # Ignore: tick time reached without io
    return false
  rescue EOFError
    # Child closed stdout (probably dead, but not necessarily)
    return true
  end
end