facter 1.6.1 → 1.6.2

data/lib/facter/util/resolution.rb

@@ -9,179 +9,179 @@ require 'facter/util/config'
 require 'timeout'
 
 class Facter::Util::Resolution
-    attr_accessor :interpreter, :code, :name, :timeout
-
-    INTERPRETER = Facter::Util::Config.is_windows? ? "cmd.exe" : "/bin/sh"
-
-    def self.have_which
-        if ! defined?(@have_which) or @have_which.nil?
-            if Facter.value(:kernel) == 'windows'
-                @have_which = false
-            else
-                %x{which which >/dev/null 2>&1}
-                @have_which = ($? == 0)
-            end
-        end
-        @have_which
+  attr_accessor :interpreter, :code, :name, :timeout
+
+  INTERPRETER = Facter::Util::Config.is_windows? ? "cmd.exe" : "/bin/sh"
+
+  def self.have_which
+    if ! defined?(@have_which) or @have_which.nil?
+      if Facter.value(:kernel) == 'windows'
+        @have_which = false
+      else
+        %x{which which >/dev/null 2>&1}
+        @have_which = ($? == 0)
+      end
     end
-
-    # Execute a program and return the output of that program.
+    @have_which
+  end
+
+  # Execute a program and return the output of that program.
+  #
+  # Returns nil if the program can't be found, or if there is a problem
+  # executing the code.
+  #
+  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
+
+    # Try to guess whether the specified code can be executed by looking at the
+    # first word. If it cannot be found on the PATH defer on resolving the fact
+    # by returning nil.
+    # This only fails on shell built-ins, most of which are masked by stuff in 
+    # /bin or of dubious value anyways. In the worst case, "sh -c 'builtin'" can
+    # be used to work around this limitation
     #
