ohai 6.24.2 → 7.0.0.rc.0

data/lib/ohai/plugins/solaris2/virtualization.rb

@@ -18,74 +18,69 @@
 # limitations under the License.
 #
 
-provides "virtualization"
+Ohai.plugin(:Virtualization) do
+  provides "virtualization"
 
-virtualization Mash.new
+  collect_data(:solaris2) do
+    virtualization Mash.new
 
-# Detect KVM/QEMU from cpuinfo, report as KVM
-psrinfo_path="/usr/sbin/psrinfo"
-if File.exists?(psrinfo_path)
-  popen4(psrinfo_path + " -pv") do |pid, stdin, stdout, stderr|
-    stdin.close
-    psr_info = stdout.read
-    if psr_info =~ /QEMU Virtual CPU/
-      virtualization[:system] = "kvm"
-      virtualization[:role] = "guest"
-    end
-  end
-end
-
-# http://www.dmo.ca/blog/detecting-virtualization-on-linux
-smbios_path="/usr/sbin/smbios"
-if File.exists?(smbios_path)
-  popen4(smbios_path) do |pid, stdin, stdout, stderr|
-    stdin.close
-    dmi_info = stdout.read
-    case dmi_info
-    when /Manufacturer: Microsoft/
-      if dmi_info =~ /Product: Virtual Machine/ 
-        virtualization[:system] = "virtualpc"
-        virtualization[:role] = "guest"
-      end 
-    when /Manufacturer: VMware/
-      if dmi_info =~ /Product: VMware Virtual Platform/ 
-        virtualization[:system] = "vmware"
+    # Detect KVM/QEMU from cpuinfo, report as KVM
+    psrinfo_path = Ohai.abs_path( "/usr/sbin/psrinfo" )
+    if File.exists?(psrinfo_path)
+      so = shell_out("#{psrinfo_path} -pv")
+      if so.stdout =~ /QEMU Virtual CPU/
+        virtualization[:system] = "kvm"
         virtualization[:role] = "guest"
       end
-    else
-      nil
     end
-  end
-end
 
-if File.executable?('/usr/sbin/zoneadm')
-  zones = Mash.new
+    # http://www.dmo.ca/blog/detecting-virtualization-on-linux
+    smbios_path= Ohai.abs_path( "/usr/sbin/smbios" )
+    if File.exists?(smbios_path)
+      so = shell_out(smbios_path)
+      case so.stdout
+      when /Manufacturer: Microsoft/
+        if so.stdout =~ /Product: Virtual Machine/ 
+          virtualization[:system] = "virtualpc"
+          virtualization[:role] = "guest"
+        end 
+      when /Manufacturer: VMware/
+        if so.stdout =~ /Product: VMware Virtual Platform/ 
+          virtualization[:system] = "vmware"
+          virtualization[:role] = "guest"
+        end
+      else
+        nil
+      end
+    end
 
-  popen4("zoneadm list -pc") do |pid, stdin, stdout, stderr|
-    stdin.close
-    stdout.each{ |line|
-      info = line.chomp.split(/:/)
-      zones[info[1]] = {
-        'id' => info[0],
-        'state' => info[2],
-        'root' => info[3],
-        'uuid' => info[4],
-        'brand' => info[5],
-        'ip' => info[6],
-      }
-    }
-    
-    if (zones.length == 1)
-      first_zone = zones.keys[0]
-      unless( first_zone == 'global')
+    if File.executable?('/usr/sbin/zoneadm')
+      zones = Mash.new
+      so = shell_out("zoneadm list -pc")
+      so.stdout.lines do |line|
+        info = line.chomp.split(/:/)
+        zones[info[1]] = {
+          'id' => info[0],
+          'state' => info[2],
+          'root' => info[3],
+          'uuid' => info[4],
+          'brand' => info[5],
+          'ip' => info[6],
+        }
+      end
+        
+      if (zones.length == 1)
+        first_zone = zones.keys[0]
+        unless( first_zone == 'global')
+          virtualization[:system] = 'zone'
+          virtualization[:role] = 'guest'
+          virtualization[:guest_uuid] = zones[first_zone]['uuid']
+        end
+      elsif (zones.length > 1)
         virtualization[:system] = 'zone'
-        virtualization[:role] = 'guest'
-        virtualization[:guest_uuid] = zones[first_zone]['uuid']
+        virtualization[:role] = 'host'
+        virtualization[:guests] = zones
       end
