ohai 0.5.8 → 0.6.0.beta.0

data/Rakefile

@@ -2,61 +2,29 @@ require 'rubygems'
 require 'rake/gempackagetask'
 require 'rubygems/specification'
 require 'date'
-require 'spec/rake/spectask'
 
-GEM = "ohai"
-GEM_VERSION = "0.5.8"
-AUTHOR = "Adam Jacob"
-EMAIL = "adam@opscode.com"
-HOMEPAGE = "http://wiki.opscode.com/display/ohai"
-SUMMARY = "Ohai profiles your system and emits JSON"
+gemspec = eval(IO.read("ohai.gemspec"))
 
-spec = Gem::Specification.new do |s|
-  s.name = GEM
-  s.version = GEM_VERSION
-  s.platform = Gem::Platform::RUBY
-  s.has_rdoc = true
-  s.summary = SUMMARY
-  s.description = s.summary
-  s.author = AUTHOR
-  s.email = EMAIL
-  s.homepage = HOMEPAGE
-
-  s.add_dependency "json", ">= 1.4.4", "<= 1.4.6"
-  s.add_dependency "extlib"
-  s.add_dependency "systemu"
-  s.add_dependency "mixlib-cli"
-  s.add_dependency "mixlib-config"
-  s.add_dependency "mixlib-log"
-  s.bindir = "bin"
-  s.executables = %w(ohai)
-  
-  s.require_path = 'lib'
-  s.autorequire = GEM
-  s.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{docs,lib,spec}/**/*")
-end
-
-task :default => :spec
-
-desc "Run specs"
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = FileList['spec/**/*_spec.rb']
-  t.spec_opts = %w(-fs --color)
-end
 
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-end
+Rake::GemPackageTask.new(gemspec).define
 
 desc "install the gem locally"
 task :install => [:package] do
