bwrap 1.0.0.pre.alpha1

data/lib/bwrap/execution/labels.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "bwrap/version"
+require_relative "execution"
+
+# Exit codes for exit status handling.
+#
+# These are not strictly speaking related to execution system,
+# but rather to handle execution status of actual scripts.
+# For example, to set exit code for {Bwrap::Output#error} call.
+#
+# Since this is fully own module, it shouldn’t harm for this to be here.
+module Bwrap::Execution::Labels
+  # If we had a successful run, i.e. no error happened.
+  NO_ERROR = 0
+
+  # Do not use.
+  INVALID_ERROR = 1
+
+  # When Output#error has been called with no :label.
+  UNSPECIFIED_ERROR = 2
+
+  # If no better error code has been created.
+  GENERIC_ERROR = 3
+
+  # Converts given label to real exit code.
+  #
+  # @param label [Symbol] Label to be converted to a exit code
+  #
+  # Accepted labels:
+  # - :success
+  # - :unspecified
+  # - :generic
+  # - :target_host_not_found
+  # - :no_package_manager
+  # - :debootstrap_failed
+  # - :file_not_modified
+  #
+  # Additional labels can be added with {.add_label}.
+  #
+  # @return [Integer] Exit code between 0 to 255
+  def self.resolve_exit_code label
+    return @additional_labels[label] if @additional_labels and @additional_labels[label]
+
+    case label
+    when :success
+      NO_ERROR
+    when :unspecified
+      UNSPECIFIED_ERROR
+    when :generic
+      GENERIC_ERROR
+    else
+      warn "Got invalid error label: #{label}"
+      INVALID_ERROR
+    end
+  end
+
+  # Add a custom label.
+  #
+  # @param label [Symbol] Name of exit code label
+  # @param exit_code [Integer] Number in range 0-255
+  def self.add_label label, exit_code
+    @additional_labels ||= {}
+    @additional_labels[label] = exit_code
+  end
+end

