facter 2.1.0-x64-mingw32

data/lib/facter/util/registry.rb

@@ -0,0 +1,11 @@
+module Facter::Util::Registry
+  class << self
+    def hklm_read(key, value)
+      require 'win32/registry'
+      reg = Win32::Registry::HKEY_LOCAL_MACHINE.open(key)
+      rval = reg[value]
+      reg.close
+      rval
+    end
+  end
+end

data/lib/facter/util/resolution.rb

@@ -0,0 +1,160 @@
+require 'facter/util/confine'
+require 'facter/util/config'
+require 'facter/util/normalization'
+require 'facter/core/execution'
+require 'facter/core/resolvable'
+require 'facter/core/suitable'
+
+# This represents a fact resolution. A resolution is a concrete
+# implementation of a fact. A single fact can have many resolutions and
+# the correct resolution will be chosen at runtime. Each time
+# {Facter.add} is called, a new resolution is created and added to the
+# set of resolutions for the fact named in the call.  Each resolution
+# has a {#has_weight weight}, which defines its priority over other
+# resolutions, and a set of {#confine _confinements_}, which defines the
+# conditions under which it will be chosen. All confinements must be
+# satisfied for a fact to be considered _suitable_.
+#
+# @api public
+class Facter::Util::Resolution
+  # @api private
+  attr_accessor :code
+  attr_writer :value
+
+  extend Facter::Core::Execution
+
+  class << self
+    # Expose command execution methods that were extracted into
+    # Facter::Util::Execution from Facter::Util::Resolution in Facter 2.0.0 for
+    # compatibility.
+    #
+    # @deprecated
+    public :search_paths, :which, :absolute_path?, :expand_command, :with_env, :exec
+  end
+
+  include Facter::Core::Resolvable
+  include Facter::Core::Suitable
+
+  # @!attribute [rw] name
+  # The name of this resolution. The resolution name should be unique with
+  # respect to the given fact.
+  # @return [String]
+  # @api public
+  attr_accessor :name
+
+  # @!attribute [r] fact
+  # @return [Facter::Util::Fact]
+  # @api private
+  attr_reader :fact
+
+  # Create a new resolution mechanism.
+  #
+  # @param name [String] The name of the resolution.
+  # @return [void]
+  #
+  # @api private
+  def initialize(name, fact)
+    @name = name
+    @fact = fact
+    @confines = []
+    @value = nil
+    @timeout = 0
+    @weight = nil
+  end
+
+  def resolution_type
+    :simple
+  end
+
+  # Evaluate the given block in the context of this resolution. If a block has
+  # already been evaluated emit a warning to that effect.
+  #
+  # @return [void]
+  def evaluate(&block)
+    if @last_evaluated
+      msg = "Already evaluated #{@name}"
+      msg << " at #{@last_evaluated}" if msg.is_a? String
+      msg << ", reevaluating anyways"
+      Facter.warn msg
+    end
+
+    instance_eval(&block)
+
+    # Ruby 1.9+ provides the source location of procs which can provide useful
+    # debugging information if a resolution is being evaluated twice. Since 1.8
+    # doesn't support this we opportunistically provide this information.
+    if block.respond_to? :source_location
+      @last_evaluated = block.source_location.join(':')
+    else
+      @last_evaluated = true
+    end
+  end
+
+  def set_options(options)
+    if options[:name]
+      @name = options.delete(:name)
+    end
+
+    if options.has_key?(:value)
+      @value = options.delete(:value)
+    end
+
+    if options.has_key?(:timeout)
+      @timeout = options.delete(:timeout)
+    end
+
+    if options.has_key?(:weight)
+      @weight = options.delete(:weight)
+    end
+
+    if not options.keys.empty?
+      raise ArgumentError, "Invalid resolution options #{options.keys.inspect}"
+    end
+  end
+
+  # Sets the code block or external program that will be evaluated to
+  # get the value of the fact.
+  #
+  # @return [void]
+  #
+  # @overload setcode(string)
+  #   Sets an external program to call to get the value of the resolution
+  #   @param [String] string the external program to run to get the
+  #     value
+  #
+  # @overload setcode(&block)
+  #   Sets the resolution's value by evaluating a block at runtime
+  #   @param [Proc] block The block to determine the resolution's value.
+  #     This block is run when the fact is evaluated. Errors raised from
+  #     inside the block are rescued and printed to stderr.
+  #
+  # @api public
+  def setcode(string = nil, &block)
+    if string
+      @code = Proc.new do
+        output = Facter::Core::Execution.execute(string, :on_fail => nil)
+        if output.nil? or output.empty?
+          nil
+        else
+          output
+        end
+      end
+    elsif block_given?
+      @code = block
+    else
+      raise ArgumentError, "You must pass either code or a block"
+    end
+  end
+
+  private
+
+  def resolve_value
+    if @value
+      @value
+    elsif @code.nil?
+      nil
+    elsif @code
+      @code.call()
+    end
+  end
+end

