facter 2.0.2-universal-darwin → 2.1.0-universal-darwin

data/lib/facter/util/formatter.rb

@@ -23,10 +23,11 @@ module Facter
         # name and separated by "=>"
         if hash.length == 1
           if value = hash.values.first
-            output = value
+            output = value.is_a?(String) ? value : value.inspect
           end
         else
           hash.sort_by { |(name, value)| name }.each do |name,value|
+            value = value.is_a?(String) ? value : value.inspect
             output << "#{name} => #{value}\n"
           end
         end

data/lib/facter/util/ip.rb

@@ -9,7 +9,7 @@ module Facter::Util::IP
       :ipaddress6 => /inet6 (?:addr: )?((?![fe80|::1])(?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/,
       :macaddress => /(?:ether|HWaddr)\s+((\w{1,2}:){5,}\w{1,2})/,
       :netmask  => /(?:Mask:|netmask )([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
-      :mtu  => /MTU:(\d+)/
+      :mtu  => /MTU:?\s*(\d+)/i
     },
     :bsd   => {
       :aliases  => [:openbsd, :netbsd, :freebsd, :darwin, :"gnu/kfreebsd", :dragonfly],

data/lib/facter/util/loader.rb

@@ -112,7 +112,7 @@ class Facter::Util::Loader
     begin
       # Store the file path so we don't try to reload it
       @loaded << file
-      Kernel.load(file)
+      kernel_load(file)
     rescue ScriptError => detail
       # Don't store the path if the file can't be loaded
       # in case it's loadable later on.
@@ -121,6 +121,15 @@ class Facter::Util::Loader
     end
   end
 
+  # Load and execute the Ruby program specified in the file. This exists
+  # for testing purposes.
+  #
+  # @api private
+  # @return [Boolean]
+  def kernel_load(file)
+    Kernel.load(file)
+  end
+
   # Load facts from the environment.  If no name is provided,
   # all will be loaded.
   def load_env(fact = nil)

data/lib/facter/util/manufacturer.rb

@@ -1,30 +1,29 @@
 # mamufacturer.rb
 # Support methods for manufacturer specific facts
 
-module Facter::Manufacturer
+require 'facter/util/posix'
 
+module Facter::Manufacturer
   def self.get_dmi_table()
     case Facter.value(:kernel)
     when 'Linux', 'GNU/kFreeBSD'
-      return nil unless FileTest.exists?("/usr/sbin/dmidecode")
-
-      output=%x{/usr/sbin/dmidecode 2>/dev/null}
+      cmd = '/usr/sbin/dmidecode'
     when 'FreeBSD'
-      return nil unless FileTest.exists?("/usr/local/sbin/dmidecode")
-
-      output=%x{/usr/local/sbin/dmidecode 2>/dev/null}
+      cmd = '/usr/local/sbin/dmidecode'
     when 'NetBSD', 'DragonFly'
-      return nil unless FileTest.exists?("/usr/pkg/sbin/dmidecode")
-
-      output=%x{/usr/pkg/sbin/dmidecode 2>/dev/null}
+      cmd = '/usr/pkg/sbin/dmidecode'
     when 'SunOS'
-      return nil unless FileTest.exists?("/usr/sbin/smbios")
+      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
 
-      output=%x{/usr/sbin/smbios 2>/dev/null}
-    else
-      output=nil
+      return output
     end
-    return output
   end
 
   def self.dmi_find_system_info(name)
@@ -54,7 +53,7 @@ module Facter::Manufacturer
     name.each do |sysctlkey,facterkey|
       Facter.add(facterkey) do
         confine :kernel => [:openbsd, :darwin]
-        setcode "sysctl -n #{sysctlkey} 2>/dev/null"
+        setcode { Facter::Util::POSIX.sysctl(sysctlkey) }
       end
     end
   end

data/lib/facter/util/memory.rb

@@ -2,6 +2,8 @@
 ## Support module for memory related facts
 ##
 
+require 'facter/util/posix'
+
 module Facter::Memory
   def self.meminfo_number(tag)
     memsize = ""
@@ -111,14 +113,10 @@ module Facter::Memory
 
   def self.mem_size_info(kernel = Facter.value(:kernel))
     case kernel
-    when /OpenBSD/i
-      Facter::Core::Execution.exec("sysctl hw.physmem | cut -d'=' -f2")
-    when /FreeBSD/i
-      Facter::Core::Execution.exec("sysctl -n hw.physmem")
+    when /Dragonfly/i, /FreeBSD/i, /OpenBSD/i
+      Facter::Util::POSIX.sysctl("hw.physmem")
     when /Darwin/i
-      Facter::Core::Execution.exec("sysctl -n hw.memsize")
-    when /Dragonfly/i
-      Facter::Core::Execution.exec("sysctl -n hw.physmem")
+      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
@@ -156,7 +154,7 @@ module Facter::Memory
     when /FreeBSD/i
       Facter::Core::Execution.exec('swapinfo -k')
     when /Darwin/i
-      Facter::Core::Execution.exec('sysctl vm.swapusage')
+      Facter::Util::POSIX.sysctl('vm.swapusage')
     when /SunOS/i
       Facter::Core::Execution.exec('/usr/sbin/swap -l 2>/dev/null')
     end
@@ -189,8 +187,8 @@ module Facter::Memory
         0
       end
     when /OpenBSD/i
-      if line =~ /^total: (\d+)k bytes allocated = \d+k used, (\d+)k available$/
-        (is_size) ? $1.to_i : $2.to_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
@@ -207,7 +205,7 @@ module Facter::Memory
         0
       end
     when /SunOS/i
-      if line =~ /^\/\S+\s.*\s+(\d+)\s+(\d+)$/
+      if line =~ /^\S+\s.*\s+(\d+)\s+(\d+)$/
         (is_size) ? $1.to_i : $2.to_i
       else
         0
@@ -217,8 +215,10 @@ module Facter::Memory
 
   def self.scale_swap_value(value, kernel)
     case kernel
-    when /OpenBSD/i, /FreeBSD/i
+    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

data/lib/facter/util/netmask.rb

@@ -17,7 +17,7 @@ module Facter::NetMask
         :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'
+    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,

data/lib/facter/util/operatingsystem.rb

@@ -0,0 +1,21 @@
+module Facter
+  module Util
+    module Operatingsystem
+
+      # @see http://www.freedesktop.org/software/systemd/man/os-release.html
+      def self.os_release(file = '/etc/os-release')
+        values = {}
+
+        if File.readable?(file)
+          File.readlines(file).each do |line|
+            if (match = line.match(/^(\w+)=["']?(.+?)["']?$/))
+              values[match[1]] = match[2]
+            end
+          end
+        end
+
+        values
+      end
+    end
+  end
+end

data/lib/facter/util/partitions.rb

@@ -0,0 +1,41 @@
+require 'facter/util/partitions/linux'
+
+module Facter::Util::Partitions
+  IMPLEMENTATIONS = {
+    'Linux' => Linux
+  }
+
+  module NoImplementation
+    def self.list
+      []
+    end
+  end
+
+  def self.implementation
+    IMPLEMENTATIONS[Facter.fact(:kernel).value] || NoImplementation
+  end
+
+  def self.list
+    implementation.list
+  end
+
+  def self.uuid(partition)
+    implementation.uuid(partition)
+  end
+
+  def self.size(partition)
+    implementation.size(partition)
+  end
+
+  def self.mount(partition)
+    implementation.mount(partition)
+  end
+
+  def self.filesystem(partition)
+    implementation.filesystem(partition)
+  end
+
+  def self.available?
+    !self.list.empty?
+  end
+end

data/lib/facter/util/partitions/linux.rb

@@ -0,0 +1,65 @@
+module Facter::Util::Partitions
+  module Linux
+    # Only Linux 2.6+ kernels support sysfs which is required to easily get device details
+    SYSFS_BLOCK_DIRECTORY     = '/sys/block/'
+    DEVDISK_BY_UUID_DIRECTORY = '/dev/disk/by-uuid/'
+
+    def self.list
+      if File.exist?(SYSFS_BLOCK_DIRECTORY)
+        devices = Dir.entries(SYSFS_BLOCK_DIRECTORY).select { |d| File.exist?( SYSFS_BLOCK_DIRECTORY + d + "/device" ) }
+  
+        if devices.empty?
+          []
+        else
+          devices.collect do |device|
+            Dir.glob( SYSFS_BLOCK_DIRECTORY + device + "/#{device}*" ).collect do |d|
+              File.basename(d)
+            end
+          end.flatten
+        end
+      else
+        []
+      end
+    end
+
+    def self.uuid(partition)
+      uuid = nil
+      if File.exist?(DEVDISK_BY_UUID_DIRECTORY)
+        Dir.entries(DEVDISK_BY_UUID_DIRECTORY).each do |file|
+          qualified_file = File.join(DEVDISK_BY_UUID_DIRECTORY, file)
+
+          #A uuid is 16 octets long (RFC4122) which is 32hex chars + 4 '-'s
+          next unless file.length == 36
+          next unless File.symlink?(qualified_file)
+          next unless File.readlink(qualified_file).match(%r[(?:\.\./\.\./|/dev/)#{partition}$])
+
+          uuid = file
+        end
+      end
+      uuid
+    end
+
+    def self.size(partition)
+      read_size(partition)
+    end
+
+    def self.mount(partition)
+      if Facter::Core::Execution.which('mount')
+        Facter::Core::Execution.exec('mount').scan(/\/dev\/#{partition}\son\s(\S+)/).flatten.first
+      end
+    end
+
+    def self.filesystem(partition)
+      if Facter::Core::Execution.which('blkid')
+        Facter::Core::Execution.exec("blkid #{File.join('/dev', partition)}").scan(/TYPE="(.+)"/).flatten.first
+      end
+    end
+    
+    private
+    def self.read_size(partition)
+      if device = partition.match(/(\D+)/)[1] and File.readable?(File.join(SYSFS_BLOCK_DIRECTORY, device, partition, 'size'))
+        File.read(File.join(SYSFS_BLOCK_DIRECTORY, device, partition, 'size')).chomp
+      end
+    end
+  end
+end

data/lib/facter/util/posix.rb

@@ -0,0 +1,16 @@
+module Facter
+module Util
+module POSIX
+  # Provides a consistent way of invoking sysctl(8) across POSIX platforms
+  #
+  # @param mib [String] the sysctl(8) MIB name
+  #
+  # @api private
+  def sysctl(mib)
+    Facter::Util::Resolution.exec("sysctl -n #{mib} 2>/dev/null")
+  end
+
+  module_function :sysctl
+end
+end
+end

data/lib/facter/util/processor.rb

@@ -271,16 +271,14 @@ module Processor
   def self.enum_kstat
     processor_num = -1
     processor_list = []
-    Thread::exclusive do
-      kstat = Facter::Core::Execution.exec('/usr/bin/kstat cpu_info')
-      if kstat
-        kstat.each_line do |l|
-          if l =~ /cpu_info(\d+)/
-            processor_num = $1.to_i
-          elsif l =~ /brand\s+(.*)\s*$/
-            processor_list[processor_num] = $1 unless processor_num == -1
-            processor_num = -1
-          end
+    kstat = Facter::Core::Execution.exec('/usr/bin/kstat cpu_info')
+    if kstat
+      kstat.each_line do |l|
+        if l =~ /cpu_info(\d+)/
+          processor_num = $1.to_i
+        elsif l =~ /brand\s+(.*)\s*$/
+          processor_list[processor_num] = $1 unless processor_num == -1
+          processor_num = -1
         end
       end
     end

data/lib/facter/util/resolution.rb

@@ -62,6 +62,10 @@ class Facter::Util::Resolution
     @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.
   #

data/lib/facter/util/values.rb

@@ -1,3 +1,4 @@
+
 module Facter
   module Util
     # A util module for facter containing helper methods
@@ -75,6 +76,34 @@ module Facter
         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

data/lib/facter/util/virtual.rb

@@ -1,4 +1,6 @@
+require 'facter/util/posix'
 require 'facter/util/file_read'
+require 'pathname'
 
 module Facter::Util::Virtual
   ##
@@ -92,7 +94,7 @@ module Facter::Util::Virtual
      txt = if FileTest.exists?("/proc/cpuinfo")
        File.read("/proc/cpuinfo")
      elsif ["FreeBSD", "OpenBSD"].include? Facter.value(:kernel)
-       Facter::Core::Execution.exec("/sbin/sysctl -n hw.model")
+       Facter::Util::POSIX.sysctl("hw.model")
      end
      (txt =~ /QEMU Virtual CPU/) ? true : false
   end
@@ -118,6 +120,10 @@ module Facter::Util::Virtual
     File.read("/sys/devices/virtual/dmi/id/product_name") =~ /oVirt Node/ rescue false
   end
 
+  def self.gce?
+    File.read("/sys/devices/virtual/dmi/id/product_name") =~ /Google/ rescue false
+  end
+
   def self.jail?
     path = case Facter.value(:kernel)
       when "FreeBSD" then "/sbin"
@@ -130,6 +136,29 @@ module Facter::Util::Virtual
     Facter::Core::Execution.exec("/usr/bin/getconf MACHINE_MODEL").chomp =~ /Virtual Machine/
   end
 
+  ##
+  # lxc? returns true if the process is running inside of a linux container.
+  # Implementation derived from
+  # http://stackoverflow.com/questions/20010199/determining-if-a-process-runs-inside-lxc-docker
+  def self.lxc?
+    path = Pathname.new('/proc/1/cgroup')
+    return false unless path.readable?
+    in_lxc = path.readlines.any? {|l| l.split(":")[2].to_s.start_with? '/lxc/' }
+    return true if in_lxc
+    return false
+  end
+
+  ##
+  # docker? returns true if the process is running inside of a docker container.
+  # Implementation derived from observation of a boot2docker system
+  def self.docker?
+    path = Pathname.new('/proc/1/cgroup')
+    return false unless path.readable?
+    in_docker = path.readlines.any? {|l| l.split(":")[2].to_s.start_with? '/docker/' }
+    return true if in_docker
+    return false
+  end
+
   def self.zlinux?
     "zlinux"
   end
@@ -142,9 +171,9 @@ module Facter::Util::Virtual
   #
   # @api public
   #
-  # @return [String] or nil if the path does not exist
+  # @return [String] or nil if the path does not exist or is unreadable
   def self.read_sysfs_dmi_entries(path="/sys/firmware/dmi/entries/1-0/raw")
-    if File.exists?(path)
+    if File.readable?(path)
       Facter::Util::FileRead.read_binary(path)
     end
   end