ohai 6.24.2 → 7.0.0.rc.0

data/lib/ohai/plugins/gce.rb

@@ -14,45 +14,39 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-provides "gce"
-
 require 'ohai/mixin/gce_metadata'
 
-# Checks for matching gce dmi
-# https://developers.google.com/compute/docs/instances#dmi
-#
-# === Return
-# true:: If gce dmi matches
-# false:: Otherwise
-GOOGLE_SYSFS_DMI = '/sys/firmware/dmi/entries/1-0/raw'
-def has_google_dmi?
- ::File.read(GOOGLE_SYSFS_DMI).include?('Google')
-end
+Ohai.plugin(:GCE) do
+  include Ohai::Mixin::GCEMetadata
 
-# Checks for gce metadata server
-#
-# === Return
-# true:: If gce metadata server found
-# false:: Otherwise
-def has_gce_metadata?
-  Ohai::Mixin::GCEMetadata.can_metadata_connect?(Ohai::Mixin::GCEMetadata::GCE_METADATA_ADDR,80)
-end
+  provides "gce"
 
-# Identifies gce
-#
-# === Return
-# true:: If gce can be identified
-# false:: Otherwise
-def looks_like_gce?
-  hint?('gce') || has_google_dmi? || has_gce_metadata?
-end
+  # Checks for gce metadata server
+  #
+  # === Return
+  # true:: If gce metadata server found
+  # false:: Otherwise
+  def has_gce_metadata?
+    can_metadata_connect?(Ohai::Mixin::GCEMetadata::GCE_METADATA_ADDR,80)
+  end
+
+  # Identifies gce
+  #
+  # === Return
+  # true:: If gce can be identified
+  # false:: Otherwise
+  def looks_like_gce?
+    hint?('gce') || has_gce_metadata?
+  end
 
-# Adds the gce Mash
-if looks_like_gce?
-  Ohai::Log.debug("looks_like_gce? == true")
-  gce Mash.new
-  Ohai::Mixin::GCEMetadata.fetch_metadata.each {|k, v| gce[k] = v }
-else
-  Ohai::Log.debug("looks_like_gce? == false")
-  false
+  collect_data do
+    if looks_like_gce?
+      Ohai::Log.debug("looks_like_gce? == true")
+      gce Mash.new
+      fetch_metadata.each {|k, v| gce[k] = v }
+    else
+      Ohai::Log.debug("looks_like_gce? == false")
+      false
+    end
+  end
 end

data/lib/ohai/plugins/groovy.rb

@@ -16,20 +16,23 @@
 # limitations under the License.
 #
 
-provides "languages/groovy"
+Ohai.plugin(:Groovy) do
+  provides "languages/groovy"
 
-require_plugin "languages"
+  depends "languages"
 
-output = nil
+  collect_data do
+    output = nil
 
-groovy = Mash.new
+    groovy = Mash.new
 
-status, stdout, stderr = run_command(:no_status_check => true, :command => "groovy -v")
-if status == 0
-  output = stdout.split
-  if output.length >= 2
-    groovy[:version] = output[2]
+    so = shell_out("groovy -v")
+    if so.exitstatus == 0
+      output = so.stdout.split
+      if output.length >= 2
+        groovy[:version] = output[2]
+      end
+      languages[:groovy] = groovy if groovy[:version]
+    end
   end
-  languages[:groovy] = groovy if groovy[:version]
 end
-

data/lib/ohai/plugins/hostname.rb

@@ -1,14 +1,22 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Benjamin Black (<nostromo@gmail.com>)
+# Author:: Bryan McLellan (<btm@loftninjas.org>)
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Author:: James Gartrell (<jgartrel@gmail.com>)
+# Copyright:: Copyright (c) 2008, 2009 Opscode, Inc.
+# Copyright:: Copyright (c) 2009 Bryan McLellan
+# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# Copyright:: Copyright (c) 2010 VMware, Inc.
 # License:: Apache License, Version 2.0
 #
 # 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.
@@ -16,13 +24,127 @@
 # limitations under the License.
 #
 
