facter 2.1.0-x64-mingw32

data/lib/facter/core/directed_graph.rb

@@ -0,0 +1,46 @@
+require 'set'
+require 'tsort'
+
+module Facter
+  module Core
+    class DirectedGraph < Hash
+      include TSort
+
+      def acyclic?
+        cycles.empty?
+      end
+
+      def cycles
+        cycles = []
+        each_strongly_connected_component do |component|
+          cycles << component if component.size > 1
+        end
+        cycles
+      end
+
+      alias tsort_each_node each_key
+
+      def tsort_each_child(node)
+        fetch(node, []).each do |child|
+          yield child
+        end
+      end
+
+      def tsort
+        missing = Set.new(self.values.flatten) - Set.new(self.keys)
+
+        if not missing.empty?
+          raise MissingVertex, "Cannot sort elements; cannot depend on missing elements #{missing.to_a}"
+        end
+
+        super
+
+      rescue TSort::Cyclic
+        raise CycleError, "Cannot sort elements; found the following cycles: #{cycles.inspect}"
+      end
+
+      class CycleError < StandardError; end
+      class MissingVertex < StandardError; end
+    end
+  end
+end

data/lib/facter/core/execution.rb

@@ -0,0 +1,123 @@
+require 'facter/util/config'
+
+module Facter
+  module Core
+    module Execution
+
+      require 'facter/core/execution/base'
+      require 'facter/core/execution/windows'
+      require 'facter/core/execution/posix'
+
+      @@impl = if Facter::Util::Config.is_windows?
+                 Facter::Core::Execution::Windows.new
+               else
+                 Facter::Core::Execution::Posix.new
+               end
+
+      def self.impl
+        @@impl
+      end
+
+      module_function
+
+      # Returns the locations to be searched when looking for a binary. This
+      # is currently determined by the +PATH+ environment variable plus
+      # `/sbin` and `/usr/sbin` when run on unix
+      #
+      # @return [Array<String>] the paths to be searched for binaries
+      # @api private
+      def search_paths
+        @@impl.search_paths
+      end
+
+      # Determines the full path to a binary. If the supplied filename does not
+      # already describe an absolute path then different locations (determined
+      # by {search_paths}) will be searched for a match.
+      #
+      # Returns nil if no matching executable can be found otherwise returns
+      # the expanded pathname.
+      #
+      # @param bin [String] the executable to locate
+      # @return [String,nil] the full path to the executable or nil if not
+      #   found
+      #
+      # @api public
+      def which(bin)
+        @@impl.which(bin)
+      end
+
+      # Determine in a platform-specific way whether a path is absolute. This
+      # defaults to the local platform if none is specified.
+      #
+      # @param path [String] the path to check
+      # @param platform [:posix,:windows,nil] the platform logic to use
+      def absolute_path?(path, platform = nil)
+        @@impl.absolute_path?(path, platform)
+      end
+
+      # Given a command line, this returns the command line with the
+      # executable written as an absolute path. If the executable contains
+      # spaces, it has be put in double quotes to be properly recognized.
+      #
+      # @param command [String] the command line
+      #
+      # @return [String, nil] the command line with the executable's path
+      # expanded, or nil if the executable cannot be found.
+      def expand_command(command)
+        @@impl.expand_command(command)
+      end
+
+      # Overrides environment variables within a block of code.  The
+      # specified values will be set for the duration of the block, after
+      # which the original values (if any) will be restored.
+      #
+      # @overload with_env(values, { || ... })
+      #
+      # @param values [Hash<String=>String>] A hash of the environment
+      #   variables to override
+      #
+      # @return [void]
+      #
+      # @api public
+      def with_env(values, &block)
+        @@impl.with_env(values, &block)
+      end
+
+      # Try to execute a command and return the output.
+      #
+      # @param code [String] the program to run
+      #
+      # @return [String] the output of the program, or nil if the command does
+      #   not exist or could not be executed.
+      #
+      # @deprecated Use #{execute} instead
+      # @api public
+      def exec(command)
+        @@impl.execute(command, :on_fail => nil)
+      end
+
+      # Execute a command and return the output of that program.
+      #
+      # @param code [String] the program to run
+      # @param options [Hash]
+      #
+      # @option options [Object] :on_fail How to behave when the command could
+      #   not be run. Specifying :raise will raise an error, anything else will
+      #   return that object on failure. Default is :raise.
+      #
+      # @raise [Facter::Core::Execution::ExecutionFailure] If the command does
+      #   not exist or could not be executed.
+      #
+      # @return [String] the output of the program, or the value of :on_fail if
+      #   command execution failed and :on_fail was specified.
+      #
+      # @api public
+      # @since 2.0.1
+      def execute(command, options = {})
+        @@impl.execute(command, options)
+      end
+
+      class ExecutionFailure < StandardError; end
+    end
+  end
+end

data/lib/facter/core/execution/base.rb