-    elsif (zones.length > 1)
-      virtualization[:system] = 'zone'
-      virtualization[:role] = 'host'
-      virtualization[:guests] = zones
     end
   end
 end

data/lib/ohai/plugins/solaris2/zpools.rb

@@ -16,49 +16,49 @@
 # limitations under the License.
 #
 
-provides "zpools"
+Ohai.plugin(:Zpools) do
+  provides "zpools"
 
-pools = Mash.new
+  collect_data(:solaris2) do
+    pools = Mash.new
 
-# Grab ZFS zpools overall health and attributes
-popen4("zpool list -H -o name,size,alloc,free,cap,dedup,health,version") do |pid, stdin, stdout, stderr|
-  stdin.close
-  stdout.each do |line|
-    case line
-    when /^([-_0-9A-Za-z]*)\s+([.0-9]+[MGTPE])\s+([.0-9]+[MGTPE])\s+([.0-9]+[MGTPE])\s+(\d+%)\s+([.0-9]+x)\s+([-_0-9A-Za-z]+)\s+(\d+)$/
-      pools[$1] = Mash.new
-      pools[$1][:pool_size] = $2
-      pools[$1][:pool_allocated] = $3
-      pools[$1][:pool_free] = $4
-      pools[$1][:capacity_used] = $5
-      pools[$1][:dedup_factor] = $6
-      pools[$1][:health] = $7
-      pools[$1][:zpool_version] = $8
+    # Grab ZFS zpools overall health and attributes
+    so = shell_out("zpool list -H -o name,size,alloc,free,cap,dedup,health,version")
+    so.stdout.lines do |line|
+      case line
+      when /^([-_0-9A-Za-z]*)\s+([.0-9]+[MGTPE])\s+([.0-9]+[MGTPE])\s+([.0-9]+[MGTPE])\s+(\d+%)\s+([.0-9]+x)\s+([-_0-9A-Za-z]+)\s+(\d+)$/
+        pools[$1] = Mash.new
+        pools[$1][:pool_size] = $2
+        pools[$1][:pool_allocated] = $3
+        pools[$1][:pool_free] = $4
+        pools[$1][:capacity_used] = $5
+        pools[$1][:dedup_factor] = $6
+        pools[$1][:health] = $7
+        pools[$1][:zpool_version] = $8
+      end
     end
-  end
-end
 
-# Grab individual health for devices in the zpools
-for pool in pools.keys
-  pools[pool][:devices] = Mash.new
-  # Run "zpool status" as non-root user (adm) so that 
-  # the command won't try to open() each device which can
-  # hang the command if any of the disks are bad.
-  popen4("su adm -c \"zpool status #{pool}\"") do |pid, stdin, stdout, stderr|
-    stdin.close
-    stdout.each do |line|
-      case line
-      when /^\s+(c[-_a-zA-Z0-9]+)\s+([-_a-zA-Z0-9]+)\s+(\d+)\s+(\d+)\s+(\d+)$/
-        pools[pool][:devices][$1] = Mash.new
-        pools[pool][:devices][$1][:state] = $2
-        pools[pool][:devices][$1][:errors] = Mash.new
-        pools[pool][:devices][$1][:errors][:read] = $3
-        pools[pool][:devices][$1][:errors][:write] = $4
-        pools[pool][:devices][$1][:errors][:checksum] = $5
+    # Grab individual health for devices in the zpools
+    for pool in pools.keys
+      pools[pool][:devices] = Mash.new
+      # Run "zpool status" as non-root user (adm) so that 
+      # the command won't try to open() each device which can
+      # hang the command if any of the disks are bad.
+      so = shell_out("su adm -c \"zpool status #{pool}\"")
+      so.stdout.lines do |line|
+        case line
+        when /^\s+(c[-_a-zA-Z0-9]+)\s+([-_a-zA-Z0-9]+)\s+(\d+)\s+(\d+)\s+(\d+)$/
+          pools[pool][:devices][$1] = Mash.new
+          pools[pool][:devices][$1][:state] = $2
+          pools[pool][:devices][$1][:errors] = Mash.new
+          pools[pool][:devices][$1][:errors][:read] = $3
+          pools[pool][:devices][$1][:errors][:write] = $4
+          pools[pool][:devices][$1][:errors][:checksum] = $5
+        end
       end
     end
+
+    # Set the zpools data
+    zpools pools
   end
 end
-
-# Set the zpools data
-zpools pools

