akerl-r10k 3.14.2.1

data/lib/r10k/util/purgeable.rb

@@ -0,0 +1,154 @@
+require 'r10k/logging'
+
+require 'fileutils'
+
+module R10K
+  module Util
+
+    # Mixin for purging stale directory contents.
+    #
+    # @abstract Classes using this mixin need to implement {#managed_directory} and
+    #   {#desired_contents}
+    module Purgeable
+
+      include R10K::Logging
+
+      HIDDEN_FILE = /\.[^.]+/
+
+      FN_MATCH_OPTS = File::FNM_PATHNAME | File::FNM_DOTMATCH
+
+      # @deprecated
+      #
+      # @!method logger
+      #   @abstract Including classes must provide a logger method
+      #   @return [Log4r::Logger]
+
+      # @!method desired_contents
+      #   @abstract Including classes must implement this method to list the
+      #     expected filenames of managed_directories
+      #   @return [Array<String>] The full paths to all the content this object is managing
+
+      # @!method managed_directories
+      #   @abstract Including classes must implement this method to return an array of
+      #     paths that can be purged
+      #   @return [Array<String>] The paths to the directories to be purged
+
+      # @return [Array<String>] The present directory entries in `self.managed_directories`
+      def current_contents(recurse)
+        dirs = self.managed_directories
+
+        dirs.flat_map do |dir|
+          if recurse
+            glob_exp = File.join(dir, '**', '{*,.[^.]*}')
+          else
+            glob_exp = File.join(dir, '*')
+          end
+
+          Dir.glob(glob_exp)
+        end
+      end
+
+      # @deprecated Unused helper function
+      #
+      # @return [Array<String>] Directory contents that are expected but not present
+      def pending_contents(recurse)
+        desired_contents - current_contents(recurse)
+      end
+
+      def matches?(test, path)
+        if test == path
+          true
+        elsif File.fnmatch?(test, path, FN_MATCH_OPTS)
+          true
+        else
+          false
+        end
+      end
+
+      # A method to collect potentially purgeable content without searching into
+      # ignored directories when recursively searching.
+      #
+      # @param dir [String, Pathname] The directory to search for purgeable content
+      # @param exclusion_gobs [Array<String>] A list of file paths or File globs
+      #     to exclude from recursion (These are generated by the classes that
+      #     mix this module into them and are typically programatically generated)
+      # @param allowed_gobs [Array<String>] A list of file paths or File globs to exclude
+      #     from recursion (These are passed in by the caller of purge! and typically
+      #     are user supplied configuration values)
+      # @param desireds_not_to_recurse_into [Array<String>] A list of file paths not to
+      #     recurse into. These are programatically generated, these exist to maintain
+      #     backwards compatibility with previous implementations that used File.globs
+      #     for "recursion", ie "**/{*,.[^.]*}" which would not recurse into dot directories.
+      # @param recurse [Boolean] Whether or not to recurse into child directories that do
+      #     not match other filters.
+      #
+      # @return [Array<String>] Contents which may be purged.
+      def potentially_purgeable(dir, exclusion_globs, allowed_globs, desireds_not_to_recurse_into, recurse)
+        children = Pathname.new(dir).children.reject do |path|
+          path = path.to_s
+
+          if exclusion_match = exclusion_globs.find { |exclusion| matches?(exclusion, path) }
+            logger.debug2 _("Not purging %{path} due to internal exclusion match: %{exclusion_match}") % {path: path, exclusion_match: exclusion_match}
+          elsif allowlist_match = allowed_globs.find { |allowed| matches?(allowed, path) }
+            logger.debug _("Not purging %{path} due to whitelist match: %{allowlist_match}") % {path: path, allowlist_match: allowlist_match}
+          else
+            desired_match = desireds_not_to_recurse_into.grep(path).first
+          end
+
+          !!exclusion_match || !!allowlist_match || !!desired_match
+        end
+
+        children.flat_map do |child|
+          if File.directory?(child) && !File.symlink?(child) && recurse
+            potentially_purgeable(child, exclusion_globs, allowed_globs, desireds_not_to_recurse_into, recurse) << child.to_s
+          else
+            child.to_s
+          end
+        end
+      end
+
+      # @return [Array<String>] Directory contents that are present but not expected
+      def stale_contents(recurse, exclusions, whitelist)
+        dirs = self.managed_directories
+        desireds = self.desired_contents
+        hidden_desireds, regular_desireds = desireds.partition do |desired|
+          HIDDEN_FILE.match(File.basename(desired))
+        end
+
+        initial_purgelist = dirs.flat_map do |dir|
+          potentially_purgeable(dir, exclusions, whitelist, hidden_desireds, recurse)
+        end
+
+        initial_purgelist.reject do |path|
+          regular_desireds.any? { |desired| matches?(desired, path) }
+        end
+      end
+
+      # Forcibly remove all unmanaged content in `self.managed_directories`
+      def purge!(opts={})
+        recurse = opts[:recurse] || false
+        whitelist = opts[:whitelist] || []
+
+        exclusions = self.respond_to?(:purge_exclusions) ? purge_exclusions : []
+
+        stale = stale_contents(recurse, exclusions, whitelist)
+
+        if stale.empty?
+          logger.debug1 _("No unmanaged contents in %{managed_dirs}, nothing to purge") % {managed_dirs: managed_directories.join(', ')}
+        else
+          stale.each do |fpath|
+            begin
+              FileUtils.rm_r(fpath, :secure => true)
+              logger.info _("Removing unmanaged path %{path}") % {path: fpath}
+            rescue Errno::ENOENT
+              # Don't log on ENOENT since we may encounter that from recursively deleting
+              # this item's parent earlier in the purge.
+            rescue
+              logger.debug1 _("Unable to remove unmanaged path: %{path}") % {path: fpath}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r10k/util/setopts.rb