@@ -0,0 +1,81 @@
+class Facter::Core::Execution::Base
+
+  def with_env(values)
+    old = {}
+    values.each do |var, value|
+      # save the old value if it exists
+      if old_val = ENV[var]
+        old[var] = old_val
+      end
+      # set the new (temporary) value for the environment variable
+      ENV[var] = value
+    end
+    # execute the caller's block, capture the return value
+    rv = yield
+  # use an ensure block to make absolutely sure we restore the variables
+  ensure
+    # restore the old values
+    values.each do |var, value|
+      if old.include?(var)
+        ENV[var] = old[var]
+      else
+        # if there was no old value, delete the key from the current environment variables hash
+        ENV.delete(var)
+      end
+    end
+    # return the captured return value
+    rv
+  end
+
+  def execute(command, options = {})
+
+    on_fail = options.fetch(:on_fail, :raise)
+
+    # Set LC_ALL and LANG to force i18n to C for the duration of this exec; this ensures that any code that parses the
+    # output of the command can expect it to be in a consistent / predictable format / locale
+    with_env 'LC_ALL' => 'C', 'LANG' => 'C' do
+
+      expanded_command = expand_command(command)
+
+      if expanded_command.nil?
+        if on_fail == :raise
+          raise Facter::Core::Execution::ExecutionFailure.new, "Could not execute '#{command}': command not found"
+        else
+          return on_fail
+        end
+      end
+
+      out = ''
+
+      begin
+        wait_for_child = true
+        out = %x{#{expanded_command}}.chomp
+        wait_for_child = false
+      rescue => detail
+        if on_fail == :raise
+          raise Facter::Core::Execution::ExecutionFailure.new, "Failed while executing '#{expanded_command}': #{detail.message}"
+        else
+          return on_fail
+        end
+      ensure
+        if wait_for_child
+          # We need to ensure that if this command exits early then any spawned
+          # children will be reaped. Process execution is frequently
+          # terminated using Timeout.timeout but since the timeout isn't in
+          # this scope we can't rescue the raised exception. The best that
+          # we can do is determine if the child has exited, and if it hasn't
+          # then we need to spawn a thread to wait for the child.
+          #
+          # Due to the limitations of Ruby 1.8 there aren't good ways to
+          # asynchronously run a command and grab the PID of that command
+          # using the standard library. The best we can do is blindly wait
+          # on all processes and hope for the best. This issue is described
+          # at https://tickets.puppetlabs.com/browse/FACT-150
+          Thread.new { Process.waitall }
+        end
+      end
+
+      out
+    end
+  end
+end

data/lib/facter/core/execution/posix.rb

@@ -0,0 +1,50 @@
+class Facter::Core::Execution::Posix < Facter::Core::Execution::Base
+
+  DEFAULT_SEARCH_PATHS = ['/sbin', '/usr/sbin']
+
+  def search_paths
+    # Make sure facter is usable even for non-root users. Most commands
+    # in /sbin (like ifconfig) can be run as non privileged users as
+    # long as they do not modify anything - which we do not do with facter
+    ENV['PATH'].split(File::PATH_SEPARATOR) + DEFAULT_SEARCH_PATHS
+  end
+
+  def which(bin)
+    if absolute_path?(bin)
+      return bin if File.executable?(bin)
+    else
+      search_paths.each do |dir|
+        dest = File.join(dir, bin)
+        return dest if File.executable?(dest)
+      end
+    end
+    nil
+  end
+
+  ABSOLUTE_PATH_REGEX = %r{^/}
+
+  def absolute_path?(path)
+    !! (path =~ ABSOLUTE_PATH_REGEX)
+  end
+
+  DOUBLE_QUOTED_COMMAND = /^"(.+?)"(?:\s+(.*))?/
+  SINGLE_QUOTED_COMMAND = /^'(.+?)'(?:\s+(.*))?/
+
+  def expand_command(command)
+    exe = nil
+    args = nil
+
+    if (match = (command.match(DOUBLE_QUOTED_COMMAND) || command.match(SINGLE_QUOTED_COMMAND)))
+      exe, args = match.captures
+    else
+      exe, args = command.split(/ /,2)
+    end
+
+    if exe and (expanded = which(exe))
+      expanded = "'#{expanded}'" if expanded.match(/\s/)
+      expanded << " #{args}" if args
+
+      return expanded
+    end
+  end
+end

data/lib/facter/core/execution/windows.rb

@@ -0,0 +1,57 @@
+class Facter::Core::Execution::Windows < Facter::Core::Execution::Base
+
+  def search_paths
+    ENV['PATH'].split(File::PATH_SEPARATOR)
+  end
+
+  DEFAULT_COMMAND_EXTENSIONS = %w[.COM .EXE .BAT .CMD]
+
+  def which(bin)
+    if absolute_path?(bin)
+      return bin if File.executable?(bin)
+    else
+      search_paths.each do |dir|
+        dest = File.join(dir, bin)
+        dest.gsub!(File::SEPARATOR, File::ALT_SEPARATOR)
+        if File.extname(dest).empty?
+          exts = ENV['PATHEXT']
+          exts = exts ? exts.split(File::PATH_SEPARATOR) : DEFAULT_COMMAND_EXTENSIONS
+          exts.each do |ext|
+            destext = dest + ext
+            return destext if File.executable?(destext)
+          end
+        end
+        return dest if File.executable?(dest)
+      end
+    end
+    nil
+  end
+
+  slash = '[\\\\/]'
+  name = '[^\\\\/]+'
+  ABSOLUTE_PATH_REGEX = %r!^(([A-Z]:#{slash})|(#{slash}#{slash}#{name}#{slash}#{name})|(#{slash}#{slash}\?#{slash}#{name}))!i
+
+  def absolute_path?(path)
+    !! (path =~ ABSOLUTE_PATH_REGEX)
+  end
+
+  DOUBLE_QUOTED_COMMAND = /^"(.+?)"(?:\s+(.*))?/
+
+  def expand_command(command)
+    exe = nil
+    args = nil
+
+    if (match = command.match(DOUBLE_QUOTED_COMMAND))
+      exe, args = match.captures
+    else
+      exe, args = command.split(/ /,2)
+    end
+
+    if exe and (expanded = which(exe))
+      expanded = "\"#{expanded}\"" if expanded.match(/\s+/)
+      expanded << " #{args}" if args
+
+      return expanded
+    end
+  end
+end

data/lib/facter/core/logging.rb

@@ -0,0 +1,169 @@
+require 'facter'
+
+module Facter::Core::Logging
+
+  extend self
+
+  # @api private
+  GREEN = ""
+  # @api private
+  RESET = ""
+
+  # @api private
+  @@debug = false
+  # @api private
+  @@timing = false
+  # @api private
+  @@trace = false
+
+  # @api private
+  @@warn_messages = {}
+  # @api private
+  @@debug_messages = {}
+
+  # Prints a debug message if debugging is turned on
+  #
+  # @param msg [String] the debug message
+  # @return [void]
+  def debug(msg)
+    if self.debugging?
+      if msg.nil? or msg.empty?
+        invoker = caller[0].slice(/.*:\d+/)
+        self.warn "#{self.class}#debug invoked with invalid message #{msg.inspect}:#{msg.class} at #{invoker}"
+      else
+        puts GREEN + msg + RESET
+      end
+    end
+  end
+
+  # Prints a debug message only once.
+  #
+  # @note Uniqueness is based on the string, not the specific location
+  #   of the method call.
+  #
+  # @param msg [String] the debug message
+  # @return [void]
+  def debugonce(msg)
+    if msg and not msg.empty? and @@debug_messages[msg].nil?
+      @@debug_messages[msg] = true
+      debug(msg)
+    end
+  end
+
+  # Prints a warning message. The message is only printed if debugging
+  # is enabled.
+  #
+  # @param msg [String] the warning message to be printed
+  #
+  # @return [void]
+  def warn(msg)
+    if msg.nil? or msg.empty?
+      invoker = caller[0].slice(/.*:\d+/)
+      Kernel.warn "#{self.class}#debug invoked with invalid message #{msg.inspect}:#{msg.class} at #{invoker}"
+    else
+      Kernel.warn msg
+    end
+  end
+
+  # Prints a warning message only once per process. Each unique string
+  # is printed once.
+  #
+  # @note Unlike {warn} the message will be printed even if debugging is
+  #   not turned on. This behavior is likely to change and should not be
+  #   relied on.
+  #
+  # @param msg [String] the warning message to be printed
+  #
+  # @return [void]
+  def warnonce(msg)
+    if @@warn_messages[msg].nil?
+      self.warn(msg)
+      @@warn_messages[msg] = true
+    end
+  end
+
+  def log_exception(exception, message = :default)
+    self.warn(format_exception(exception, message, @@trace))
+  end
+
+  def format_exception(exception, message, trace)
+    arr = []
+
+    if message == :default
+      arr << exception.message
+    elsif message
+      arr << message
+    end
+
+    if trace
+      arr.concat(exception.backtrace)
+    end
+
+    arr.flatten.join("\n")
+  end
+
+  # Print an exception message, and optionally a backtrace if trace is set
+
+  # Print timing information
+  #
+  # @param string [String] the time to print
+  # @return [void]
+  #
+  # @api private
+  def show_time(string)
+    $stderr.puts "#{GREEN}#{string}#{RESET}" if string and self.timing?
+  end
+
+  # Enable or disable logging of debug messages
+  #
+  # @param bool [true, false]
+  # @return [void]
+  #
+  # @api private
+  def debugging(bool)
+    @@debug = bool
+  end
+
+  # Is debugging enabled?
+  #
+  # @return [true, false]
+  #
+  # @api private
+  def debugging?
+    @@debug
+  end
+
+  # Enable or disable logging of timing information
+  #
+  # @param bool [true, false]
+  # @return [void]
+  #
+  # @api private
+  def timing(bool)
+    @@timing = bool
+  end
+
+  # Returns whether timing output is turned on
+  #
+  # @api private
+  def timing?
+    @@timing
+  end
+
+  def trace(bool)
+    @@trace = bool
+  end
+
+  def trace?
+    @@trace
+  end
+
+  # Clears the seen state of warning messages. See {warnonce}.
+  #
+  # @return [void]
+  #
+  # @api private
+  def clear_messages
+    @@warn_messages.clear
+  end
+end