facter 2.0.1.rc1-x86-mingw32

data/lib/facter/ssh.rb

@@ -0,0 +1,72 @@
+# Fact: ssh
+#
+# Purpose:
+#
+# Resolution:
+#
+# Caveats:
+#
+
+## ssh.rb
+## Facts related to SSH
+##
+
+{"SSHDSAKey" => { :file => "ssh_host_dsa_key.pub", :sshfprrtype => 2 },
+ "SSHRSAKey" => { :file => "ssh_host_rsa_key.pub", :sshfprrtype => 1 },
+ "SSHECDSAKey" => { :file => "ssh_host_ecdsa_key.pub", :sshfprrtype => 3 },
+ "SSHED25519Key" => { :file => "ssh_host_ed25519_key.pub", :sshfprrtype => 4 } }.each do |name,key|
+
+  Facter.add(name) do
+    setcode do
+      value = nil
+      
+      [ "/etc/ssh",
+        "/usr/local/etc/ssh",
+        "/etc",
+        "/usr/local/etc",
+        "/etc/opt/ssh",
+      ].each do |dir|
+      
+        filepath = File.join(dir,key[:file])
+      
+        if FileTest.file?(filepath)
+          begin
+            value = File.read(filepath).chomp.split(/\s+/)[1]
+            break
+          rescue
+            value = nil
+          end
+        end
+      end
+      
+      value
+    end
+  end
+  
+  Facter.add('SSHFP_' + name[3..-4]) do
+    setcode do
+      ssh = Facter.fact(name).value
+      value = nil
+      
+      if ssh && key[:sshfprrtype]
+        begin
+          require 'digest/sha1'
+          require 'base64'
+          digest = Base64.decode64(ssh)
+          value = 'SSHFP ' + key[:sshfprrtype].to_s + ' 1 ' + Digest::SHA1.hexdigest(digest)
+          begin
+            require 'digest/sha2'
+            value += "\nSSHFP " + key[:sshfprrtype].to_s + ' 2 ' + Digest::SHA256.hexdigest(digest)
+          rescue
+          end
+        rescue
+          value = nil
+        end
+      end
+      
+      value
+    end
+    
+  end
+  
+end

data/lib/facter/timezone.rb

@@ -0,0 +1,14 @@
+# Fact: timezone
+#
+# Purpose: Return the machine's time zone.
+#
+# Resolution: Uses's Ruby's Time module's Time.new call.
+#
+# Caveats:
+#
+
+Facter.add("timezone") do
+  setcode do
+    Time.new.zone
+  end
+end

data/lib/facter/uniqueid.rb

@@ -0,0 +1,4 @@
+Facter.add(:uniqueid) do
+  setcode 'hostid'
+  confine :kernel => %w{SunOS Linux AIX GNU/kFreeBSD}
+end

data/lib/facter/uptime.rb

@@ -0,0 +1,34 @@
+# Fact: uptime
+#
+# Purpose: return the system uptime in a human readable format.
+#
+# Resolution:
+#   Does basic maths on the "uptime_seconds" fact to return a count of
+#   days, hours and minutes of uptime
+#
+# Caveats:
+#
+
+require 'facter/util/uptime'
+
+Facter.add(:uptime) do
+  setcode do
+    seconds = Facter.fact(:uptime_seconds).value
+
+    unless seconds
+      "unknown"
+    else
+      days    = seconds / (60 * 60 * 24)
+      hours   = seconds / (60 * 60) % 24
+      minutes = seconds / 60 % 60
+
+      case days
+      when 0 then "#{hours}:#{"%02d" % minutes} hours"
+      when 1 then '1 day'
+      else "#{days} days"
+      end
+    end
+
+  end
+end
+

data/lib/facter/uptime_days.rb

@@ -0,0 +1,15 @@
+# Fact: uptime_days
+#
+# Purpose: Return purely number of days of uptime.
+#
+# Resolution: Divides uptime_hours fact by 24.
+#
+# Caveats:
+#
+
+Facter.add(:uptime_days) do
+  setcode do
+    hours = Facter.value(:uptime_hours)
+    hours && hours / 24 # hours in day
+  end
+end

data/lib/facter/uptime_hours.rb

@@ -0,0 +1,15 @@
+# Fact: uptime_hours
+#
+# Purpose: Return purely number of hours of uptime.
+#
+# Resolution: Divides uptime_seconds fact by 3600.
+#
+# Caveats:
+#
+
+Facter.add(:uptime_hours) do
+  setcode do
+    seconds = Facter.value(:uptime_seconds)
+    seconds && seconds / (60 * 60) # seconds in hour
+  end
+end

data/lib/facter/uptime_seconds.rb

