facter 1.6.18 → 1.7.0.rc1

data/lib/facter/util/nothing_loader.rb

@@ -0,0 +1,15 @@
+# An external fact loader that doesn't load anything
+
+# This makes it possible to disable loading
+# of external facts
+
+module Facter
+  module Util
+
+    class NothingLoader
+
+      def load(collection)
+      end
+    end
+  end
+end

data/lib/facter/util/parser.rb

@@ -0,0 +1,141 @@
+# This class acts as the factory and parent class for parsed
+# facts such as scripts, text, json and yaml files.
+#
+# Parsers must subclass this class and provide their own #results method.
+require 'facter'
+require 'yaml'
+
+module Facter::Util::Parser
+  @parsers = []
+
+  # For support mutliple extensions you can pass an array of extensions as
+  # +ext+.
+  def self.extension_matches?(filename, ext)
+    extension = case ext
+    when String
+      ext.downcase
+    when Enumerable
+      ext.collect {|x| x.downcase }
+    end
+    [extension].flatten.to_a.include?(file_extension(filename).downcase)
+  end
+
+  def self.file_extension(filename)
+    File.extname(filename).sub(".", '')
+  end
+
+  def self.register(klass, &suitable)
+    @parsers << [klass, suitable]
+  end
+
+  def self.parser_for(filename)
+    registration = @parsers.detect { |k| k[1].call(filename) }
+
+    if registration.nil?
+      NothingParser.new
+    else
+      registration[0].new(filename)
+    end
+  end
+
+  class Base
+    attr_reader :filename
+
+    def initialize(filename, content = nil)
+      @filename = filename
+      @content  = content
+    end
+
+    def content
+      @content ||= File.read(filename)
+    end
+
+    # results on the base class is really meant to be just an exception handler
+    # wrapper.
+    def results
+      parse_results
+    rescue Exception => detail
+      Facter.warn("Failed to handle #{filename} as #{self.class} facts")
+      Facter.warn("detail: #{detail.class}: #{detail.message}")
+      Facter.debug(detail.backtrace.join("\n\t"))
+      nil
+    end
+
+    def parse_results
+      raise ArgumentError, "Subclasses must respond to parse_results"
+    end
+  end
+
+  class YamlParser < Base
+    def parse_results
+      YAML.load(content)
+    end
+  end
+
+  register(YamlParser) do |filename|
+    extension_matches?(filename, "yaml")
+  end
+
+  class TextParser < Base
+    def parse_results
+      re = /^(.+?)=(.+)$/
+      result = {}
+      content.each_line do |line|
+        if match_data = re.match(line.chomp)
+          result[match_data[1]] = match_data[2]
+        end
+      end
+      result
+    end
+  end
+
+  register(TextParser) do |filename|
+    extension_matches?(filename, "txt")
+  end
+
+  class JsonParser < Base
+    def results
+      if Facter.json?
+        JSON.load(content)
+      else
+        Facter.warnonce "Cannot parse JSON data file #{filename} without the json library."
+        Facter.warnonce "Suggested next step is `gem install json` to install the json library."
+        nil
+      end
+    end
+  end
+
+  register(JsonParser) do |filename|
+    extension_matches?(filename, "json")
+  end
+
+  class ScriptParser < Base
+    def results
+      output = Facter::Util::Resolution.exec(filename)
+
+      result = {}
+      re = /^(.+)=(.+)$/
+      output.each_line do |line|
+        if match_data = re.match(line.chomp)
+          result[match_data[1]] = match_data[2]
+        end
+      end
+      result
+    end
+  end
+
+  register(ScriptParser) do |filename|
+    if not Facter::Util::Config.is_windows?
+      File.executable?(filename) && File.file?(filename)
+    end
+  end
+
+
+  # A parser that is used when there is no other parser that can handle the file
+  # The return from results indicates to the caller the file was not parsed correctly.
+  class NothingParser
+    def results
+      nil
+    end
+  end
+end

data/lib/facter/util/processor.rb

@@ -218,55 +218,47 @@ module Processor
       model = Facter.value(:architecture)
       case model
       when "x86_64", "amd64", "i386", "x86", /parisc/, "hppa", "ia64"