@@ -0,0 +1,78 @@
+require 'r10k/logging'
+
+module R10K
+  module Util
+
+    # Allow for easy setting of instance options based on a hash
+    #
+    # This emulates the behavior of Ruby 2.0 named arguments, but since r10k
+    # supports Ruby 1.8.7+ we cannot use that functionality.
+    module Setopts
+
+      class Ignore; end
+
+      include R10K::Logging
+
+      private
+
+      # @param opts [Hash]
+      # @param allowed [Hash<Symbol, Symbol>]
+      #
+      # @example
+      #   opts = {:one => "one value"}
+      #   allowed => {:one => :self}
+      #   setopts(opts, allowed)
+      #   @one # => "one value"
+      #
+      # @example
+      #   opts = {:uno => "one value"}
+      #   allowed => {:one => :one, :uno => :one}
+      #   setopts(opts, allowed)
+      #   @one # => "one value"
+      #
+      # @example
+      #
+      #   opts = {:trace => "something"}
+      #   allowed = {:trace => nil}
+      #   setopts(opts, allowed)
+      #   @trace # => nil
+      #
+      def setopts(opts, allowed, raise_on_unhandled: true)
+        processed_vars = {}
+        opts.each_pair do |key, value|
+          if allowed.key?(key)
+            # Ignore nil options and explicit ignore param
+            next unless rhs = allowed[key]
+            next if rhs == ::R10K::Util::Setopts::Ignore
+
+            var = case rhs
+                  when :self, TrueClass
+                    # tr here is because instance variables cannot have hyphens in their names.
+                    "@#{key}".tr('-','_').to_sym
+                  else
+                    # tr here same as previous
+                    "@#{rhs}".tr('-','_').to_sym
+                  end
+
+            if processed_vars.include?(var)
+              # This should be a raise, but that would be a behavior change and
+              # should happen on a SemVer boundry.
+              logger.warn _("%{class_name} parameters '%{a}' and '%{b}' conflict. Specify one or the other, but not both" \
+                            % {class_name: self.class.name, a: processed_vars[var], b: key})
+            end
+
+            instance_variable_set(var, value)
+            processed_vars[var] = key
+          else
+            err_str = _("%{class_name} cannot handle option '%{key}'") % {class_name: self.class.name, key: key}
+            if raise_on_unhandled
+              raise ArgumentError, err_str
+            else
+              logger.warn(err_str)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r10k/util/subprocess/result.rb

@@ -0,0 +1,56 @@
+# @api private
+class R10K::Util::Subprocess::Result
+
+  # @!attribute [r] argv
+  #   @return [Array<String>]
+  attr_reader :argv
+
+  # @!attribute [r] cmd
+  #   @return [String]
+  attr_reader :cmd
+
+  # @!attribute [r] stdout
+  #   @return [String]
+  attr_reader :stdout
+
+  # @!attribute [r] stderr
+  #   @return [String]
+  attr_reader :stderr
+
+  # @!attribute [r] exit_code
+  #   @return [Integer]
+  attr_reader :exit_code
+
+  def initialize(argv, stdout, stderr, exit_code)
+    @argv = argv
+    @cmd = argv.join(' ')
+    @stdout = stdout.chomp
+    @stderr = stderr.chomp
+    @exit_code = exit_code
+  end
+
+  def format(with_cmd = true)
+    msg = []
+    if with_cmd
+      msg << "Command: #{@cmd}"
+    end
+    if !@stdout.empty?
+      msg << "Stdout:"
+      msg << @stdout
+    end
+    if !@stderr.empty?
+      msg << "Stderr:"
+      msg << @stderr
+    end
+    msg << "Exit code: #{@exit_code}"
+    msg.join("\n")
+  end
+
+  def failed?
+    exit_code != 0
+  end
+
+  def success?
+    exit_code == 0
+  end
+end