data/lib/facter/util/solaris_zones.rb

@@ -0,0 +1,158 @@
+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::Core::Execution.execute(zoneadm_cmd, {:on_fail => nil})
+      parse!
+    end
+
+    ##
+    # parse! parses the string stored in {@zoneadm_output} and stores the
+    # resulting Hash data structure in {@zone_hash}
+    #
+    # @api private
+    def parse!
+      if @zoneadm_output
+        rows = @zoneadm_output.split("\n").collect { |line| line.split(':') }
+      else
+        Facter.debug "Cannot parse zone facts, #{zoneadm_cmd} returned no output"
+        rows = []
+      end
+
+      @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

data/lib/facter/util/unix_root.rb

@@ -0,0 +1,5 @@
+module Facter::Util::Root
+  def self.root?
+    Process.uid == 0
+  end
+end

data/lib/facter/util/uptime.rb

@@ -0,0 +1,81 @@
+require 'time'
+
+# A module to gather uptime facts
+#
+module Facter::Util::Uptime
+  def self.get_uptime_seconds_unix
+    uptime_proc_uptime or uptime_sysctl or uptime_executable
+  end
+
+  def self.get_uptime_seconds_win
+    require 'facter/util/wmi'
+
+    last_boot = ""
+    Facter::Util::WMI.execquery("select * from Win32_OperatingSystem").each do |x|
+      last_boot = x.LastBootupTime
+    end
+    self.compute_uptime(Time.parse(last_boot.split('.').first))
+  end
+
+  private
+
+  def self.uptime_proc_uptime
+    output = Facter::Core::Execution.execute("/bin/cat #{uptime_file} 2>/dev/null")
+
+    if not output.empty?
+      output.chomp.split(" ").first.to_i
+    end
+  end
+
+  def self.uptime_sysctl
+    output = Facter::Core::Execution.execute("#{uptime_sysctl_cmd} 2>/dev/null", :on_fail => nil)
+    if output
+      compute_uptime(Time.at(output.match(/\d+/)[0].to_i))
+    end
+  end
+
+  def self.uptime_executable
+    output = Facter::Core::Execution.execute("#{uptime_executable_cmd} 2>/dev/null", :on_fail => nil)
+
+    if output
+      up=0
+      if output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+):(\d+)/
+        # Regexp handles Solaris, AIX, HP-UX, and Tru64.
+        # 'day(?:s|\(s\))?' says maybe 'day', 'days',
+        #   or 'day(s)', and don't set $2.
+        up=86400*$1.to_i + 3600*$2.to_i + 60*$3.to_i
+      elsif output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) hr(?:s|\(s\))?,/
+        up=86400*$1.to_i + 3600*$2.to_i
+      elsif output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) min(?:s|\(s\))?,/
+        up=86400*$1.to_i + 60*$2.to_i
+      elsif output =~ /(\d+) day(?:s|\(s\))?,/
+        up=86400*$1.to_i
+      elsif output =~ /up\s+(\d+):(\d+),/
+        # must anchor to 'up' to avoid matching time of day
+        # at beginning of line.
+        up=3600*$1.to_i + 60*$2.to_i
+      elsif output =~ /(\d+) hr(?:s|\(s\))?,/
+        up=3600*$1.to_i
+      elsif output =~ /(\d+) min(?:s|\(s\))?,/
+        up=60*$1.to_i
+      end
+      up
+    end
+  end
+
+  def self.compute_uptime(time)
+    (Time.now - time).to_i
+  end
+
+  def self.uptime_file
+    "/proc/uptime"
+  end
+
+  def self.uptime_sysctl_cmd
+    'sysctl -n kern.boottime'
+  end
+
+  def self.uptime_executable_cmd
+    "uptime"
+  end
+end

