facter 2.1.0-x64-mingw32

data/lib/facter/util/manufacturer.rb

@@ -0,0 +1,99 @@
+# mamufacturer.rb
+# Support methods for manufacturer specific facts
+
+require 'facter/util/posix'
+
+module Facter::Manufacturer
+  def self.get_dmi_table()
+    case Facter.value(:kernel)
+    when 'Linux', 'GNU/kFreeBSD'
+      cmd = '/usr/sbin/dmidecode'
+    when 'FreeBSD'
+      cmd = '/usr/local/sbin/dmidecode'
+    when 'NetBSD', 'DragonFly'
+      cmd = '/usr/pkg/sbin/dmidecode'
+    when 'SunOS'
+      cmd = '/usr/sbin/smbios'
+    end
+
+    if cmd and (output = Facter::Core::Execution.exec("#{cmd} 2>/dev/null"))
+
+      if output.respond_to?(:force_encoding)
+        output.force_encoding(Encoding::ASCII_8BIT)
+      end
+
+      return output
+    end
+  end
+
+  def self.dmi_find_system_info(name)
+    splitstr=  Facter.value(:kernel) ==  'SunOS' ? "ID  SIZE TYPE" : /^Handle/
+    output = self.get_dmi_table()
+    return if output.nil?
+    name.each_pair do |key,v|
+      v.each do |v2|
+        v2.each_pair do |value,facterkey|
+          output.split(splitstr).each do |line|
+            if line =~ /#{key}/ and line =~ /\n\s+#{value} (.+)\n/
+              result = $1.strip
+              Facter.add(facterkey) do
+                confine :kernel => [ :linux, :freebsd, :netbsd, :sunos, :"gnu/kfreebsd", :dragonfly ]
+                setcode do
+                  result
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def self.sysctl_find_system_info(name)
+    name.each do |sysctlkey,facterkey|
+      Facter.add(facterkey) do
+        confine :kernel => [:openbsd, :darwin]
+        setcode { Facter::Util::POSIX.sysctl(sysctlkey) }
+      end
+    end
+  end
+
+  def self.prtdiag_sparc_find_system_info()
+    # Parses prtdiag for a SPARC architecture string, won't work with Solaris x86
+    output = Facter::Core::Execution.exec('/usr/sbin/prtdiag 2>/dev/null')
+
+    # System Configuration:  Sun Microsystems  sun4u Sun SPARC Enterprise M3000 Server
+    if output and output =~ /^System Configuration:\s+(.+?)\s+(sun\d+\S+)\s+(.+)/
+      Facter.add('manufacturer') do
+        setcode do
+          $1
+        end
+      end
+      Facter.add('productname') do
+        setcode do
+          $3
+        end
+      end
+    end
+
+    Facter.add('serialnumber') do
+      setcode "/usr/sbin/sneep"
+    end
+  end
+
+  def self.win32_find_system_info(name)
+    require 'facter/util/wmi'
+    value = ""
+    wmi = Facter::Util::WMI.connect()
+    name.each do |facterkey, win32key|
+      query = wmi.ExecQuery("select * from Win32_#{win32key.last}")
+      Facter.add(facterkey) do
+        confine :kernel => :windows
+        setcode do
+          query.each { |x| value = x.__send__( (win32key.first).to_sym) }
+          value
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/memory.rb