@@ -0,0 +1,24 @@
+# Fact: uptime_seconds
+#
+# Purpose: Return purely number of seconds of uptime.
+#
+# Resolution:
+#   Using the 'facter/util/uptime.rb' module, try a verity of methods to acquire
+#   the uptime on Unix.
+#
+#   On Windows, the module calculates the uptime by the "LastBootupTime" Windows
+#   management value.
+#
+# Caveats:
+#
+
+require 'facter/util/uptime'
+
+Facter.add(:uptime_seconds) do
+  setcode { Facter::Util::Uptime.get_uptime_seconds_unix }
+end
+
+Facter.add(:uptime_seconds) do
+  confine :kernel => :windows
+  setcode { Facter::Util::Uptime.get_uptime_seconds_win }
+end

data/lib/facter/util/architecture.rb

@@ -0,0 +1,19 @@
+# A module to help test architecture facts on non-AIX test hardware
+
+module Facter::Util::Architecture
+  ##
+  # lsattr is intended to directly delegate to Facter::Core::Execution.exec in
+  # an effort to make the processorX facts easier to test.  See also the
+  # {lsdev} method.
+  def self.lsattr(command="lsattr -El proc0 -a type")
+    Facter::Core::Execution.exec(command)
+  end
+
+  ##
+  # kernel_fact_value is intended to directly delegate to Facter.value(:kernel)
+  # to make it easier to stub the kernel fact without affecting the entire
+  # system.
+  def self.kernel_fact_value
+    Facter.value(:kernel)
+  end
+end

data/lib/facter/util/collection.rb

@@ -0,0 +1,161 @@
+require 'facter'
+require 'facter/util/fact'
+require 'facter/util/loader'
+
+# Manage which facts exist and how we access them.  Largely just a wrapper
+# around a hash of facts.
+#
+# @api private
+class Facter::Util::Collection
+
+  def initialize(internal_loader, external_loader)
+    @facts = Hash.new
+    @internal_loader = internal_loader
+    @external_loader = external_loader
+  end
+
+  # Return a fact object by name.
+  def [](name)
+    value(name)
+  end
+
+  # Define a new fact or extend an existing fact.
+  #
+  # @param name [Symbol] The name of the fact to define
+  # @param options [Hash] A hash of options to set on the fact
+  #
+  # @return [Facter::Util::Fact] The fact that was defined
+  def define_fact(name, options = {}, &block)
+    fact = create_or_return_fact(name, options)
+
+    if block_given?
+      fact.instance_eval(&block)
+    end
+
+    fact
+  rescue => e
+    Facter.log_exception(e, "Unable to add fact #{name}: #{e}")
+  end
+
+  # Add a resolution mechanism for a named fact.  This does not distinguish
+  # between adding a new fact and adding a new way to resolve a fact.
+  #
+  # @param name [Symbol] The name of the fact to define
+  # @param options [Hash] A hash of options to set on the fact and resolution
+  #
+  # @return [Facter::Util::Fact] The fact that was defined
+  def add(name, options = {}, &block)
+    fact = create_or_return_fact(name, options)
+
+    fact.add(options, &block)
+
+    return fact
+  end
+
+  include Enumerable
+
+  # Iterate across all of the facts.
+  def each
+    load_all
+    @facts.each do |name, fact|
+      value = fact.value
+      unless value.nil?
+        yield name.to_s, value
+      end
+    end
+  end
+
+  # Return a fact by name.
+  def fact(name)
+    name = canonicalize(name)
+
+    # Try to load the fact if necessary
+    load(name) unless @facts[name]
+
+    # Try HARDER
+    internal_loader.load_all unless @facts[name]
+
+    if @facts.empty?
+      Facter.warnonce("No facts loaded from #{internal_loader.search_path.join(File::PATH_SEPARATOR)}")
+    end
+
+    @facts[name]
+  end
+
+  # Flush all cached values.
+  def flush
+    @facts.each { |name, fact| fact.flush }
+    @external_facts_loaded = nil
+  end
+
+  # Return a list of all of the facts.
+  def list
+    load_all
+    return @facts.keys
+  end
+
+  def load(name)
+    internal_loader.load(name)
+    load_external_facts
+  end
+
+  # Load all known facts.
+  def load_all
+    internal_loader.load_all
+    load_external_facts
+  end
+
+  def internal_loader
+    @internal_loader
+  end
+
+  def external_loader
+    @external_loader
+  end
+
+  # Return a hash of all of our facts.
+  def to_hash
+    @facts.inject({}) do |h, ary|
+      value = ary[1].value
+      if ! value.nil?
+        # For backwards compatibility, convert the fact name to a string.
+        h[ary[0].to_s] = value
+      end
+      h
+    end
+  end
+
+  def value(name)
+    if fact = fact(name)
+      fact.value
+    end
+  end
+
+  private
+
+  def create_or_return_fact(name, options)
+    name = canonicalize(name)
+
+    fact = @facts[name]
+
+    if fact.nil?
+      fact = Facter::Util::Fact.new(name, options)
+      @facts[name] = fact
+    else
+      fact.extract_ldapname_option!(options)
+    end
+
+    fact
+  end
+
+  def canonicalize(name)
+    name.to_s.downcase.to_sym
+  end
+
+  def load_external_facts
+    if ! @external_facts_loaded
+      @external_facts_loaded = true
+      external_loader.load(self)
+    end
+  end
+end