data/lib/facter/util/values.rb

@@ -0,0 +1,109 @@
+
+module Facter
+  module Util
+    # A util module for facter containing helper methods
+    module Values
+      module_function
+
+      class DeepFreezeError < StandardError; end
+
+      # Duplicate and deeply freeze a given data structure
+      #
+      # @param value [Object] The structure to freeze
+      # @return [void]
+      def deep_freeze(value)
+        case value
+        when Numeric, Symbol, TrueClass, FalseClass, NilClass
+          # These are immutable values, we can safely ignore them
+          value
+        when String
+          value.dup.freeze
+        when Array
+          value.map do |entry|
+            deep_freeze(entry)
+          end.freeze
+        when Hash
+          value.inject({}) do |hash, (key, value)|
+            hash[deep_freeze(key)] = deep_freeze(value)
+            hash
+          end.freeze
+        else
+          raise DeepFreezeError, "Cannot deep freeze #{value}:#{value.class}"
+        end
+      end
+
+      class DeepMergeError < StandardError; end
+
+      # Perform a deep merge of two nested data structures.
+      #
+      # @param left [Object]
+      # @param right [Object]
+      # @param path [Array<String>] The traversal path followed when merging nested hashes
+      #
+      # @return [Object] The merged data structure.
+      def deep_merge(left, right, path = [], &block)
+        ret = nil
+
+        if left.is_a? Hash and right.is_a? Hash
+          ret = left.merge(right) do |key, left_val, right_val|
+            path.push(key)
+            merged = deep_merge(left_val, right_val, path)
+            path.pop
+            merged
+          end
+        elsif left.is_a? Array and right.is_a? Array
+          ret = left.dup.concat(right)
+        elsif right.nil?
+          ret = left
+        elsif left.nil?
+          ret = right
+        elsif left.nil? and right.nil?
+          ret = nil
+        else
+          msg = "Cannot merge #{left.inspect}:#{left.class} and #{right.inspect}:#{right.class}"
+          if not path.empty?
+            msg << " at root"
+            msg << path.map { |part| "[#{part.inspect}]" }.join
+          end
+          raise DeepMergeError, msg
+        end
+
+        ret
+      end
+
+      def convert(value)
+        value = value.to_s if value.is_a?(Symbol)
+        value = value.downcase if value.is_a?(String)
+        value
+      end
+
+      # Flatten the given data structure to something that's suitable to return
+      # as flat facts.
+      #
+      # @param path [String] The fact path to be prefixed to the given value.
+      # @param structure [Object] The data structure to flatten. Nested hashes
+      #   will be recursively flattened, everything else will be returned as-is.
+      #
+      # @return [Hash] The given data structure prefixed with the given path
+      def flatten_structure(path, structure)
+        results = {}
+
+        if structure.is_a? Hash
+          structure.each_pair do |name, value|
+            new_path = "#{path}_#{name}".gsub(/\-|\//, '_')
+            results.merge! flatten_structure(new_path, value)
+          end
+        elsif structure.is_a? Array
+          structure.each_with_index do |value, index|
+            new_path = "#{path}_#{index}"
+            results.merge! flatten_structure(new_path, value)
+          end
+        else
+          results[path] = structure
+        end
+
+        results
+      end
+    end
+  end
+end