-provides "fqdn", "domain"
+require 'socket'
+require 'ipaddr'
+
+Ohai.plugin(:Hostname) do
+  provides "domain", "hostname", "fqdn", "machinename"
+
+  # hostname : short hostname
+  # machinename : output of hostname command (might be short on solaris)
+  # fqdn : result of canonicalizing hostname using DNS or /etc/hosts
+  # domain : domain part of FQDN
+  #
+  # hostname and machinename should always exist
+  # fqdn and domain may be broken if DNS is broken on the host
+
+  def from_cmd(cmd)
+    so = shell_out(cmd)
+    so.stdout.split($/)[0]
+  end
+
+  # forward and reverse lookup to canonicalize FQDN (hostname -f equivalent)
+  # this is ipv6-safe, works on ruby 1.8.7+
+  def resolve_fqdn
+    begin
+      hostname = from_cmd("hostname")
+      addrinfo = Socket.getaddrinfo(hostname, nil).first
+      iaddr = IPAddr.new(addrinfo[3])
+      Socket.gethostbyaddr(iaddr.hton)[0]
+    rescue
+      nil
+    end
+  end
+
+  def collect_domain
+    # Domain is everything after the first dot
+    if fqdn
+      fqdn =~ /.+?\.(.*)/
+      domain $1
+    end
+  end
+
+  def collect_hostname
+    # Hostname is everything before the first dot
+    if machinename
+      machinename =~ /(.+?)\./
+      hostname $1
+    elsif fqdn
+      fqdn =~ /(.+?)\./
+      hostname $1
+    end
+  end
+
+  def get_fqdn_from_sigar
+    require 'sigar'
+    sigar = Sigar.new
+    sigar.fqdn
+  end
+
+  def sigar_is_available?
+    begin
+      require 'sigar'
+      true
+    rescue LoadError
+      false
+    end
+  end
+
+  collect_data(:aix, :hpux, :default) do
+    machinename from_cmd("hostname")
+    fqdn sigar_is_available? ? get_fqdn_from_sigar : resolve_fqdn
+    collect_hostname
+    collect_domain
+  end
+
+  collect_data(:darwin, :netbsd, :openbsd) do
+    hostname from_cmd("hostname -s")
+    fqdn resolve_fqdn
+    machinename from_cmd("hostname")
+    collect_domain
+  end
+
+  collect_data(:freebsd) do
+    hostname from_cmd("hostname -s")
+    machinename from_cmd("hostname")
+    fqdn from_cmd("hostname -f")
+    collect_domain
+  end
+
+  collect_data(:linux) do
+    hostname from_cmd("hostname -s")
+    machinename from_cmd("hostname")
+    begin
+      fqdn from_cmd("hostname --fqdn")
+    rescue
+      Ohai::Log.debug("hostname -f returned an error, probably no domain is set")
+    end
+    domain collect_domain
+  end
+
+  collect_data(:solaris2) do
+    machinename from_cmd("hostname")
+    hostname from_cmd("hostname")
+    fqdn resolve_fqdn
+    domain collect_domain
+  end
+
+  collect_data(:windows) do
+    require 'ruby-wmi'
+    require 'socket'
 
-require_plugin "os"
-require_plugin "#{os}::hostname"
+    host = WMI::Win32_ComputerSystem.find(:first)
+    hostname "#{host.Name}"
+    machinename "#{host.Name}"
 
-# Domain is everything after the first dot
-if fqdn
-  fqdn =~ /.+?\.(.*)/
-  domain $1 
+    info = Socket.gethostbyname(Socket.gethostname)
+    if info.first =~ /.+?\.(.*)/
+      fqdn info.first
+    else
+      #host is not in dns. optionally use:
+      #C:\WINDOWS\system32\drivers\etc\hosts
+      fqdn Socket.gethostbyaddr(info.last).first
+    end
+    domain collect_domain
+  end
 end

data/lib/ohai/plugins/ip_scopes.rb

@@ -15,28 +15,43 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-begin
-  require 'ipaddr_extensions'
-
+Ohai.plugin(:IpScopes) do
   provides "network_ip_scope", "privateaddress"
 
-  require_plugin "hostname"
-  require_plugin "network"
+  depends "network/interfaces"
+
+  collect_data do
+    begin
+      require 'ipaddr_extensions'
 