data/lib/ohai/plugins/ssh_host_key.rb

@@ -16,58 +16,62 @@
 # limitations under the License.
 #
 
-provides "keys/ssh"
-require_plugin "keys"
+Ohai.plugin(:SSHHostKey) do
+  provides "keys/ssh"
+  depends "keys"
 
-keys[:ssh] = Mash.new
-
-def extract_keytype?(content)
-  case content[0]
-  when "ssh-dss"
-    [ "dsa", nil ]
-  when "ssh-rsa"
-    [ "rsa", nil ]
-  when /^ecdsa/
-    [ "ecdsa", content[0] ]
-  else
-    [ nil, nil ]
+  def extract_keytype?(content)
+    case content[0]
+    when "ssh-dss"
+      [ "dsa", nil ]
+    when "ssh-rsa"
+      [ "rsa", nil ]
+    when /^ecdsa/
+      [ "ecdsa", content[0] ]
+    else
+      [ nil, nil ]
+    end
   end
-end
 
-sshd_config = if File.exists?("/etc/ssh/sshd_config")
-                "/etc/ssh/sshd_config"
-              elsif File.exists?("/etc/sshd_config")
-                # Darwin
-                "/etc/sshd_config"
-              else
-                Ohai::Log.debug("Failed to find sshd configuration file")
-                nil
-              end
+  collect_data do
+    keys[:ssh] = Mash.new
 
-if sshd_config
-  File.open(sshd_config) do |conf|
-    conf.each_line do |line|
-      if line.match(/^hostkey\s/i)
-        pub_file = "#{line.split[1]}.pub"
-        content = IO.read(pub_file).split
-        key_type, key_subtype = extract_keytype?(content)
-        keys[:ssh]["host_#{key_type}_public"] = content[1] unless key_type.nil?
-        keys[:ssh]["host_#{key_type}_type"] = key_subtype unless key_subtype.nil?
+    sshd_config = if File.exists?("/etc/ssh/sshd_config")
+                    "/etc/ssh/sshd_config"
+                  elsif File.exists?("/etc/sshd_config")
+                    # Darwin
+                    "/etc/sshd_config"
+                  else
+                    Ohai::Log.debug("Failed to find sshd configuration file")
+                    nil
+                  end
+
+    if sshd_config
+      File.open(sshd_config) do |conf|
+        conf.each_line do |line|
+          if line.match(/^hostkey\s/i)
+            pub_file = "#{line.split[1]}.pub"
+            content = IO.read(pub_file).split
+            key_type, key_subtype = extract_keytype?(content)
+            keys[:ssh]["host_#{key_type}_public"] = content[1] unless key_type.nil?
+            keys[:ssh]["host_#{key_type}_type"] = key_subtype unless key_subtype.nil?
+          end
+        end
       end
     end
-  end
-end
 
-if keys[:ssh][:host_dsa_public].nil? && File.exists?("/etc/ssh/ssh_host_dsa_key.pub")
-  keys[:ssh][:host_dsa_public] = IO.read("/etc/ssh/ssh_host_dsa_key.pub").split[1]
-end
+    if keys[:ssh][:host_dsa_public].nil? && File.exists?("/etc/ssh/ssh_host_dsa_key.pub")
+      keys[:ssh][:host_dsa_public] = IO.read("/etc/ssh/ssh_host_dsa_key.pub").split[1]
+    end
 
-if keys[:ssh][:host_rsa_public].nil? && File.exists?("/etc/ssh/ssh_host_rsa_key.pub")
-  keys[:ssh][:host_rsa_public] = IO.read("/etc/ssh/ssh_host_rsa_key.pub").split[1]
-end
+    if keys[:ssh][:host_rsa_public].nil? && File.exists?("/etc/ssh/ssh_host_rsa_key.pub")
+      keys[:ssh][:host_rsa_public] = IO.read("/etc/ssh/ssh_host_rsa_key.pub").split[1]
+    end
 
-if keys[:ssh][:host_ecdsa_public].nil? && File.exists?("/etc/ssh/ssh_host_ecdsa_key.pub")
-  content = IO.read("/etc/ssh/ssh_host_ecdsa_key.pub")
-  keys[:ssh][:host_ecdsa_public] = content.split[1]
-  keys[:ssh][:host_ecdsa_type] = content.split[0]
+    if keys[:ssh][:host_ecdsa_public].nil? && File.exists?("/etc/ssh/ssh_host_ecdsa_key.pub")
+      content = IO.read("/etc/ssh/ssh_host_ecdsa_key.pub")
+      keys[:ssh][:host_ecdsa_public] = content.split[1]
+      keys[:ssh][:host_ecdsa_type] = content.split[0]
+    end
+  end
 end