-    # Returns nil if the program can't be found, or if there is a problem
-    # executing the code.
-    #
-    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
-
-        # Try to guess whether the specified code can be executed by looking at the
-        # first word. If it cannot be found on the PATH defer on resolving the fact
-        # by returning nil.
-        # This only fails on shell built-ins, most of which are masked by stuff in 
-        # /bin or of dubious value anyways. In the worst case, "sh -c 'builtin'" can
-        # be used to work around this limitation
-        #
-        # Windows' %x{} throws Errno::ENOENT when the command is not found, so we 
-        # can skip the check there. This is good, since builtins cannot be found 
-        # elsewhere.
-        if have_which and !Facter::Util::Config.is_windows?
-            path = nil
-            binary = code.split.first
-            if code =~ /^\//
-                path = binary
-            else
-                path = %x{which #{binary} 2>/dev/null}.chomp
-                # we don't have the binary necessary
-                return nil if path == "" or path.match(/Command not found\./)
-            end
-
-            return nil unless FileTest.exists?(path)
-        end
-
-        out = nil
-
-        begin
-            out = %x{#{code}}.chomp
-        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
+    # Windows' %x{} throws Errno::ENOENT when the command is not found, so we 
+    # can skip the check there. This is good, since builtins cannot be found 
+    # elsewhere.
+    if have_which and !Facter::Util::Config.is_windows?
+      path = nil
+      binary = code.split.first
+      if code =~ /^\//
+        path = binary
+      else
+        path = %x{which #{binary} 2>/dev/null}.chomp
+        # we don't have the binary necessary
+        return nil if path == "" or path.match(/Command not found\./)
+      end
+
+      return nil unless FileTest.exists?(path)
     end
 
-    # Add a new confine to the resolution mechanism.
-    def confine(confines)
-        confines.each do |fact, values|
-            @confines.push Facter::Util::Confine.new(fact, *values)
-        end
-    end
+    out = nil
 
-    def has_weight(weight)
-        @weight = weight
+    begin
+      out = %x{#{code}}.chomp
+    rescue Errno::ENOENT => detail
+      # command not found on Windows
+      return nil
+    rescue => detail
+      $stderr.puts detail
+      return nil
     end
 
-    # Create a new resolution mechanism.
-    def initialize(name)
-        @name = name
-        @confines = []
-        @value = nil
-        @timeout = 0
-        @weight = nil
+    if out == ""
+      return nil
+    else
+      return out
     end
+  end
 
-    # Return the importance of this resolution.
-    def weight
-        if @weight
-            @weight
-        else
-            @confines.length
-        end
+  # Add a new confine to the resolution mechanism.
+  def confine(confines)
+    confines.each do |fact, values|
+      @confines.push Facter::Util::Confine.new(fact, *values)
     end
-
-    # We need this as a getter for 'timeout', because some versions
-    # of ruby seem to already have a 'timeout' method and we can't
-    # seem to override the instance methods, somehow.
-    def limit
-        @timeout
+  end
+
+  def has_weight(weight)
+    @weight = weight
+  end
+
+  # Create a new resolution mechanism.
+  def initialize(name)
+    @name = name
+    @confines = []
+    @value = nil
+    @timeout = 0
+    @weight = nil
+  end
+
+  # Return the importance of this resolution.
+  def weight
+    if @weight
+      @weight
+    else
+      @confines.length
     end
-
-    # Set our code for returning a value.
-    def setcode(string = nil, interp = nil, &block)
-        Facter.warnonce "The interpreter parameter to 'setcode' is deprecated and will be removed in a future version." if interp
-        if string
-            @code = string
-            @interpreter = interp || INTERPRETER
-        else
-            unless block_given?
-                raise ArgumentError, "You must pass either code or a block"
-            end
-            @code = block
-        end
+  end
+
+  # We need this as a getter for 'timeout', because some versions
+  # of ruby seem to already have a 'timeout' method and we can't
+  # seem to override the instance methods, somehow.
+  def limit
+    @timeout
+  end
+
+  # Set our code for returning a value.
+  def setcode(string = nil, interp = nil, &block)
+    Facter.warnonce "The interpreter parameter to 'setcode' is deprecated and will be removed in a future version." if interp
+    if string
+      @code = string
+      @interpreter = interp || INTERPRETER
+    else
+      unless block_given?
+        raise ArgumentError, "You must pass either code or a block"
+      end
+      @code = block
     end
-
-    def interpreter
-      Facter.warnonce "The 'Facter::Util::Resolution.interpreter' method is deprecated and will be removed in a future version."
-      @interpreter
+  end
+
+  def interpreter
+    Facter.warnonce "The 'Facter::Util::Resolution.interpreter' method is deprecated and will be removed in a future version."
+    @interpreter
+  end
+
+  def interpreter=(interp)
+    Facter.warnonce "The 'Facter::Util::Resolution.interpreter=' method is deprecated and will be removed in a future version."
+    @interpreter = interp
+  end
+
+  # Is this resolution mechanism suitable on the system in question?
+  def suitable?
+    unless defined? @suitable
+      @suitable = ! @confines.detect { |confine| ! confine.true? }
     end
 
-    def interpreter=(interp)
-      Facter.warnonce "The 'Facter::Util::Resolution.interpreter=' method is deprecated and will be removed in a future version."
-      @interpreter = interp
-    end
+    return @suitable
+  end
 
-    # Is this resolution mechanism suitable on the system in question?
-    def suitable?
-        unless defined? @suitable
-            @suitable = ! @confines.detect { |confine| ! confine.true? }
-        end
+  def to_s
+    return self.value()
+  end
 
-        return @suitable
-    end
+  # How we get a value for our resolution mechanism.
+  def value
+    result = nil
+    return result if @code == nil
 
-    def to_s
-        return self.value()
-    end
+    starttime = Time.now.to_f
 
-    # How we get a value for our resolution mechanism.
-    def value
-        result = nil
-        return result if @code == nil
-
-        starttime = Time.now.to_f
-
-        begin
-            Timeout.timeout(limit) do
-                if @code.is_a?(Proc)
-                    result = @code.call()
-                else
-                    result = Facter::Util::Resolution.exec(@code)
-                end
-            end
-        rescue Timeout::Error => detail
-            warn "Timed out seeking value for %s" % self.name
-
-            # This call avoids zombies -- basically, create a thread that will
-            # dezombify all of the child processes that we're ignoring because
-            # of the timeout.
-            Thread.new { Process.waitall }
-            return nil
-        rescue => details
-            warn "Could not retrieve %s: %s" % [self.name, details]
-            return nil
+    begin
+      Timeout.timeout(limit) do
+        if @code.is_a?(Proc)
+          result = @code.call()
+        else
+          result = Facter::Util::Resolution.exec(@code)
         end
+      end
+    rescue Timeout::Error => detail
+      warn "Timed out seeking value for %s" % self.name
+
+      # This call avoids zombies -- basically, create a thread that will
+      # dezombify all of the child processes that we're ignoring because
+      # of the timeout.
+      Thread.new { Process.waitall }
+      return nil
+    rescue => details
+      warn "Could not retrieve %s: %s" % [self.name, details]
+      return nil
+    end
 
-        finishtime = Time.now.to_f
-        ms = (finishtime - starttime) * 1000
-        Facter.show_time "#{self.name}: #{"%.2f" % ms}ms"
+    finishtime = Time.now.to_f
+    ms = (finishtime - starttime) * 1000
+    Facter.show_time "#{self.name}: #{"%.2f" % ms}ms"
 
-        return nil if result == ""
-        return result
-    end
+    return nil if result == ""
+    return result
+  end
 end

data/lib/facter/util/uptime.rb

@@ -3,63 +3,63 @@ 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_kstat or uptime_who_dash_b
-    end
+  def self.get_uptime_seconds_unix
+    uptime_proc_uptime or uptime_sysctl or uptime_kstat or uptime_who_dash_b
+  end
 
-    def self.get_uptime_seconds_win
-      require 'facter/util/wmi'
+  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))
+    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
+  private
 
-    def self.uptime_proc_uptime
-        if output = Facter::Util::Resolution.exec("/bin/cat #{uptime_file} 2>/dev/null")
-            output.chomp.split(" ").first.to_i
-        end
+  def self.uptime_proc_uptime
+    if output = Facter::Util::Resolution.exec("/bin/cat #{uptime_file} 2>/dev/null")
+      output.chomp.split(" ").first.to_i
     end
+  end
 
-    def self.uptime_sysctl
-        if output = Facter::Util::Resolution.exec("#{uptime_sysctl_cmd} 2>/dev/null")
-            compute_uptime(Time.at(output.unpack('L').first))
-        end
+  def self.uptime_sysctl
+    if output = Facter::Util::Resolution.exec("#{uptime_sysctl_cmd} 2>/dev/null")
+      compute_uptime(Time.at(output.unpack('L').first))
     end
+  end
 
-    def self.uptime_kstat
-        if output = Facter::Util::Resolution.exec("#{uptime_kstat_cmd} 2>/dev/null")
-            compute_uptime(Time.at(output.chomp.split(/\s/).last.to_i))
-        end
+  def self.uptime_kstat
+    if output = Facter::Util::Resolution.exec("#{uptime_kstat_cmd} 2>/dev/null")
+      compute_uptime(Time.at(output.chomp.split(/\s/).last.to_i))
     end
+  end
 
-    def self.uptime_who_dash_b
-        if output = Facter::Util::Resolution.exec("#{uptime_who_cmd} 2>/dev/null")
-            compute_uptime(Time.parse(output))
-        end
+  def self.uptime_who_dash_b
+    if output = Facter::Util::Resolution.exec("#{uptime_who_cmd} 2>/dev/null")
+      compute_uptime(Time.parse(output))
     end
+  end
 
-    def self.compute_uptime(time)
-        (Time.now - time).to_i
-    end
+  def self.compute_uptime(time)
+    (Time.now - time).to_i
+  end
 
-    def self.uptime_file
-        "/proc/uptime"
-    end
+  def self.uptime_file
+    "/proc/uptime"
+  end
 
-    def self.uptime_sysctl_cmd
-        'sysctl -b kern.boottime'
-    end
+  def self.uptime_sysctl_cmd
+    'sysctl -b kern.boottime'
+  end
 
-    def self.uptime_kstat_cmd
-        'kstat -p unix:::boot_time'
-    end
+  def self.uptime_kstat_cmd
+    'kstat -p unix:::boot_time'
+  end
 
-    def self.uptime_who_cmd
-        'who -b'
-    end
+  def self.uptime_who_cmd
+    'who -b'
+  end
 end

data/lib/facter/util/values.rb

@@ -1,14 +1,14 @@
 # A util module for facter containing helper methods
 module Facter
-    module Util
-        module Values
-            module_function
+  module Util
+    module Values
+      module_function
 
-            def convert(value)
-                value = value.to_s if value.is_a?(Symbol)
-                value = value.downcase if value.is_a?(String)
-                value
-            end    
-        end
+      def convert(value)
+        value = value.to_s if value.is_a?(Symbol)
+        value = value.downcase if value.is_a?(String)
+        value
+      end  
     end
+  end
 end