-  sh %{gem install pkg/#{GEM}-#{GEM_VERSION}}
+  sh %{gem install pkg/#{ohai}-#{OHAI_VERSION}}
 end
 
-desc "create a gemspec file"
-task :make_spec do
-  File.open("#{GEM}.gemspec", "w") do |file|
-    file.puts spec.to_ruby
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new do |t|
+    t.pattern = 'spec/**/*_spec.rb'
+    t.rspec_opts = %w(-fs --color)
+  end
+rescue LoadError
+  desc "rspec is not installed, this task is disabled"
+  task :spec do
+    abort "rspec is not installed. `(sudo) gem install rspec` to run unit tests"
   end
 end
+
+task :default => :spec

data/bin/ohai

@@ -29,7 +29,7 @@ end
 begin
   # if we're in a source code checkout, we want to run the code from that.
   # have to do this *after* rubygems is loaded.
-  $:.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+  $:.unshift File.expand_path('../../lib', __FILE__)
   require 'ohai/application'
 rescue LoadError
   if missing_rubygems

data/lib/ohai.rb

@@ -16,9 +16,7 @@
 # limitations under the License.
 #
 
+require 'ohai/version'
 require 'ohai/config'
 require 'ohai/system'
 
-module Ohai
-  VERSION = '0.5.8'
-end

data/lib/ohai/mash.rb

@@ -0,0 +1,211 @@
+# Copyright (c) 2009 Dan Kubb
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# ---
+# ---
+
+# Some portions of blank.rb and mash.rb are verbatim copies of software
+# licensed under the MIT license. That license is included below:
+
+# Copyright (c) 2005-2008 David Heinemeier Hansson
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# This class has dubious semantics and we only have it so that people can write
+# params[:key] instead of params['key'].
+class Mash < Hash
+
+  # @param constructor<Object>
+  #   The default value for the mash. Defaults to an empty hash.
+  #
+  # @details [Alternatives]
+  #   If constructor is a Hash, a new mash will be created based on the keys of
+  #   the hash and no default value will be set.
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  # @param key<Object> The default value for the mash. Defaults to nil.
+  #
+  # @details [Alternatives]
+  #   If key is a Symbol and it is a key in the mash, then the default value will
+  #   be set to the value matching the key.
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # @param key<Object> The key to set.
+  # @param value<Object>
+  #   The value to set the key to.
+  #
+  # @see Mash#convert_key
+  # @see Mash#convert_value
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # @param other_hash<Hash>
+  #   A hash to update values in the mash with. The keys and the values will be
+  #   converted to Mash format.
+  #
+  # @return [Mash] The updated mash.
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # @param key<Object> The key to check for. This will be run through convert_key.
+  #
+  # @return [Boolean] True if the key exists in the mash.
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  # def include? def has_key? def member?
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # @param key<Object> The key to fetch. This will be run through convert_key.
+  # @param *extras<Array> Default value.
+  #
+  # @return [Object] The value at key or the default value.
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # @param *indices<Array>
+  #   The keys to retrieve values for. These will be run through +convert_key+.
+  #
+  # @return [Array] The values at each of the provided keys
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # @param hash<Hash> The hash to merge with the mash.
+  #
+  # @return [Mash] A new mash with the hash values merged in.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # @param key<Object>
+  #   The key to delete from the mash.\
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  # @param *rejected<Array[(String, Symbol)] The mash keys to exclude.
+  #
+  # @return [Mash] A new mash without the selected keys.
+  #
+  # @example
+  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { "two" => 2, "three" => 3 }
+  def except(*keys)
+    super(*keys.map {|k| convert_key(k)})
+  end
+
+  # Used to provide the same interface as Hash.
+  #
+  # @return [Mash] This mash unchanged.
+  def stringify_keys!; self end
+
+  # @return [Hash] The mash as a Hash with symbolized keys.
+  def symbolize_keys
+    h = Hash.new(default)
+    each { |key, val| h[key.to_sym] = val }
+    h
+  end
+
+  # @return [Hash] The mash as a Hash with string keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+  # @return [Mash] Convert a Hash into a Mash
+  # The input Hash's default value is maintained
+  def self.from_hash(hash)
+    mash = Mash.new(hash)
+    mash.default = hash.default
+    mash
+  end
+
+  protected
+  # @param key<Object> The key to convert.
+  #
+  # @param [Object]
+  #   The converted key. If the key was a symbol, it will be converted to a
+  #   string.
+  #
+  # @api private
+  def convert_key(key)
+    key.kind_of?(Symbol) ? key.to_s : key
+  end
+
+  # @param value<Object> The value to convert.
+  #
+  # @return [Object]
+  #   The converted value. A Hash or an Array of hashes, will be converted to
+  #   their Mash equivalents.
+  #
+  # @api private
+  def convert_value(value)
+    if value.class == Hash
+      Mash.from_hash(value)
+    elsif value.is_a?(Array)
+      value.collect { |e| convert_value(e) }
+    else
+      value
+    end
+  end
+end

data/lib/ohai/mixin/command.rb

@@ -6,9 +6,9 @@
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-# 
+#
 #     http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -27,42 +27,30 @@ require 'systemu'
 module Ohai
   module Mixin
     module Command
-      
-      def run_command(args={})         
+
+      def run_command(args={})
         if args.has_key?(:creates)
           if File.exists?(args[:creates])
             Ohai::Log.debug("Skipping #{args[:command]} - creates #{args[:creates]} exists.")
             return false
           end
         end
-        
+
         stdout_string = nil
         stderr_string = nil
-                
-        args[:cwd] ||= Dir.tmpdir        
+
+        args[:cwd] ||= Dir.tmpdir
         unless File.directory?(args[:cwd])
           raise Ohai::Exceptions::Exec, "#{args[:cwd]} does not exist or is not a directory"
         end
-        
+
         status = nil
         Dir.chdir(args[:cwd]) do
-          if args[:timeout]
-            begin
-              Timeout.timeout(args[:timeout]) do
-                status, stdout_string, stderr_string = systemu(args[:command])
-              end
-            rescue Exception => e
-              Ohai::Log.error("#{args[:command_string]} exceeded timeout #{args[:timeout]}")
-              raise(e)
-            end
-          else
-            status, stdout_string, stderr_string = systemu(args[:command])
-          end
-
+          status, stdout_string, stderr_string = run_command_backend(args[:command], args[:timeout])
           # systemu returns 42 when it hits unexpected errors
           if status.exitstatus == 42 and stderr_string == ""
             stderr_string = "Failed to run: #{args[:command]}, assuming command not found"
-            Ohai::Log.debug(stderr_string)          
+            Ohai::Log.debug(stderr_string)
           end
 
           if stdout_string
@@ -75,7 +63,7 @@ module Ohai
             Ohai::Log.debug(stderr_string.strip)
             Ohai::Log.debug("---- End #{args[:command]} STDERR ----")
           end
-        
+
           args[:returns] ||= 0
           args[:no_status_check] ||= false
           if status.exitstatus != args[:returns] and not args[:no_status_check]
@@ -88,16 +76,66 @@ module Ohai
       end
 
       module_function :run_command
-           
-      # This is taken directly from Ara T Howard's Open4 library, and then 
+
+      def run_command_unix(command, timeout)
+        stderr_string, stdout_string, status = "", "", nil
+
+        exec_processing_block = lambda do |pid, stdin, stdout, stderr|
+          stdout_string, stderr_string = stdout.string.chomp, stderr.string.chomp
+        end
+
+        if timeout
+          begin
+            Timeout.timeout(timeout) do
+              status = popen4(command, {}, &exec_processing_block)
+            end
+          rescue Timeout::Error => e
+            Chef::Log.error("#{command} exceeded timeout #{timeout}")
+            raise(e)
+          end
+        else
+          status = popen4(command, {}, &exec_processing_block)
+        end
+        return status, stdout_string, stderr_string
+      end
+
+      def run_comand_windows(command, timeout)
+        if timeout
+          begin
+            systemu(command)
+          rescue SystemExit => e
+            raise
+          rescue Timeout::Error => e
+            Ohai::Log.error("#{command} exceeded timeout #{timeout}")
+            raise(e)
+          end
+        else
+          systemu(command)
+        end
+      end
+
+      if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+        alias :run_command_backend :run_command_windows
+      else
+        alias :run_command_backend :run_command_unix
+      end
+      # This is taken directly from Ara T Howard's Open4 library, and then
       # modified to suit the needs of Ohai.  Any bugs here are most likely
       # my own, and not Ara's.
       #
-      # The original appears in external/open4.rb in its unmodified form. 
+      # The original appears in external/open4.rb in its unmodified form.
       #
       # Thanks Ara!
       def popen4(cmd, args={}, &b)
-        
+
+        # Waitlast - this is magic.
+        #
+        # Do we wait for the child process to die before we yield
+        # to the block, or after?  That is the magic of waitlast.
+        #
+        # By default, we are waiting before we yield the block.
+        args[:waitlast] ||= false
+
         args[:user] ||= nil
         unless args[:user].kind_of?(Integer)
           args[:user] = Etc.getpwnam(args[:user]).uid if args[:user]
@@ -114,7 +152,7 @@ module Ohai
         unless args[:environment].has_key?("LC_ALL")
           args[:environment]["LC_ALL"] = "C"
         end
-        
+
         pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
 
         verbose = $VERBOSE
@@ -123,6 +161,8 @@ module Ohai
           ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
           cid = fork {
+            Process.setsid
+
             pw.last.close
             STDIN.reopen pw.first
             pw.first.close
@@ -137,27 +177,32 @@ module Ohai
 
             STDOUT.sync = STDERR.sync = true
 
-            if args[:user]
-              Process.euid = args[:user]
-              Process.uid = args[:user]
-            end
-            
             if args[:group]
               Process.egid = args[:group]
               Process.gid = args[:group]
             end
-            
+
+            if args[:user]
+              Process.euid = args[:user]
+              Process.uid = args[:user]
+            end
+
             args[:environment].each do |key,value|
               ENV[key] = value
             end
-            
+
+            if args[:umask]
+              umask = ((args[:umask].respond_to?(:oct) ? args[:umask].oct : args[:umask].to_i) & 007777)
+              File.umask(umask)
+            end
+
             begin
               if cmd.kind_of?(Array)
                 exec(*cmd)
               else
                 exec(cmd)
               end
-              raise 'forty-two' 
+              raise 'forty-two'
             rescue Exception => e
               Marshal.dump(e, ps.last)
               ps.last.flush
@@ -173,9 +218,6 @@ module Ohai
 
         begin
           e = Marshal.load ps.first
-          # If we get here, exec failed. Collect status of child to prevent
-          # zombies.
-          Process.waitpid(cid)
           raise(Exception === e ? e : "unknown failure!")
         rescue EOFError # If we get an EOF error, then the exec was successful
           42
@@ -187,18 +229,89 @@ module Ohai
 
         pi = [pw.last, pr.first, pe.first]
 
-        if b 
+        if b
           begin
-            b[cid, *pi]
-            Process.waitpid2(cid).last
+            if args[:waitlast]
+              b[cid, *pi]
+              # send EOF so that if the child process is reading from STDIN
+              # it will actually finish up and exit
+              pi[0].close_write
+              Process.waitpid2(cid).last
+            else
+              # This took some doing.
+              # The trick here is to close STDIN
+              # Then set our end of the childs pipes to be O_NONBLOCK
+              # Then wait for the child to die, which means any IO it
+              # wants to do must be done - it's dead.  If it isn't,
+              # it's because something totally skanky is happening,
+              # and we don't care.
+              o = StringIO.new
+              e = StringIO.new
+
+              #pi[0].close
+
+              stdout = pi[1]
+              stderr = pi[2]
+
+              stdout.sync = true
+              stderr.sync = true
+
+              stdout.fcntl(Fcntl::F_SETFL, pi[1].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
+              stderr.fcntl(Fcntl::F_SETFL, pi[2].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
+
+              stdout_finished = false
+              stderr_finished = false
+
+              results = nil
+
+              while !stdout_finished || !stderr_finished
+                begin
+                  channels_to_watch = []
+                  channels_to_watch << stdout if !stdout_finished
+                  channels_to_watch << stderr if !stderr_finished
+                  ready = IO.select(channels_to_watch, nil, nil, 1.0)
+                rescue Errno::EAGAIN
+                ensure
+                  results = Process.waitpid2(cid, Process::WNOHANG)
+                  if results
+                    stdout_finished = true
+                    stderr_finished = true
+                  end
+                end
+
+                if ready && ready.first.include?(stdout)
+                  line = results ? stdout.gets(nil) : stdout.gets
+                  if line
+                    o.write(line)
+                  else
+                    stdout_finished = true
+                  end
+                end
+                if ready && ready.first.include?(stderr)
+                  line = results ? stderr.gets(nil) : stderr.gets
+                  if line
+                    e.write(line)
+                  else
+                    stderr_finished = true
+                  end
+                end
+              end
+              results = Process.waitpid2(cid) unless results
+              o.rewind
+              e.rewind
+              b[cid, pi[0], o, e]
+              results.last
+            end
           ensure
             pi.each{|fd| fd.close unless fd.closed?}
           end
         else
           [cid, pw.last, pr.first, pe.first]
         end
-      end      
-      
+      rescue Errno::ENOENT
+        raise Ohai::Exceptions::Exec, "command #{cmd} doesn't exist or is not in the PATH"
+      end
+
       module_function :popen4
     end
   end