data/lib/bwrap/execution.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "bwrap/version"
+require "bwrap/output"
+require_relative "execution/execute"
+
+# @abstract Module to be included in a class that needs to execute commands.
+#
+# Methods to execute processes.
+module Bwrap::Execution
+  include Bwrap::Output
+
+  # Unspecified execution related error.
+  class CommandError < StandardError
+  end
+
+  # Signifies that command execution has failed.
+  class ExecutionFailed < CommandError
+  end
+
+  # Actual implementation of execution command. Can be used when static method is needed.
+  #
+  # @note When an array is given as a command, empty strings are passed as empty arguments.
+  #
+  #   This means that `[ "foo", "bar" ]` passes one argument to "foo" command, when
+  #   `[ "foo", "", "bar" ]` passes two arguments.
+  #
+  #   This may or may not be what is assumed, so it can’t be fixed here. It is up to the
+  #   command to decide how to handle empty arguments.
+  #
+  # Returns pid of executed command if wait is false.
+  # Returns command output if wait is true.
+  #
+  # fail == If true, an error is raised in case the command returns failure code.
+  #
+  # @param error if :show, warn()s output of the command is shown if execution failed.
+  #
+  # @see #execute
+  def self.do_execute command,
+                      fail: true,
+                      wait: true,
+                      log: true,
+                      direct_output: false,
+                      env: {},
+                      clear_env: false,
+                      error: nil,
+                      log_callback: 2,
+                      rootcmd: nil
+    command = Execute.format_command command, rootcmd: rootcmd
+    Execute.handle_logging command, log_callback: log_callback, log: log, dry_run: @dry_run
+    return if @dry_run || Bwrap::Execution::Execute.dry_run
+
+    Execute.open_pipes direct_output
+
+    # If command is an array, there can’t be arrays inside the array.
+    # For convenience, the array is flattened here, so callers can construct commands more easily.
+    if command.respond_to? :flatten!
+      command.flatten!
+    end
+
+    # If command is string, splat operator (the *) does not do anything. If array, it expand the arguments.
+    # This causes spawning work correctly, as that’s how spawn() expects to have the argu
+    pid = spawn(env, *command, err: [ :child, :out ], out: Execute.w, unsetenv_others: clear_env)
+    output = Execute.finish_execution(log: log, wait: wait, direct_output: direct_output)
+    return pid unless wait
+
+    # This is instant return, but allows us to have $?/$CHILD_STATUS set.
+    Process.wait pid
+    @last_status = $CHILD_STATUS
+
+    output = Execute.process_output output: output
+    Execute.handle_execution_fail fail: fail, error: error, output: output
+    output
+  ensure
+    Execute.clean_variables
+  end
+
+  # Returns Process::Status instance of last execution.
+  #
+  # @note This only is able to return the status if wait is true, as otherwise caller is assumed to
+  # handle execution flow.
+  def self.last_status
+    @last_status
+  end
+
+  # Check if requested program can be found.
+  #
+  # Should work cross-platform and in restricted environents pretty well.
+  private def command_available? command
+    exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [ "" ]
+    ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+      exts.each do |ext|
+        exe = File.join(path, "#{command}#{ext}")
+        return true if File.executable?(exe) && !File.directory?(exe)
+      end
+    end
+    false
+  end
+
+  # Returns path to given executable.
+  private def which command, fail: true
+    exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [ "" ]
+    ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+      exts.each do |ext|
+        exe = File.join(path, "#{command}#{ext}")
+        return exe if File.executable?(exe) && !File.directory?(exe)
+      end
+    end
+    error "Failed to find #{command} from PATH." if fail
+    nil
+  end
+
+  # Execute a command.
+  #
+  # This method can be used by including Execution module in a class that should be able to
+  # execute commands.
+  #
+  # @see .do_execute .do_execute for documentation of argument syntax
+  private def execute *args
+    # Mangle proper location to error message.
+    if args.last.is_a? Hash
+      args.last[:log_callback] = 3
+    else
+      args << { log_callback: 3 }
+    end
+    Bwrap::Execution.do_execute(*args)
+  end
+
+  # Same as ::execute, but uses log: false to avoid unnecessary output when we’re just getting a
+  # value for internal needs.
+  #
+  # Defaults to fail: false, since when one just wants to get the value, there is not that much
+  # need to unconditionally die if getting bad exit code.
+  private def execvalue *args, fail: false, rootcmd: nil, env: {}
+    # This logging handling is a bit of duplication from execute(), but to be extra safe, it is duplicated.
+    # The debug message contents will always be evaluated, so can just do it like this.
+    log_command = args[0].respond_to?(:join) && args[0].join(" ") || args[0]
+    log_command =
+        if log_command.frozen?
+          log_command.dup.force_encoding("UTF-8")
+        else
+          log_command.force_encoding("UTF-8")
+        end
+    if @dry_run
+      puts "Would execvalue “#{log_command}” at #{caller_locations(1, 1)[0]}"
+      return
+    end
+    trace "Execvaluing “#{log_command}” at #{caller_locations(1, 1)[0]}"
+    execute(*args, fail: fail, log: false, rootcmd: rootcmd, env: env)
+  end
+
+  private def exec_success?
+    $CHILD_STATUS.success?
+  end
+
+  private def exec_failure?
+    !exec_success?
+  end
+
+  # When running through bundler, don’t use whatever it defines as we’re running inside chroot.
+  private def clean_execute
+    if (Bundler&.bundler_major_version) >= 2
+      Bundler.with_unbundled_env do
+        yield 2
+      end
+    elsif Bundler&.bundler_major_version == 1
+      Bundler.with_clean_env do
+        yield 1
+      end
+    else
+      yield nil
+    end
+  rescue NameError
+    # If NameError is thrown, no Bundler is available.
+    yield nil
+  end
+end