data/lib/r10k/util/subprocess/runner/jruby.rb

@@ -0,0 +1,23 @@
+require 'open3'
+require 'r10k/util/subprocess/runner'
+
+# Run processes under JRuby.
+#
+# This implementation relies on Open3.capture3 to run commands and capture
+# results. In contrast to the POSIX runner this cannot be used in an
+# asynchronous manner as-is; implementing that will probably mean launching a
+# thread and invoking #capture3 in that thread.
+class R10K::Util::Subprocess::Runner::JRuby < R10K::Util::Subprocess::Runner
+
+  def initialize(argv)
+    @argv = argv
+  end
+
+  def run
+    spawn_opts = @cwd ? {:chdir => @cwd} : {}
+    stdout, stderr, status = Open3.capture3(*@argv, spawn_opts)
+    @result = R10K::Util::Subprocess::Result.new(@argv, stdout, stderr, status.exitstatus)
+  rescue Errno::ENOENT, Errno::EACCES => e
+    @result = R10K::Util::Subprocess::Result.new(@argv, '', e.message, 255)
+  end
+end

data/lib/r10k/util/subprocess/runner/posix.rb

@@ -0,0 +1,103 @@
+require 'r10k/util/subprocess/runner'
+require 'r10k/util/subprocess/runner/pump'
+require 'fcntl'
+
+# Implement a POSIX command runner by using fork/exec.
+#
+# This implementation is optimized to run commands in the background, and has
+# a few noteworthy implementation details.
+#
+# First off, when the child process is forked, it calls setsid() to detach from
+# the controlling TTY. This has two main ramifications: sending signals will
+# never be send to the forked process, and the forked process does not have
+# access to stdin.
+#
+# @api private
+class R10K::Util::Subprocess::Runner::POSIX < R10K::Util::Subprocess::Runner
+
+  def initialize(argv)
+    @argv = argv
+    mkpipes
+  end
+
+  def run
+    # Create a pipe so that the parent can verify that the child process
+    # successfully executed. The pipe will be closed on a successful exec(),
+    # and will contain an error message on failure.
+    exec_r, exec_w = pipe
+
+    @stdout_pump = R10K::Util::Subprocess::Runner::Pump.new(@stdout_r)
+    @stderr_pump = R10K::Util::Subprocess::Runner::Pump.new(@stderr_r)
+    pid = fork do
+      exec_r.close
+      execute_child(exec_w)
+    end
+
+    exec_w.close
+    @stdout_pump.start
+    @stderr_pump.start
+
+    execute_parent(exec_r, pid)
+
+    @result
+  end
+
+  private
+
+  def execute_child(exec_w)
+    if @cwd
+      Dir.chdir @cwd
+    end
+
+    # Create a new session for the forked child. This prevents children from
+    # ever being the foreground process on a TTY, which is almost always what
+    # we want in r10k.
+    Process.setsid
+
+    # Reopen file descriptors
+    STDOUT.reopen(@stdout_w)
+    STDERR.reopen(@stderr_w)
+
+    executable = @argv.shift
+    exec([executable, executable], *@argv)
+  rescue SystemCallError => e
+    exec_w.write("#{e.class}: #{e.message}")
+    exit(254)
+  end
+
+  def execute_parent(exec_r, pid)
+    @stdout_w.close
+    @stderr_w.close
+
+    stdout = ''
+    stderr = ''
+
+    if !exec_r.eof?
+      stderr = exec_r.read || "exec() failed"
+      _, @status = Process.waitpid2(pid)
+    else
+      _, @status = Process.waitpid2(pid)
+      @stdout_pump.wait
+      @stderr_pump.wait
+      stdout = @stdout_pump.string
+      stderr = @stderr_pump.string
+    end
+    exec_r.close
+
+    @stdout_r.close
+    @stderr_r.close
+
+    @result = R10K::Util::Subprocess::Result.new(@argv, stdout, stderr, @status.exitstatus)
+  end
+
+  def mkpipes
+    @stdout_r, @stdout_w = pipe
+    @stderr_r, @stderr_w = pipe
+  end
+
+  def pipe
+    ::IO.pipe.tap do |pair|
+      pair.each { |p| p.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+    end
+  end
+end

data/lib/r10k/util/subprocess/runner/pump.rb

@@ -0,0 +1,59 @@
+require 'r10k/util/subprocess/runner'
+
+# Perform nonblocking reads on a streaming IO instance.
+#
+# @api private
+class R10K::Util::Subprocess::Runner::Pump
+
+  # !@attribute [r] string
+  #   @return [String] The output collected from the IO device
+  attr_reader :string
+
+  # @!attribute [r] min_delay
+  #   @return [Float] The minimum time to wait while polling the IO device
+  attr_accessor :min_delay
+
+  # @!attribute [r] max_delay
+  #   @return [Float] The maximum time to wait while polling the IO device
+  attr_accessor :max_delay
+
+  def initialize(io)
+    @io     = io
+    @thread = nil
+    @string = ''
+    @run    = true
+    @min_delay = 0.05
+    @max_delay = 1.0
+  end
+
+  def start
+    @thread = Thread.new { pump }
+  end
+
+  def halt!
+    @run = false
+    @thread.join
+  end
+
+  # Block until the pumping thread reaches EOF on the IO object.
+  def wait
+    @thread.join
+  end
+
+  private
+
+  def pump
+    backoff = @min_delay
+    while @run
+      begin
+        @string << @io.read_nonblock(4096)
+        backoff /= 2 if backoff > @min_delay
+      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+        backoff *= 2 if backoff < @max_delay
+        IO.select([@io], [], [], backoff)
+      rescue EOFError
+        @run = false
+      end
+    end
+  end
+end

data/lib/r10k/util/subprocess/runner/windows.rb

@@ -0,0 +1,23 @@
+require 'open3'
+require 'r10k/util/subprocess/runner'
+
+# Run processes on Windows.
+#
+# This implementation relies on Open3.capture3 to run commands and capture
+# results. In contrast to the POSIX runner this cannot be used in an
+# asynchronous manner as-is; implementing that will probably mean launching a
+# thread and invoking #capture3 in that thread.
+class R10K::Util::Subprocess::Runner::Windows < R10K::Util::Subprocess::Runner
+
+  def initialize(argv)
+    @argv = argv
+  end
+
+  def run
+    spawn_opts = @cwd ? {:chdir => @cwd} : {}
+    stdout, stderr, status = Open3.capture3(*@argv, spawn_opts)
+    @result = R10K::Util::Subprocess::Result.new(@argv, stdout, stderr, status.exitstatus)
+  rescue Errno::ENOENT, Errno::EACCES => e
+    @result = R10K::Util::Subprocess::Result.new(@argv, '', e.message, 255)
+  end
+end

data/lib/r10k/util/subprocess/runner.rb

@@ -0,0 +1,26 @@
+# Define an abstract interface for external command runners.
+#
+# @api private
+class R10K::Util::Subprocess::Runner
+
+  require 'r10k/util/subprocess/runner/windows'
+  require 'r10k/util/subprocess/runner/posix'
+  require 'r10k/util/subprocess/runner/jruby'
+
+  # @!attribute [rw] cwd
+  #   @return [String] The directory to be used as the cwd when executing
+  #     the command.
+  attr_accessor :cwd
+
+  # @!attribute [r] result
+  #   @return [R10K::Util::Subprocess::Result]
+  attr_reader :result
+
+  def initialize(argv)
+    raise NotImplementedError
+  end
+
+  def run
+    raise NotImplementedError
+  end
+end

data/lib/r10k/util/subprocess/subprocess_error.rb

@@ -0,0 +1,24 @@
+require 'r10k/errors'
+require 'r10k/util/subprocess'
+require 'r10k/util/setopts'
+
+class R10K::Util::Subprocess::SubprocessError < R10K::Error
+
+  # !@attribute [r] result
+  #   @return [R10K::Util::Subprocess::Result]
+  attr_reader :result
+
+  include R10K::Util::Setopts
+
+  def initialize(mesg, options = {})
+    super
+    setopts(options, {:result => true})
+  end
+
+  def message
+    msg = []
+    msg << "#{super}:"
+    msg << @result.format
+    msg.join("\n")
+  end
+end

data/lib/r10k/util/subprocess.rb

@@ -0,0 +1,85 @@
+require 'r10k/logging'
+require 'r10k/util/platform'
+
+module R10K
+  module Util
+
+    # The subprocess namespace implements an interface similar to childprocess.
+    # The interface has been simplified to make it easier to use and does not
+    # depend on native code.
+    #
+    # @api private
+    class Subprocess
+
+      require 'r10k/util/subprocess/runner'
+      require 'r10k/util/subprocess/result'
+      require 'r10k/util/subprocess/subprocess_error'
+
+      # @return [Class < R10K::Util::Subprocess::Runner]
+      def self.runner
+        if R10K::Util::Platform.windows?
+          R10K::Util::Subprocess::Runner::Windows
+        elsif R10K::Util::Platform.jruby?
+          R10K::Util::Subprocess::Runner::JRuby
+        else
+          R10K::Util::Subprocess::Runner::POSIX
+        end
+      end
+
+      include R10K::Logging
+
+      # @!attribute [r] argv
+      #   @return [Array<String>] The command to be executed
+      attr_reader :argv
+
+      # @!attribute [rw] raise_on_fail
+      #   Determine whether #execute raises an error when the command exits
+      #   with a non-zero exit status.
+      #   @return [true, false]
+      attr_accessor :raise_on_fail
+
+      # @!attribute [rw] cwd
+      #   @return [String] The directory to be used as the cwd when executing
+      #     the command.
+      attr_accessor :cwd
+
+      # @!attribute [w] logger
+      #   Allow calling processes to take ownership of execution logs by passing
+      #   their own logger to the command being executed.
+      attr_writer :logger
+
+      # Prepare the subprocess invocation.
+      #
+      # @param argv [Array<String>] The argument vector to execute
+      def initialize(argv)
+        @argv = argv
+
+        @raise_on_fail = false
+      end
+
+      # Execute the given command and return the result of evaluation.
+      #
+      # @api public
+      # @raise [R10K::Util::Subprocess::SubprocessError] if raise_on_fail is
+      #   true and the command exited with a non-zero status.
+      # @return [R10K::Util::Subprocess::Result]
+      def execute
+        subprocess = self.class.runner.new(@argv)
+        subprocess.cwd = @cwd if @cwd
+
+        logmsg = _("Starting process: %{args}") % {args: @argv.inspect}
+        logmsg << "(cwd: #{@cwd})" if @cwd
+        logger.debug2(logmsg)
+
+        result = subprocess.run
+        logger.debug2(_("Finished process:\n%{result}") % {result: result.format})
+
+        if @raise_on_fail && result.failed?
+          raise SubprocessError.new(_("Command exited with non-zero exit code"), :result => result)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/r10k/util/symbolize_keys.rb

@@ -0,0 +1,35 @@
+module R10K
+  module Util
+    module SymbolizeKeys
+      module_function
+
+      # Convert all String keys to Symbol keys
+      #
+      # @param hash [Hash] The data structure to convert
+      # @param recurse [Boolean] Whether to recursively symbolize keys in nested
+      #   hash values. Defaults to false.
+      # @raise [TypeError] If a String key collides with an existing Symbol key
+      # @return [void]
+      def symbolize_keys!(hash, recurse = false)
+        hash.keys.each do |key|
+          if key.is_a?(String)
+            if hash.key?(key.to_sym)
+              raise TypeError, _("An existing interned key for %{key} exists, cannot overwrite") % {key: key}
+            end
+            hash[key.to_sym] = hash.delete(key)
+            key = key.to_sym
+          end
+
+          value = hash[key]
+          if recurse
+            if value.is_a?(Hash)
+              symbolize_keys!(value, true)
+            elsif value.is_a?(Array)
+              value.map { |item| symbolize_keys!(item, true) if item.is_a?(Hash) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r10k/version.rb

@@ -0,0 +1,6 @@
+module R10K
+  # When updating to a new major (X) or minor (Y) version, include `#major` or
+  # `#minor` (respectively) in your commit message to trigger the appropriate
+  # release. Otherwise, a new patch (Z) version will be released.
+  VERSION = '3.14.2.1'
+end

data/lib/r10k.rb

@@ -0,0 +1,11 @@
+require 'gettext-setup'
+
+module R10K
+  GettextSetup.initialize(File.absolute_path('../locales', File.dirname(__FILE__)))
+
+  # Attempt to set the R10k error and log message locale
+  FastGettext.locale = ENV["LANG"]
+end
+
+require 'r10k/version'
+require 'r10k/logging'