data/lib/facter/util/composite_loader.rb

@@ -0,0 +1,12 @@
+# A composite loader that allows for more than one
+# default directory loader
+
+class Facter::Util::CompositeLoader
+  def initialize(loaders)
+    @loaders = loaders
+  end
+
+  def load(collection)
+    @loaders.each { |loader| loader.load(collection) }
+  end
+end

data/lib/facter/util/config.rb

@@ -0,0 +1,61 @@
+require 'rbconfig'
+
+# A module to return config related data
+#
+module Facter::Util::Config
+
+  def self.ext_fact_loader
+    @ext_fact_loader || Facter::Util::DirectoryLoader.default_loader
+  end
+
+  def self.ext_fact_loader=(loader)
+    @ext_fact_loader = loader
+  end
+
+  def self.is_mac?
+    RbConfig::CONFIG['host_os'] =~ /darwin/i
+  end
+
+  # Returns true if OS is windows
+  def self.is_windows?
+    RbConfig::CONFIG['host_os'] =~ /mswin|win32|dos|mingw|cygwin/i
+  end
+
+  def self.windows_data_dir
+    if Dir.const_defined? 'COMMON_APPDATA' then
+      Dir::COMMON_APPDATA
+    else
+      nil
+    end
+  end
+
+  def self.external_facts_dirs=(dir)
+    @external_facts_dirs = dir
+  end
+
+  def self.external_facts_dirs
+    @external_facts_dirs
+  end
+
+  def self.setup_default_ext_facts_dirs
+    if Facter::Util::Root.root?
+      windows_dir = windows_data_dir
+      if windows_dir.nil? then
+        @external_facts_dirs = ["/etc/facter/facts.d", "/etc/puppetlabs/facter/facts.d"]
+      else
+        @external_facts_dirs = [File.join(windows_dir, 'PuppetLabs', 'facter', 'facts.d')]
+      end
+    else
+      @external_facts_dirs = [File.expand_path(File.join("~", ".facter", "facts.d"))]
+    end
+  end
+
+  if Facter::Util::Config.is_windows?
+    require 'win32/dir'
+    require 'facter/util/windows_root'
+  else
+    require 'facter/util/unix_root'
+  end
+
+  setup_default_ext_facts_dirs
+end

data/lib/facter/util/confine.rb

@@ -0,0 +1,66 @@
+# A restricting tag for fact resolution mechanisms.  The tag must be true
+# for the resolution mechanism to be suitable.
+
+require 'facter/util/values'
+
+class Facter::Util::Confine
+  attr_accessor :fact, :values
+
+  include Facter::Util::Values
+
+  # Add the restriction.  Requires the fact name, an operator, and the value
+  # we're comparing to.
+  #
+  # @param fact [Symbol] Name of the fact
+  # @param values [Array] One or more values to match against.
+  #   They can be any type that provides a === method.
+  # @param block [Proc] Alternatively a block can be supplied as a check.  The fact
+  #   value will be passed as the argument to the block.  If the block returns
+  #   true then the fact will be enabled, otherwise it will be disabled.
+  def initialize(fact = nil, *values, &block)
+    raise ArgumentError, "The fact name must be provided" unless fact or block_given?
+    if values.empty? and not block_given?
+      raise ArgumentError, "One or more values or a block must be provided"
+    end
+    @fact = fact
+    @values = values
+    @block = block
+  end
+
+  def to_s
+    return @block.to_s if @block
+    return "'%s' '%s'" % [@fact, @values.join(",")]
+  end
+
+  # Evaluate the fact, returning true or false.
+  # if we have a block paramter then we only evaluate that instead
+  def true?
+    if @block and not @fact then
+      begin
+        return !! @block.call
+      rescue StandardError => error
+        Facter.debug "Confine raised #{error.class} #{error}"
+        return false
+      end
+    end
+
+    unless fact = Facter[@fact]
+      Facter.debug "No fact for %s" % @fact
+      return false
+    end
+    value = convert(fact.value)
+
+    return false if value.nil?
+
+    if @block then
+      begin
+        return !! @block.call(value)
+      rescue StandardError => error
+        Facter.debug "Confine raised #{error.class} #{error}"
+        return false
+      end
+    end
+
+    return @values.any? do |v| convert(v) === value end
+  end
+end