data/lib/bwrap/output/colors.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "output"
+
+# Methods to color CLI output.
+module Bwrap::Output::Colors
+  # Outputs ANSI true color sequence.
+  def self.color red, green, blue, bold: false
+    return unless $stdout.tty?
+    return if ENV["COLORTERM"] != "truecolor" && ENV["COLORTERM"] != "24bit"
+
+    out = ""
+    out += "\x1b[38;1;1m" if bold
+    # https://stackoverflow.com/questions/4842424/list-of-ansi-color-escape-sequences
+    out += "\x1b[38;2;#{red};#{green};#{blue}m"
+
+    out
+  end
+
+  # Outputs ANSI command to stop color output.
+  def self.stopcolor
+    return unless $stdout.tty?
+    return if ENV["COLORTERM"] != "truecolor" && ENV["COLORTERM"] != "24bit"
+
+    "\x1b[0m"
+  end
+
+  # Calls `Bwrap::Output::Colors#color`.
+  private def color red, green, blue, bold: false
+    Bwrap::Output::Colors.color red, green, blue, bold
+  end
+
+  # Calls `Bwrap::Output::Colors#stopcolor`.
+  private def stopcolor
+    Bwrap::Output::Colors.stopcolor
+  end
+end

data/lib/bwrap/output/levels.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "colors"
+
+# Output level functionality.
+class Bwrap::Output::Levels
+  include Bwrap::Output::Colors
+
+  @@_verbose = false
+  @@_debug = false
+  @@_trace = ENV["BWRAP_TRACE"] && true || false
+
+  # @see Bwrap::Output#verbose?
+  def self.verbose?
+    @@_verbose
+  end
+
+  # @see Bwrap::Output##debug?
+  def self.debug?
+    @@_debug
+  end
+
+  # @see Bwrap::Output##trace?
+  def self.trace?
+    @@_trace
+  end
+
+  # Takes hash of options received from Optimist and checks output related flags.
+  def self.handle_output_options options
+    # Set output level flags to true or false, if it was given.
+    unless options[:trace].nil?
+      @@_verbose = options[:trace]
+      @@_debug = options[:trace]
+      @@_trace = options[:trace]
+    end
+    unless options[:debug].nil?
+      @@_verbose = options[:debug]
+      @@_debug = options[:debug]
+    end
+    unless options[:verbose].nil?
+      @@_verbose = options[:verbose]
+    end
+  end
+
+  # Formats given string and outputs it.
+  #
+  # @return formatted string
+  def self.trace_print_formatted str, log_callback: 1
+    out = "#{Bwrap::Output::Colors.color(230, 165, 240)}[TRACE]#{Bwrap::Output::Colors.stopcolor} #{str}"
+    out = append_caller out, log_callback: (log_callback + 1)
+    puts out
+
+    out
+  end
+
+  # Formats given string and outputs it.
+  #
+  # @return formatted string
+  def self.debug_print_formatted str, log_callback: 1
+    out = "#{Bwrap::Output::Colors.color(190, 190, 190)}[DEBUG]#{Bwrap::Output::Colors.stopcolor} #{str}"
+    out = append_caller out, log_callback: (log_callback + 1)
+    puts out
+
+    out
+  end
+
+  # Formats given string and outputs it.
+  #
+  # @return formatted string
+  def self.verbose_print_formatted str, log_callback: 1
+    out = "#{Bwrap::Output::Colors.color(130, 230, 130, bold: true)}[INFO]#{Bwrap::Output::Colors.stopcolor} #{str}"
+    out = append_caller out, log_callback: (log_callback + 1)
+    puts out
+
+    out
+  end
+
+  # Formats given string and outputs it.
+  #
+  # @return formatted string
+  def self.warning_print_formatted str, log_callback: 1
+    out = "#{Bwrap::Output::Colors.color(190, 190, 110, bold: true)}[WARN]#{Bwrap::Output::Colors.stopcolor} #{str}"
+    out = "#{out} (called at #{caller_locations(log_callback, 1)[0]})" if @@_debug or @@_trace
+    $stderr.puts out
+
+    out
+  end
+
+  # Formats given string and outputs it.
+  def self.error_print_formatted str, log_callback: 1
+    out = "#{Bwrap::Output::Colors.color(230, 110, 110, bold: true)}[ERROR]#{Bwrap::Output::Colors.stopcolor} #{str}"
+    out = "#{out} (called at #{caller_locations(log_callback, 1)[0]})" if @@_debug or @@_trace
+    $stderr.puts out
+  end
+
+  # Private class method.
+  #
+  # Appends caller information to given output.
+  #
+  # Used by *_print_formatted methods.
+  def self.append_caller out, log_callback: 1
+    out = "#{out} (called at #{caller_locations(log_callback, 1)[0]})" if @@_trace
+    out
+  end
+  private_class_method :append_caller
+end