@@ -0,0 +1,228 @@
+## memory.rb
+## Support module for memory related facts
+##
+
+require 'facter/util/posix'
+
+module Facter::Memory
+  def self.meminfo_number(tag)
+    memsize = ""
+    size = [0]
+    File.readlines("/proc/meminfo").each do |l|
+      size = $1.to_f if l =~ /^#{tag}:\s+(\d+)\s+\S+/
+      if tag == "MemFree" &&
+          l =~ /^(?:Buffers|Cached):\s+(\d+)\s+\S+/
+        size += $1.to_f
+      end
+    end
+    size / 1024.0
+  end
+
+  def self.scale_number(size, multiplier)
+    suffixes = ['', 'kB', 'MB', 'GB', 'TB']
+
+    s = suffixes.shift
+    while s != multiplier
+      s = suffixes.shift
+    end
+
+    while size > 1024.0
+      size /= 1024.0
+      s = suffixes.shift
+    end
+
+    "%.2f %s" % [size, s]
+  end
+
+  def self.vmstat_find_free_memory(args = [])
+    cmd = 'vmstat'
+    cmd += (' ' + args.join(' ')) unless args.empty?
+    row = Facter::Core::Execution.exec(cmd).split("\n")[-1]
+    if row =~ /^\s*\d+\s*\d+\s*\d+\s*\d+\s*(\d+)/
+      memfree = $1
+    end
+  end
+
+  # Darwin had to be different. It's generally opaque with how much RAM it is
+  # using, and this figure could be improved upon too I fear.
+  # Parses the output of "vm_stat", takes the pages free & pages speculative
+  # and multiples that by the page size (also given in output). Ties in with
+  # what activity monitor outputs for free memory.
+  def self.vmstat_darwin_find_free_memory()
+
+    memfree = 0
+    pagesize = 0
+    memspecfree = 0
+
+    vmstats = Facter::Core::Execution.exec('vm_stat')
+    vmstats.each_line do |vmline|
+      case
+      when vmline =~ /page\ssize\sof\s(\d+)\sbytes/
+        pagesize = $1.to_i
+      when vmline =~ /^Pages\sfree:\s+(\d+)\./
+        memfree = $1.to_i
+      when vmline =~ /^Pages\sspeculative:\s+(\d+)\./
+        memspecfree = $1.to_i
+      end
+    end
+
+    freemem = ( memfree + memspecfree ) * pagesize
+  end
+
+  # on AIX use svmon to get the free memory:
+  # it's the third value on the line starting with memory
+  # svmon can be run by non root users
+  def self.svmon_aix_find_free_memory()
+    Facter::Core::Execution.exec("/usr/bin/svmon -O unit=KB") =~ /^memory\s+\d+\s+\d+\s+(\d+)\s+/
+    $1
+  end
+
+  def self.mem_free(kernel = Facter.value(:kernel))
+    output = mem_free_info(kernel)
+    scale_mem_free_value output, kernel
+  end
+
+  def self.mem_free_info(kernel = Facter.value(:kernel))
+    case kernel
+    when /OpenBSD/i, /SunOS/i, /Dragonfly/i
+      vmstat_find_free_memory()
+    when /FreeBSD/i
+      vmstat_find_free_memory(["-H"])
+    when /Darwin/i
+      vmstat_darwin_find_free_memory()
+    when /AIX/i
+      svmon_aix_find_free_memory()
+    end
+  end
+
+  def self.scale_mem_free_value (value, kernel)
+    case kernel
+    when /OpenBSD/i, /FreeBSD/i, /SunOS/i, /Dragonfly/i, /AIX/i
+      value.to_f / 1024.0
+    when /Darwin/i
+      value.to_f / 1024.0 / 1024.0
+    else
+      value.to_f
+    end
+ end
+
+  def self.mem_size(kernel = Facter.value(:kernel))
+    output = mem_size_info(kernel)
+    scale_mem_size_value output, kernel
+  end
+
+  def self.mem_size_info(kernel = Facter.value(:kernel))
+    case kernel
+    when /Dragonfly/i, /FreeBSD/i, /OpenBSD/i
+      Facter::Util::POSIX.sysctl("hw.physmem")
+    when /Darwin/i
+      Facter::Util::POSIX.sysctl("hw.memsize")
+    when /AIX/i
+      if Facter::Core::Execution.exec("/usr/bin/svmon -O unit=KB") =~ /^memory\s+(\d+)\s+/
+        $1
+      end
+    end
+  end
+
+  def self.scale_mem_size_value(value, kernel)
+    case kernel
+    when /OpenBSD/i, /FreeBSD/i, /Darwin/i, /Dragonfly/i
+      value.to_f / 1024.0 / 1024.0
+    when /AIX/i
+      value.to_f / 1024.0
+    else
+      value.to_f
+    end
+  end
+
+  def self.swap_size(kernel = Facter.value(:kernel))
+    output = swap_info(kernel)
+    parse_swap output, kernel, :size if output
+  end
+
+  def self.swap_free(kernel = Facter.value(:kernel))
+    output = swap_info(kernel)
+    parse_swap output, kernel, :free if output
+  end
+
+  def self.swap_info(kernel = Facter.value(:kernel))
+    case kernel
+    when /AIX/i
+      (Facter.value(:id) == "root") ? Facter::Core::Execution.exec('swap -l 2>/dev/null') : nil
+    when /OpenBSD/i
+      Facter::Core::Execution.exec('swapctl -s')
+    when /FreeBSD/i
+      Facter::Core::Execution.exec('swapinfo -k')
+    when /Darwin/i
+      Facter::Util::POSIX.sysctl('vm.swapusage')
+    when /SunOS/i
+      Facter::Core::Execution.exec('/usr/sbin/swap -l 2>/dev/null')
+    end
+  end
+
+  def self.parse_swap (output, kernel = Facter.value(:kernel), size_or_free = :size)
+    value_in_mb = 0.0
+    value = 0
+    is_size = size_or_free == :size
+    unless output.nil?
+      output.each_line do |line|
+        value += parse_swap_line(line, kernel, is_size)
+      end
+    end      
+    value_in_mb = scale_swap_value(value, kernel)
+  end
+
+  # There is a lot of duplication here because of concern over being able to add
+  # new platforms in a reasonable manner. For all of these platforms the first
+  # regex corresponds to the swap size value and the second corresponds to the swap
+  # free value, but this may not always be the case. In Ruby 1.9.3 it is possible
+  # to give these names, but sadly 1.8.7 does not support this.
+ 
+  def self.parse_swap_line(line, kernel, is_size)
+    case kernel
+    when /AIX/i
+      if line =~ /^\/\S+\s.*\s+(\S+)MB\s+(\S+)MB/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    when /OpenBSD/i
+      if line =~ /^total: (\d+) (\d+)-blocks allocated, (\d+) used, (\d+) available$/
+        (is_size) ? ($1.to_i * $2.to_i) : ($4.to_i * $2.to_i)
+      else
+        0
+      end
+    when /FreeBSD/i
+      if line =~ /\S+\s+(\d+)\s+\d+\s+(\d+)\s+\d+%$/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    when /Darwin/i
+      if line =~ /total\s=\s(\S+)M\s+used\s=\s\S+M\s+free\s=\s(\S+)M\s/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    when /SunOS/i
+      if line =~ /^\S+\s.*\s+(\d+)\s+(\d+)$/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    end
+  end
+
+  def self.scale_swap_value(value, kernel)
+    case kernel
+    when /FreeBSD/i
+      value.to_f / 1024.0
+    when /OpenBSD/i
+      value.to_f / 1024.0 / 1024.0
+    when /SunOS/i
+      value.to_f / 2 / 1024.0
+    else
+      value.to_f
+    end
+  end
+end