-        Thread::exclusive do
-          File.readlines(cpuinfo).each do |l|
-            if l =~ /processor\s+:\s+(\d+)/
-              processor_num = $1.to_i
-            elsif l =~ /model name\s+:\s+(.*)\s*$/
-              processor_list[processor_num] = $1 unless processor_num == -1
-              processor_num = -1
-            elsif l =~ /processor\s+(\d+):\s+(.*)/
-              processor_num = $1.to_i
-              processor_list[processor_num] = $2 unless processor_num == -1
-            end
+        File.readlines(cpuinfo).each do |l|
+          if l =~ /processor\s+:\s+(\d+)/
+            processor_num = $1.to_i
+          elsif l =~ /model name\s+:\s+(.*)\s*$/
+            processor_list[processor_num] = $1 unless processor_num == -1
+            processor_num = -1
+          elsif l =~ /processor\s+(\d+):\s+(.*)/
+            processor_num = $1.to_i
+            processor_list[processor_num] = $2 unless processor_num == -1
           end
         end
 
       when "ppc64"
-        Thread::exclusive do
-          File.readlines(cpuinfo).each do |l|
-            if l =~ /processor\s+:\s+(\d+)/
-              processor_num = $1.to_i
-            elsif l =~ /cpu\s+:\s+(.*)\s*$/
-              processor_list[processor_num] = $1 unless processor_num == -1
-              processor_num = -1
-            end
+        File.readlines(cpuinfo).each do |l|
+          if l =~ /processor\s+:\s+(\d+)/
+            processor_num = $1.to_i
+          elsif l =~ /cpu\s+:\s+(.*)\s*$/
+            processor_list[processor_num] = $1 unless processor_num == -1
+            processor_num = -1
           end
         end
 
       when /arm/
-        Thread::exclusive do
-          File.readlines(cpuinfo).each do |l|
-            if l =~ /Processor\s+:\s+(.+)/
+        File.readlines(cpuinfo).each do |l|
+          if l =~ /Processor\s+:\s+(.+)/
+            processor_num += 1
+            processor_list[processor_num] = $1.chomp
+          elsif l =~ /processor\s+:\s+(\d+)\s*$/
+            proc_num = $1.to_i
+            if proc_num != 0
               processor_num += 1
-              processor_list[processor_num] = $1.chomp
-            elsif l =~ /processor\s+:\s+(\d+)\s*$/
-              proc_num = $1.to_i
-              if proc_num != 0
-                processor_num += 1
-                processor_list[processor_num] = processor_list[processor_num-1]
-              end
+              processor_list[processor_num] = processor_list[processor_num-1]
             end
           end
         end
 
       when /sparc/
-        Thread::exclusive do
-          File.readlines(cpuinfo).each do |l|
-            if l =~ /cpu\s+:\s+(.*)\s*$/
-              processor_num += 1
-              processor_list[processor_num] = $1
-            end
+        File.readlines(cpuinfo).each do |l|
+          if l =~ /cpu\s+:\s+(.*)\s*$/
+            processor_num += 1
+            processor_list[processor_num] = $1
           end
         end
       end

data/lib/facter/util/resolution.rb

@@ -10,6 +10,7 @@ require 'timeout'
 
 class Facter::Util::Resolution
   attr_accessor :interpreter, :code, :name, :timeout
+  attr_writer :value, :weight
 
   INTERPRETER = Facter::Util::Config.is_windows? ? "cmd.exe" : "/bin/sh"
 
@@ -108,6 +109,39 @@ class Facter::Util::Resolution
     end
   end
 
+  #
+  # Call this method with a block of code for which you would like to temporarily modify
+  # one or more environment variables; the specified values will be set for the duration
+  # of your block, after which the original values (if any) will be restored.
+  #
+  # [values] a Hash containing the key/value pairs of any environment variables that you
+  # would like to temporarily override
+  def self.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
 
   # Execute a program and return the output of that program.
   #
@@ -117,33 +151,38 @@ class Facter::Util::Resolution
   def self.exec(code, interpreter = nil)
     Facter.warnonce "The interpreter parameter to 'exec' is deprecated and will be removed in a future version." if interpreter
 