data/lib/ohai/plugins/uptime.rb

@@ -1,42 +1,104 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Bryan McLellan (<btm@loftninjas.org>)
+# Author:: Claire McQuin (<claire@opscode.com>)
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Author:: Kurt Yoder (<ktyopscode@yoderhome.com>)
+# Author:: Paul Mooring (<paul@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2012, 2013 Opscode, Inc.
+# Copyright:: Copyright (c) 2009 Bryan McLellan
+# 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.
+# 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.
 #
 
-def _seconds_to_human(seconds)
-  days = seconds.to_i / 86400
-  seconds -= 86400 * days
-  
-  hours = seconds.to_i / 3600
-  seconds -= 3600 * hours
-  
-  minutes = seconds.to_i / 60
-  seconds -= 60 * minutes
-    
-  if days > 1
-    return sprintf("%d days %02d hours %02d minutes %02d seconds", days, hours, minutes, seconds)
-  elsif days == 1
-    return sprintf("%d day %02d hours %02d minutes %02d seconds", days, hours, minutes, seconds)
-  elsif hours > 0
-    return sprintf("%d hours %02d minutes %02d seconds", hours, minutes, seconds)
-  elsif minutes > 0
-    return sprintf("%d minutes %02d seconds", minutes, seconds)
-  else
-    return sprintf("%02d seconds", seconds)
+require 'ohai/mixin/seconds_to_human'
+
+Ohai.plugin(:Uptime) do
+  provides "uptime", "uptime_seconds"
+  provides "idletime", "idletime_seconds" # linux only
+
+  def collect_uptime(path)
+    # kern.boottime: { sec = 1232765114, usec = 823118 } Fri Jan 23 18:45:14 2009
+    so = shell_out("#{Ohai.abs_path(path)} kern.boottime")
+    so.stdout.lines do |line|
+      if line =~ /kern.boottime:\D+(\d+)/
+        usec = Time.new.to_i - $1.to_i
+        return [usec, seconds_to_human(usec)]
+      end
+    end
+    return [nil, nil]
+  end
+
+  collect_data(:hpux, :default) do
+    require 'sigar'
+
+    sigar = Sigar.new
+    uptime = sigar.uptime.uptime
+    uptime_seconds uptime.to_i * 1000
+    uptime seconds_to_human(uptime.to_i)
+  end
+
+  collect_data(:darwin) do
+    data = collect_uptime("/usr/sbin/sysctl")
+    uptime_seconds data.first
+    uptime data.last
+  end
+
+  collect_data(:freebsd, :netbsd) do
+    data = collect_uptime("/sbin/sysctl")
+    uptime_seconds data.first
+    uptime data.last
+  end
+
+  collect_data(:linux) do
+    uptime, idletime = File.open("/proc/uptime").gets.split(" ")
+    uptime_seconds uptime.to_i
+    uptime seconds_to_human(uptime.to_i)
+    idletime_seconds idletime.to_i
+    idletime seconds_to_human(idletime.to_i)
   end
-end
 
+  collect_data(:openbsd) do
+    # kern.boottime=Tue Nov  1 14:45:52 2011
+    so = shell_out("#{ Ohai.abs_path( "/sbin/sysctl" )} #kern.boottime")
+    so.stdout.lines do |line|
+      if line =~ /kern.boottime=(.+)/
+        uptime_seconds Time.new.to_i - Time.parse($1).to_i
+        uptime seconds_to_human(uptime_seconds)
+      end
+    end
+  end
+
+  collect_data(:solaris2) do
+    so = shell_out("kstat -p unix:0:system_misc:boot_time")
+    # unix:0:system_misc:boot_time    1343860543
+    so.stdout.lines do |line|
+      if line =~ /unix:0:system_misc:boot_time\s+(\d+)/
+        uptime_seconds Time.new.to_i - $1.to_i
+        uptime seconds_to_human(uptime_seconds)
+      end
+    end
+  end
+
+  collect_data(:windows) do
+    require 'ruby-wmi'
+
+    uptime_seconds ::WMI::Win32_PerfFormattedData_PerfOS_System.find(:first).SystemUpTime.to_i
+    uptime seconds_to_human(uptime_seconds)
+  end
+
+end