r10k 3.5.2

data/lib/r10k/util/license.rb

@@ -0,0 +1,24 @@
+require 'r10k/errors'
+require 'r10k/features'
+
+module R10K
+  module Util
+    module License
+      extend R10K::Logging
+
+      def self.load
+        if R10K::Features.available?(:pe_license)
+          logger.debug2 _("pe_license feature is available, loading PE license key")
+          begin
+            return PELicense.load_license_key
+          rescue PELicense::InvalidLicenseError => e
+            raise R10K::Error.wrap(e, _("Invalid PE license detected: %{error_msg}") % {error_msg: e.message} )
+          end
+        else
+          logger.debug2 _("pe_license feature is not available, PE only Puppet modules will not be downloadable.")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/r10k/util/platform.rb

@@ -0,0 +1,42 @@
+require 'rbconfig'
+
+module R10K
+  module Util
+    module Platform
+      FIPS_FILE = "/proc/sys/crypto/fips_enabled"
+
+      def self.platform
+        # Test JRuby first to handle JRuby on Windows as well.
+        if self.jruby?
+          :jruby
+        elsif self.windows?
+          :windows
+        else
+          :posix
+        end
+      end
+
+      # We currently only suport FIPS mode on redhat 7, where it is
+      # toggled via a file.
+      def self.fips?
+        if File.exist?(FIPS_FILE)
+          File.read(FIPS_FILE).chomp == "1"
+        else
+          false
+        end
+      end
+
+      def self.windows?
+        RbConfig::CONFIG['host_os'] =~ /mswin|win32|dos|mingw|cygwin/i
+      end
+
+      def self.jruby?
+        RUBY_PLATFORM == "java"
+      end
+
+      def self.posix?
+        !windows? && !jruby?
+      end
+    end
+  end
+end

data/lib/r10k/util/purgeable.rb

@@ -0,0 +1,88 @@
+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
+
+      # @!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
+
+      # @return [Array<String>] Directory contents that are expected but not present
+      def pending_contents(recurse)
+        desired_contents - current_contents(recurse)
+      end
+
+      # @return [Array<String>] Directory contents that are present but not expected
+      def stale_contents(recurse, exclusions, whitelist)
+        fn_match_opts = File::FNM_PATHNAME | File::FNM_DOTMATCH
+
+        (current_contents(recurse) - desired_contents).reject do |item|
+          if exclusion_match = exclusions.find { |ex_item| (ex_item == item) || File.fnmatch?(ex_item, item, fn_match_opts) }
+            logger.debug2 _("Not purging %{item} due to internal exclusion match: %{exclusion_match}") % {item: item, exclusion_match: exclusion_match}
+          elsif whitelist_match = whitelist.find { |wl_item| (wl_item == item) || File.fnmatch?(wl_item, item, fn_match_opts) }
+            logger.debug _("Not purging %{item} due to whitelist match: %{whitelist_match}") % {item: item, whitelist_match: whitelist_match}
+          end
+
+          !!exclusion_match || !!whitelist_match
+        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,55 @@
+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
+
+      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)
+        opts.each_pair do |key, value|
+          if allowed.key?(key)
+            rhs = allowed[key]
+            case rhs
+            when NilClass, FalseClass
+              # Ignore nil options
+            when :self, TrueClass
+              # tr here is because instance variables cannot have hyphens in their names.
+              instance_variable_set("@#{key}".tr('-','_').to_sym, value)
+            else
+              # tr here same as previous
+              instance_variable_set("@#{rhs}".tr('-','_').to_sym, value)
+            end
+          else
+            raise ArgumentError, _("%{class_name} cannot handle option '%{key}'") % {class_name: self.class.name, key: key}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r10k/util/subprocess.rb

@@ -0,0 +1,84 @@
+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/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.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/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