-    if expanded_code = expand_command(code)
-      # if we can find the binary, we'll run the command with the expanded path to the binary
-      code = expanded_code
-    else
-      # if we cannot find the binary return nil on posix. On windows we'll still try to run the
-      # command in case it is a shell-builtin. In case it is not, windows will raise Errno::ENOENT
-      return nil unless Facter::Util::Config.is_windows?
-      return nil if absolute_path?(code)
-    end
-
-    out = nil
-
-    begin
-      out = %x{#{code}}.chomp
-      Facter.warnonce 'Using Facter::Util::Resolution.exec with a shell built-in is deprecated. Most built-ins can be replaced with native ruby commands. If you really have to run a built-in, pass "cmd /c your_builtin" as a command' unless expanded_code
-    rescue Errno::ENOENT => detail
-      # command not found on Windows
-      return nil
-    rescue => detail
-      $stderr.puts detail
-      return nil
-    end
+    ## Set 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 "LANG" => "C" do
+      
+      if expanded_code = expand_command(code)
+        # if we can find the binary, we'll run the command with the expanded path to the binary
+        code = expanded_code
+      else
+        # if we cannot find the binary return nil on posix. On windows we'll still try to run the
+        # command in case it is a shell-builtin. In case it is not, windows will raise Errno::ENOENT
+        return nil unless Facter::Util::Config.is_windows?
+        return nil if absolute_path?(code)
+      end
+      
+      out = nil
 
-    if out == ""
-      return nil
-    else
-      return out
+      begin
+        out = %x{#{code}}.chomp
+        Facter.warnonce 'Using Facter::Util::Resolution.exec with a shell built-in is deprecated. Most built-ins can be replaced with native ruby commands. If you really have to run a built-in, pass "cmd /c your_builtin" as a command' unless expanded_code
+      rescue Errno::ENOENT => detail
+        # command not found on Windows
+        return nil
+      rescue => detail
+        $stderr.puts detail
+        return nil
+      end
+      
+      if out == ""
+        return nil
+      else
+        return out
+      end
     end
   end
 
@@ -197,6 +236,37 @@ class Facter::Util::Resolution
     end
   end
 
+  ##
+  # on_flush accepts a block and executes the block when the resolution's value
+  # is flushed.  This makes it possible to model a single, expensive system
+  # call inside of a Ruby object and then define multiple dynamic facts which
+  # resolve by sending messages to the model instance.  If one of the dynamic
+  # facts is flushed then it can, in turn, flush the data stored in the model
+  # instance to keep all of the dynamic facts in sync without making multiple,
+  # expensive, system calls.
+  #
+  # Please see the Solaris zones fact for an example of how this feature may be
+  # used.
+  #
+  # @see Facter::Util::Fact#flush
+  # @see Facter::Util::Resolution#flush
+  #
+  # @api public
+  def on_flush(&block)
+    @on_flush_block = block
+  end
+
+  ##
+  # flush executes the block, if any, stored by the {on_flush} method
+  #
+  # @see Facter::Util::Fact#flush
+  # @see Facter::Util::Resolution#on_flush
+  #
+  # @api private
+  def flush
+    @on_flush_block.call if @on_flush_block
+  end
+
   def interpreter
     Facter.warnonce "The 'Facter::Util::Resolution.interpreter' method is deprecated and will be removed in a future version."
     @interpreter
@@ -222,6 +292,7 @@ class Facter::Util::Resolution
 
   # How we get a value for our resolution mechanism.
   def value
+    return @value if @value
     result = nil
     return result if @code == nil
 

data/lib/facter/util/solaris_zones.rb

@@ -0,0 +1,153 @@
+require 'facter/util/resolution'
+
+module Facter
+module Util
+  ##
+  # Provide a set of utility methods to interact with Solaris zones.  This class
+  # is expected to be instantiated once per set of resolutions in order to
+  # cache the output of the zoneadm command, which can be quite expensive.
+  #
+  # @api private
+  class SolarisZones
+    attr_reader :zone_hash
+    attr_reader :zoneadm_cmd
+    attr_reader :zoneadm_output
+    attr_reader :zoneadm_keys
+
+    ##
+    # add_facts defines all of the facts for solaris zones, for example `zones`,
+    # `zone_global_id`, `zone_global_status`, etc...  This method defines the
+    # static fact named `zones`.  The value of this fact is the numver of zones
+    # reported by the zoneadm system command.  The `zones` fact also defines
+    # all of the dynamic facts describing the following seven attribute values
+    # for each zone.
+    #
+    # Zones may be added to the system while Facter is loaded.  In order to
+    # define new dynamic facts that reflect this new information, the `virtual`
+    # will define new facts as a side effect of refreshing it's own value.
+    #
+    # @api private
+    def self.add_facts
+      model = new
+      model.refresh
+      model.add_dynamic_facts
+      Facter.add("zones") do
+        setcode do
+          model.refresh if model.flushed?
+          model.add_dynamic_facts
+          model.count
+        end
+        on_flush do
+          model.flush!
+        end
+      end
+    end
+
+    ##
+    # @param [Hash] opts the options to create the instance with
+    # @option opts [String] :zoneadm_cmd ('/usr/sbin/zoneadm list -cp') the
+    #   system command to inspect zones
+    # @option opts [String] :zoneadm_output (nil) the cached output of the
+    #   zoneadm_cmd
+    def initialize(opts = {})
+      @zoneadm_keys = [:id, :name, :status, :path, :uuid, :brand, :iptype]
+      @zoneadm_cmd = opts[:zoneadm_cmd] || '/usr/sbin/zoneadm list -cp'
+      if opts[:zoneadm_output]
+        @zoneadm_output = opts[:zoneadm_output]
+      end
+    end
+
+    ##
+    # add_dynamic_facts defines all of the dynamic facts derived from parsing
+    # the output of the zoneadm command.  The zone facts are dynamic, so this
+    # method has the behavior of figuring out what dynamic zone facts need to
+    # be defined and how they should be resolved.
+    #
+    # @param model [SolarisZones] the model used to store data from the system
+    #
+    # @api private
+    def add_dynamic_facts
+      model = self
+      zone_hash.each_pair do |zone, attr_hsh|
+        attr_hsh.keys.each do |attr|
+          Facter.add("zone_#{zone}_#{attr}") do
+            setcode do
+              model.refresh if model.flushed?
+              # Don't resolve if the zone has since been deleted
+              if zone_hsh = model.zone_hash[zone]
+                zone_hsh[attr] # the value
+              end
+            end
+            on_flush do
+              model.flush!
+            end
+          end
+        end
+      end
+    end
+
+    ##
+    # refresh executes the zoneadm_cmd and stores the output data.
+    #
+    # @api private
+    #
+    # @return [Hash] the parsed output of the zoneadm command
+    def refresh
+      @zoneadm_output = Facter::Util::Resolution.exec(zoneadm_cmd)
+      parse!
+    end
+
+    ##
+    # parse! parses the string stored in {@zoneadm_output} and stores the
+    # resulting Hash data structure in {@zone_hash}
+    #
+    # @api private
+    def parse!
+      rows = @zoneadm_output.split("\n").collect { |line| line.split(':') }
+
+      @zone_hash = rows.inject({}) do |memo, fields|
+        zone = fields[1].intern
+        # Transform the row into a hash with keys named by the column names
+        memo[zone] = Hash[*@zoneadm_keys.zip(fields).flatten]
+        memo
+      end
+    end
+    private :parse!
+
+    ##
+    # count returns the number of running zones, including the global zone.
+    # This method is intended to be used from the setcode block of the `zones`
+    # fact.
+    #
+    # @api private
+    #
+    # @return [Fixnum, nil] the number of running zones or nil if the number
+    #   could not be determined.
+    def count
+      if @zone_hash
+        @zone_hash.size
+      end
+    end
+
+    ##
+    # flush! purges the saved data from the zoneadm_cmd output
+    #
+    # @api private
+    def flush!
+      @zoneadm_output = nil
+      @zone_hash = nil
+    end
+
+    ##
+    # flushed? returns true if the instance has no parsed data accessible via
+    # the {zone_hash} method.
+    #
+    # @api private
+    #
+    # @return [Boolean] true if there is no parsed data, false otherwise
+    def flushed?
+      !@zone_hash
+    end
+  end
+end
+end