data/lib/bwrap/output/log.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: false
+
+# force_encoding modifies string, so can’t freeze strings.
+
+require_relative "output"
+
+# Logging methods.
+class Bwrap::Output::Log
+  @@log_file = nil
+
+  # Get handle of opened log file.
+  def self.log_file
+    @@log_file
+  end
+
+  # Writes given string to log.
+  def self.write_to_log str
+    @@log_file&.write str.force_encoding("UTF-8")
+  end
+
+  # Writes given string to log.
+  def self.puts_to_log str
+    @@log_file&.puts str.force_encoding("UTF-8")
+  end
+
+  # Closes an open log file.
+  def self.close_log_file
+    @@log_file&.close
+    @@log_file = nil
+  end
+
+  # Starts logging to given file.
+  def self.log_to_file log_path
+    log_file = File.open log_path, "w"
+
+    # In default mode, log messages disappears as Ruby’s own buffer gets full.
+    # This makes only OS buffer being used.
+    log_file.sync = false
+
+    @@log_file = log_file
+
+    at_exit do
+      ::Bwrap::Output::Log.close_log_file
+    end
+  end
+end
+

data/lib/bwrap/output/output.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bwrap/version"
+
+# Outputting utilities.
+module Bwrap::Output
+  # Nya.
+end

data/lib/bwrap/output.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# Have variables like $CHILD_STATUS which is alias of $?.
+require "English"
+
+require "bwrap/execution/labels"
+require_relative "output/colors"
+require_relative "output/levels"
+require_relative "output/log"
+
+# Extends the module with outputting methods.
+module Bwrap::Output
+  include Bwrap::Output::Colors
+
+  # @see #verbose?
+  def self.verbose?
+    Bwrap::Output::Levels.verbose?
+  end
+
+  # @see #debug?
+  def self.debug?
+    Bwrap::Output::Levels.debug?
+  end
+
+  # @see #trace?
+  def self.trace?
+    Bwrap::Output::Levels.trace?
+  end
+
+  # Takes hash of options received from Optimist and checks output related flags.
+  def self.handle_output_options options
+    Bwrap::Output::Levels.handle_output_options options
+  end
+
+  # Handler used by #trace to output given string.
+  def self.trace_output str, raw: false, log_callback: 1
+    return unless trace?
+
+    if raw
+      print str
+    else
+      out = Bwrap::Output::Levels.trace_print_formatted str, log_callback: (log_callback + 1)
+    end
+    Bwrap::Output::Log.puts_to_log out || str
+  end
+
+  # Handler used by #debug to output given string.
+  def self.debug_output str, raw: false, log_callback: 1
+    return unless debug?
+
+    if raw
+      print str
+    else
+      out = Bwrap::Output::Levels.debug_print_formatted str, log_callback: (log_callback + 1)
+    end
+    Bwrap::Output::Log.puts_to_log out || str
+  end
+
+  # Handler used by #verb to output given string.
+  def self.verb_output str, raw: false, log_callback: 1
+    return unless verbose?
+
+    if raw
+      print str
+    else
+      out = Bwrap::Output::Levels.verbose_print_formatted str, log_callback: (log_callback + 1)
+    end
+    Bwrap::Output::Log.puts_to_log out || str
+  end
+
+  # Handler used by #warn to output given string.
+  def self.warn_output str, raw: false, log_callback: 1
+    if raw
+      print str
+    else
+      out = Bwrap::Output::Levels.warning_print_formatted str, log_callback: (log_callback + 1)
+    end
+    Bwrap::Output::Log.puts_to_log out || str
+  end
+
+  # Aborts current process.
+  #
+  # Use this instead of Ruby’s #exit in order to filter out dummy #exit calls from the code.
+  def self.error_output str = nil, label: :unspecified, log_callback: 1
+    unless str.nil?
+      out = Bwrap::Output::Levels.error_print_formatted str, log_callback: (log_callback + 1)
+      Bwrap::Output::Log.puts_to_log out
+    end
+
+    exit Bwrap::Execution::Labels.resolve_exit_code(label)
+  end
+
+  # @return true if --verbose, --debug or --trace has been passed, false if not.
+  private def verbose?
+    Bwrap::Output::Levels.verbose?
+  end
+
+  # @return true if --debug or --trace has been passed, false if not.
+  private def debug?
+    Bwrap::Output::Levels.debug?
+  end
+
+  # @return true if --trace has been passed, false if not.
+  private def trace?
+    Bwrap::Output::Levels.trace?
+  end
+
+  # Outputs given string if trace flag has been set.
+  #
+  # Output flags can be set with {.handle_output_options}.
+  #
+  # @param str String to be outputted
+  # @param raw [Boolean] If true, disables output formatting
+  private def trace str, raw: false
+    Bwrap::Output.trace_output(str, raw: raw, log_callback: 2)
+  end
+
+  # Outputs given string if debug flag has been set.
+  #
+  # Output flags can be set with {.handle_output_options}.
+  #
+  # @param str String to be outputted
+  # @param raw [Boolean] If true, disables output formatting
+  private def debug str, raw: false
+    Bwrap::Output.debug_output(str, raw: raw, log_callback: 2)
+  end
+
+  # Outputs given string if verbose flag has been set.
+  #
+  # Output flags can be set with {.handle_output_options}.
+  #
+  # @param str String to be outputted
+  # @param raw [Boolean] If true, disables output formatting
+  private def verb str, raw: false
+    Bwrap::Output.verb_output(str, raw: raw, log_callback: 2)
+  end
+
+  # Outputs given string to `$stderr`.
+  #
+  # @param str String to be outputted
+  # @param raw [Boolean] If true, disables output formatting
+  private def warn str, raw: false
+    Bwrap::Output.warn_output(str, raw: raw, log_callback: 2)
+  end
+
+  # Outputs given string to `$stderr` and halts execution.
+  #
+  # @param str String to be outputted
+  # @param label [Symbol] Exit label accepted by {Bwrap::Execution.resolve_exit_code}
+  private def error str = nil, label: :unspecified
+    Bwrap::Output.error_output(str, label: label, log_callback: 2)
+  end
+end