data/lib/facter/util/netmask.rb

@@ -0,0 +1,40 @@
+module Facter::NetMask
+  def self.get_netmask
+    netmask = nil;
+    ipregex = %r{(\d{1,3}\.){3}\d{1,3}}
+
+    ops = nil
+    case Facter.value(:kernel)
+    when 'Linux'
+      ops = {
+        :ifconfig_opts => ['2>/dev/null'],
+        :regex => %r{#{Facter.value(:ipaddress)}.*?(?:Mask:|netmask)\s*(#{ipregex})}x,
+        :munge => nil,
+      }
+    when 'SunOS'
+      ops = {
+        :ifconfig_opts => ['-a'],
+        :regex => %r{\s+ inet \s #{Facter.value(:ipaddress)} \s netmask \s (\w{8})}x,
+        :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
+      }
+    when 'FreeBSD','NetBSD','OpenBSD', 'Darwin', 'GNU/kFreeBSD', 'DragonFly', 'AIX'
+      ops = {
+        :ifconfig_opts => ['-a'],
+        :regex => %r{\s+ inet \s #{Facter.value(:ipaddress)} \s netmask \s 0x(\w{8})}x,
+        :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
+      }
+    end
+
+    String(Facter::Util::IP.exec_ifconfig(ops[:ifconfig_opts])).split(/\n/).collect do |line|
+      matches = line.match(ops[:regex])
+      if !matches.nil?
+        if ops[:munge].nil?
+          netmask = matches[1]
+        else
+          netmask = ops[:munge].call(matches[1])
+        end
+      end
+    end
+    netmask
+  end
+end

data/lib/facter/util/normalization.rb

@@ -0,0 +1,94 @@
+module Facter
+  module Util
+    module Normalization
+      class NormalizationError < StandardError; end
+
+      VALID_TYPES = [Integer, Float, TrueClass, FalseClass, NilClass, String, Array, Hash]
+
+      module_function
+
+      # Recursively normalize the given data structure
+      #
+      # @api public
+      # @raise [NormalizationError] If the data structure contained an invalid element.
+      # @return [void]
+      def normalize(value)
+        case value
+        when Integer, Float, TrueClass, FalseClass, NilClass
+          value
+        when String
+          normalize_string(value)
+        when Array
+          normalize_array(value)
+        when Hash
+          normalize_hash(value)
+        else
+          raise NormalizationError, "Expected #{value} to be one of #{VALID_TYPES.inspect}, but was #{value.class}"
+        end
+      end
+
+      # @!method normalize_string(value)
+      #
+      # Attempt to normalize and validate the given string.
+      #
+      # On Ruby 1.8 the string is checked by stripping out all non UTF-8
+      # characters and comparing the converted string to the original. If they
+      # do not match then the string is considered invalid.
+      #
+      # On Ruby 1.9+, the string is validate by checking that the string encoding
+      # is UTF-8 and that the string content matches the encoding. If the string
+      # is not an expected encoding then it is converted to UTF-8.
+      #
+      # @api public
+      # @raise [NormalizationError] If the string used an unsupported encoding or did not match its encoding
+      # @param value [String]
+      # @return [void]
+
+      if RUBY_VERSION =~ /^1\.8/
+        require 'iconv'
+
+        def normalize_string(value)
+          converted = Iconv.conv('UTF-8//IGNORE', 'UTF-8', value)
+          if converted != value
+            raise NormalizationError, "String #{value.inspect} is not valid UTF-8"
+          end
+          value
+        end
+      else
+        def normalize_string(value)
+          value = value.encode(Encoding::UTF_8)
+
+          unless value.valid_encoding?
+            raise NormalizationError, "String #{value.inspect} doesn't match the reported encoding #{value.encoding}"
+          end
+
+          value
+        rescue EncodingError
+          raise NormalizationError, "String encoding #{value.encoding} is not UTF-8 and could not be converted to UTF-8"
+        end
+      end
+
+      # Validate all elements of the array.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the elements failed validation
+      # @param value [Array]
+      # @return [void]
+      def normalize_array(value)
+        value.collect do |elem|
+          normalize(elem)
+        end
+      end
+
+      # Validate all keys and values of the hash.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the keys or values failed normalization
+      # @param value [Hash]
+      # @return [void]
+      def normalize_hash(value)
+        Hash[value.collect { |k, v| [ normalize(k), normalize(v) ] } ]
+      end
+    end
+  end
+end