-  network['interfaces'].keys.each do |ifName|
-    next if network['interfaces'][ifName]['addresses'].nil?
+      network['interfaces'].keys.sort.each do |ifName|
+        next if network['interfaces'][ifName]['addresses'].nil?
 
-    network['interfaces'][ifName]['addresses'].each do |address,attrs|
-      begin
-        attrs.merge! 'ip_scope' => address.to_ip.scope
-        privateaddress address if address.to_ip.scope =~ /PRIVATE/
-      rescue ArgumentError
-        # Just silently fail if we can't create an IP from the string.
+        interface = network['interfaces'][ifName]
+        interface['addresses'].each do |address,attrs|
+          begin
+            attrs.merge! 'ip_scope' => address.to_ip.scope
+
+            if private_addr?(address) && !tunnel_iface?(interface)
+              privateaddress(address)
+            end
+          rescue ArgumentError
+            # Just silently fail if we can't create an IP from the string.
+          end
+        end
       end
+
+    rescue LoadError => e
+      # our favourite gem is not installed. Boohoo.
+      Ohai::Log.debug("ip_scopes: cannot load gem, plugin disabled: #{e}")
     end
   end
 
-rescue LoadError => e
-  # our favourite gem is not installed. Boohoo.
-  Ohai::Log.debug("ip_scopes: cannot load gem, plugin disabled: #{e}")
+  def private_addr?(address)
+    address.to_ip.scope =~ /PRIVATE/
+  end
+
+  def tunnel_iface?(interface)
+    interface['type'] == 'ppp'
+  end
 end

data/lib/ohai/plugins/java.rb

@@ -15,32 +15,56 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-provides "languages/java"
 
-require_plugin "languages"
+Ohai.plugin(:Java) do
+  provides "languages/java"
+  depends "languages"
 
-java = Mash.new
+  def get_java_info
+    java = Mash.new
+    so = shell_out("java -version")
+    if so.exitstatus == 0
+      so.stderr.split(/\r?\n/).each do |line|
+        case line
+        when /java version \"([0-9\.\_]+)\"/
+          java[:version] = $1
+        when /^(.+Runtime Environment.*) \((build )?(.+)\)$/
+          java[:runtime] = { "name" => $1, "build" => $3 }
+        when /^(.+ (Client|Server) VM) \(build (.+)\)$/
+          java[:hotspot] = { "name" => $1, "build" => $3 }
+        end
+      end
 
-status, stdout, stderr = nil
-if RUBY_PLATFORM.downcase.include?("darwin")
-  if system("/usr/libexec/java_home >/dev/null 2>&1")
-    status, stdout, stderr = run_command(:no_status_check => true, :command => "java -mx64m -version")
+      languages[:java] = java if java[:version]
+    end
   end
-else
-  status, stdout, stderr = run_command(:no_status_check => true, :command => "java -mx64m -version")
-end
 
-if status == 0
-  stderr.split("\n").each do |line|
-    case line
-    when /java version \"([0-9\.\_]+)\"/
-      java[:version] = $1
-    when /^(.+Runtime Environment.*) \((build )?(.+)\)$/
-      java[:runtime] = { "name" => $1, "build" => $3 }
-    when /^(.+ (Client|Server) VM) \(build (.+)\)$/
-      java[:hotspot] = { "name" => $1, "build" => $3 }
-    end
+  # On Mac OS X, the development tools include "stubs" for JVM executables that
+  # prompt the user to install the JVM if they desire. In our case we simply
+  # wish to detect if the JVM is there and do not want to trigger a popup
+  # window. As a workaround, we can run the java_home executable and check its
+  # exit status to determine if the `java` executable is the real one or the OS
+  # X stub. In the terminal, it looks like this:
+  #
+  #   $ /usr/libexec/java_home
+  #   Unable to find any JVMs matching version "(null)".
+  #   No Java runtime present, try --request to install.
+  #
+  #   $ echo $?
+  #   1
+  #
+  # This check always returns true when not on darwin because it is just a
+  # workaround for this particular annoyance.
+  def has_real_java?
+    return true unless on_darwin?
+    shell_out("/usr/libexec/java_home").status.success?
   end
 
-  languages[:java] = java if java[:version]
+  def on_darwin?
+    RUBY_PLATFORM.downcase.include?("darwin")
+  end
+
+  collect_data do
+    get_java_info if has_real_java?
+  end
 end