data/lib/bwrap/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# bwrap command runner tools.
+module Bwrap
+  # Current version of bwrap.
+  VERSION = "1.0.0-alpha1"
+end
+
+require "deep-cover" if ENV["DEEP_COVER"]

data/lib/bwrap.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "optimist"
+
+#require "deep-cover" if ENV["DEEP_COVER"]
+
+require "bwrap/version"
+require "bwrap/args/construct"
+require "bwrap/config"
+require "bwrap/execution"
+
+# Executes bwrap command using given configuration.
+class Bwrap::Bwrap
+  include Bwrap::Execution
+
+  def initialize config
+    @config = config
+
+    parse_command_line_arguments
+  end
+
+  # Runs given command inside bwrap.
+  #
+  # @param command [String, Array] Command, with necessary arguments, to be executed inside bwrap
+  def run command
+    construct = Bwrap::Args::Construct.new
+    construct.config = @config
+    bwrap_args = construct.construct_bwrap_args
+
+    exec_command = [ "bwrap" ]
+    exec_command += bwrap_args
+    exec_command += %W{ #{command} --new-instance }
+    exec_command += ARGV unless ARGV.empty?
+
+    execute exec_command
+
+    construct.cleanup
+  end
+
+  # Parses command line arguments given to caller script.
+  private def parse_command_line_arguments
+    options = optimist_cli_args
+
+    Bwrap::Output.handle_output_options options
+  end
+
+  # Parses global bwrap flags using Optimist.
+  private def optimist_cli_args
+    Optimist.options do
+      version ::Bwrap::VERSION
+
+      banner "Usage:"
+      banner "  #{$PROGRAM_NAME} [global options]\n \n"
+      banner "Global options:"
+      opt :verbose,
+          "Show verbose output",
+          short: "v"
+      opt :debug,
+          "Show debug output (useful when debugging a problem)",
+          short: "d"
+      opt :trace,
+          "Show trace output (noisiest, probably not useful for most of time)",
+          short: :none
+      opt :version,
+          "Print version and exit",
+          short: "V"
+      opt :help,
+          "Show help message",
+          short: "h"
+
+      educate_on_error
+    end
+  end
+end