data/lib/ohai/plugins/kernel.rb

@@ -1,34 +1,201 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Benjamin Black (<nostromo@gmail.com>)
+# Author:: Bryan McLellan (<btm@loftninjas.org>)
+# Author:: Claire McQuin (<claire@opscode.com>)
+# Author:: James Gartrell (<jgartrel@gmail.com>)
+# Copyright:: Copyright (c) 2008, 2009, 2013 Opscode, Inc.
+# Copyright:: Copyright (c) 2009 Bryan McLellan
 # License:: Apache License, Version 2.0
 #
 # 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.
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 
-provides "kernel"
-
-require_plugin 'ruby'
-
-kernel Mash.new
-case languages[:ruby][:host_os]
-when /mswin|mingw32|windows/
-  require_plugin "windows::kernel"
-  require_plugin "windows::kernel_devices"
-else
-  kernel[:name] = from("uname -s")
-  kernel[:release] = from("uname -r")
-  kernel[:version] = from("uname -v")
-  kernel[:machine] = from("uname -m")
-  kernel[:modules] = Mash.new
+Ohai.plugin(:Kernel) do
+  provides "kernel", "kernel/modules"
+
+  # common initial kernel attribute values
+  def init_kernel
+    kernel Mash.new
+    [["uname -s", :name], ["uname -r", :release],
+     ["uname -v", :version], ["uname -m", :machine]].each do |cmd, property|
+      so = shell_out(cmd)
+      kernel[property] = so.stdout.split($/)[0]
+    end
+    kernel
+  end
+
+  # common *bsd code for collecting modules data
+  def bsd_modules(path)
+    modules = Mash.new
+    so = shell_out("#{Ohai.abs_path(path)}")
+    so.stdout.lines do |line|
+      #  1    7 0xc0400000 97f830   kernel
+      if line =~ /(\d+)\s+(\d+)\s+([0-9a-fx]+)\s+([0-9a-fx]+)\s+([a-zA-Z0-9\_]+)/
+        modules[$5] = { :size => $4, :refcount => $2 }
+      end
+    end
+    modules
+  end
+
+  # windows
+  def machine_lookup(sys_type)
+    return "i386" if sys_type.eql?("X86-based PC")
+    return "x86_64" if sys_type.eql?("x64-based PC")
+    sys_type
+  end
+
+  # windows
+  def os_lookup(sys_type)
+    return "Unknown" if sys_type.to_s.eql?("0")
+    return "Other" if sys_type.to_s.eql?("1")
+    return "MSDOS" if sys_type.to_s.eql?("14")
+    return "WIN3x" if sys_type.to_s.eql?("15")
+    return "WIN95" if sys_type.to_s.eql?("16")
+    return "WIN98" if sys_type.to_s.eql?("17")
+    return "WINNT" if sys_type.to_s.eql?("18")
+    return "WINCE" if sys_type.to_s.eql?("19")
+    return nil
+  end
+
+  collect_data(:default) do
+    kernel init_kernel
+  end
+
+  collect_data(:darwin) do
+    kernel init_kernel
+    kernel[:os] = kernel[:name]
+
+    so = shell_out("sysctl -n hw.optional.x86_64")
+    if so.stdout.split($/)[0].to_i == 1
+      kernel[:machine] = 'x86_64'
+    end
+
+    modules = Mash.new
+    so = shell_out("kextstat -k -l")
+    so.stdout.lines do |line|
+      if line =~ /(\d+)\s+(\d+)\s+0x[0-9a-f]+\s+0x([0-9a-f]+)\s+0x[0-9a-f]+\s+([a-zA-Z0-9\.]+) \(([0-9\.]+)\)/
+        modules[$4] = { :version => $5, :size => $3.hex, :index => $1, :refcount => $2 }
+      end
+    end
+
+    kernel[:modules] = modules
+  end
+
+  collect_data(:freebsd) do
+    kernel init_kernel
+    kernel[:os] = kernel[:name]
+
+    so = shell_out("uname -i")
+    kernel[:ident] = so.stdout.split($/)[0]
+    so = shell_out("sysctl kern.securelevel")
+    kernel[:securelevel] = so.stdout.split($/).select { |e| e =~ /kern.securelevel: (.+)$/ }
+
+    kernel[:modules] = bsd_modules("/sbin/kldstat")
+  end
+
+  collect_data(:linux) do
+    kernel init_kernel
+
+    so = shell_out("uname -o")
+    kernel[:os] = so.stdout.split($/)[0]
+
+    modules = Mash.new
+    so = shell_out("env lsmod")
+    so.stdout.lines do |line|
+      if line =~ /([a-zA-Z0-9\_]+)\s+(\d+)\s+(\d+)/
+        modules[$1] = { :size => $2, :refcount => $3 }
+      end
+    end
+
+    kernel[:modules] = modules
+  end
+
+  collect_data(:netbsd, :openbsd) do
+    kernel init_kernel
+    kernel[:os] = kernel[:name]
+
+    so = shell_out("sysctl kern.securelevel")
+    kernel[:securelevel] = so.stdout.split($/).select { |e| e =~ /kern.securelevel:\ (.+)$/ }
+
+    kernel[:modules] = bsd_modules("/usr/bin/modstat")
+  end
+
+  collect_data(:solaris2) do
+    kernel init_kernel
+
+    so = shell_out("uname -s")
+    kernel[:os] = so.stdout.split($/)[0]
+
+    modules = Mash.new
+
+    so = shell_out("modinfo")
+    # EXAMPLE:
+    # Id Loadaddr   Size Info Rev Module Name
+    #  6  1180000   4623   1   1  specfs (filesystem for specfs)
+    module_description =  /[\s]*([\d]+)[\s]+([a-f\d]+)[\s]+([a-f\d]+)[\s]+(?:[\-\d]+)[\s]+(?:[\d]+)[\s]+([\S]+)[\s]+\((.+)\)$/
+    so.stdout.lines do |line|
+      if mod = module_description.match(line)
+        modules[mod[4]] = { :id => mod[1].to_i, :loadaddr => mod[2], :size => mod[3].to_i(16), :description => mod[5]}
+      end
+    end
+
+    kernel[:modules] = modules
+  end
+
+  collect_data(:windows) do
+    require 'ruby-wmi'
+    WIN32OLE.codepage = WIN32OLE::CP_UTF8
+
+    kernel Mash.new
+
+    host = WMI::Win32_OperatingSystem.find(:first)
+    kernel[:os_info] = Mash.new
+    host.properties_.each do |p|
+      kernel[:os_info][p.name.wmi_underscore.to_sym] = host.send(p.name)
+    end
+
+    kernel[:name] = "#{kernel[:os_info][:caption]}"
+    kernel[:release] = "#{kernel[:os_info][:version]}"
+    kernel[:version] = "#{kernel[:os_info][:version]} #{kernel[:os_info][:csd_version]} Build #{kernel[:os_info][:build_number]}"
+    kernel[:os] = os_lookup(kernel[:os_info][:os_type]) || languages[:ruby][:host_os]
+
+    host = WMI::Win32_ComputerSystem.find(:first)
+    kernel[:cs_info] = Mash.new
+    host.properties_.each do |p|
+      kernel[:cs_info][p.name.wmi_underscore.to_sym] = host.send(p.name)
+    end
+
+    kernel[:machine] = machine_lookup("#{kernel[:cs_info][:system_type]}")
+
+    kext = Mash.new
+    pnp_drivers = Mash.new
+
+    drivers = WMI::Win32_PnPSignedDriver.find(:all)
+    drivers.each do |driver|
+      pnp_drivers[driver.DeviceID] = Mash.new
+      driver.properties_.each do |p|
+        pnp_drivers[driver.DeviceID][p.name.wmi_underscore.to_sym] = driver.send(p.name)
+      end
+      if driver.DeviceName
+        kext[driver.DeviceName] = pnp_drivers[driver.DeviceID]
+        kext[driver.DeviceName][:version] = pnp_drivers[driver.DeviceID][:driver_version]
+        kext[driver.DeviceName][:date] = pnp_drivers[driver.DeviceID][:driver_date] ? pnp_drivers[driver.DeviceID][:driver_date].to_s[0..7] : nil
+      end
+    end
+
+    kernel[:pnp_drivers] = pnp_drivers
+    kernel[:modules] = kext
+  end
 end