ohai 13.3.0 → 13.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 82da0b1a779fb8c56cc2d219a02483ee0cb1b457
-  data.tar.gz: ca97f22a9aa2765a92d5ff2e5526f9f1a49e8caf
+  metadata.gz: 65368dc9cbcaede4fadbcbf469c90fb68a64b4c0
+  data.tar.gz: 6c5a528d552e9cf11a81f6b5181ad86f226ff6cc
 SHA512:
-  metadata.gz: 76632d8ec3f46c4a926a8478de23248f364dedd4f088a9e93cce359bd5d2c7314955d6858e78be9d3b7df229f7eba8286e1048cc3584195aca62056dbef5e8fd
-  data.tar.gz: 8f486adaead3001cdb19f51ee4c4c14eb6329664671f1b334f7198654d89387f5759ea1c4f67c31811b98cecb1751e63eb581d5624a6cdf6c975511daa52cdab
+  metadata.gz: 8b4557d434f813f5b4320274d48a14791a5bd6111c2163ffbc7934efe68d43a71d64d067196da68ca31895dd0947d0e021b80e936a9216e3a01bd398f6d80208
+  data.tar.gz: 848d151c7ff1b30b15971d9d4b7d2e9a34f239f9f256df3f7cc1324b39cb811bf7245f1e15ce39e7ede589f30e3412e4093f27043bd0e4b02da2aa39262ca2dd

data/lib/ohai/mixin/azure_metadata.rb

@@ -0,0 +1,53 @@
+#
+# Author:: Tim Smith (<tsmith@chef.io>)
+# Copyright:: Copyright 2017 Chef Software, 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.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "net/http"
+
+module Ohai
+  module Mixin
+    module AzureMetadata
+
+      AZURE_METADATA_ADDR = "169.254.169.254" unless defined?(AZURE_METADATA_ADDR)
+      AZURE_METADATA_URL = "/metadata/instance?api-version=2017-04-02" unless defined?(AZURE_METADATA_URL)
+
+      # fetch the meta content with a timeout and the required header
+      def http_get(uri)
+        conn = Net::HTTP.start(AZURE_METADATA_ADDR)
+        conn.read_timeout = 6
+        conn.get(uri, initheader = { "Metadata" => "true" })
+      end
+
+      def fetch_metadata
+        Ohai::Log.debug("Mixin AzureMetadata: Fetching metadata from host #{AZURE_METADATA_ADDR} at #{AZURE_METADATA_URL}")
+        response = http_get(AZURE_METADATA_URL)
+        if response.code == "200"
+          begin
+            data = StringIO.new(response.body)
+            parser = FFI_Yajl::Parser.new
+            parser.parse(data)
+          rescue FFI_Yajl::ParseError
+            Ohai::Log.warn("Mixin AzureMetadata: Metadata response is NOT valid JSON")
+            nil
+          end
+        else
+          Ohai::Log.warn("Mixin AzureMetadata: Received resonse code #{response.code} requesting metadata")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ohai/plugins/aix/uptime.rb

@@ -22,16 +22,31 @@ Ohai.plugin(:Uptime) do
 
   collect_data(:aix) do
     require "date"
-    # Example output:
-    # $ who -b
-    #   .       system boot  Jul  9 17:51
-    so = shell_out("who -b")
-    so.stdout.lines.each do |line|
-      if line =~ /.* boot (.+)/
-        uptime_seconds Time.now.to_i - DateTime.parse($1 + " #{Time.now.zone}").strftime("%s").to_i
-        uptime seconds_to_human(uptime_seconds)
-        break
-      end
+    # below we're going to assume that PID 1 is init (this is true 99.99999% of the time)
+    # output will look like this
+    # 1148-20:54:50
+    # This reads as 1148 days, 20 hours, 54 minutes, 50 seconds since the process was started (elapsed)
+    # who -b does not return the YEAR, so we need something more concrete
+    so = shell_out("LC_ALL=POSIX ps -o etime= -p 1").stdout
+
+    # Here we'll check our shell_out for a dash, which indicates there is a # of days involved
+    # We'll chunk off the days, hours (where applicable), minutes, seconds into seperate vars
+    # We also need to do this because ps -o etime= will not display days if the machine has been up for less than 24 hours
+    # If the machine has been up for less than one hour, the shell_out will not output hours hence our else
+    # see here: https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/com.ibm.aix.cmds4/ps.htm#ps__row-d3e109655
+    d = nil
+    h = nil
+    case so
+    when /^\d+-\d/
+      (d, h, m, s) = so.split(/[-:]/)
+    when /^\d+:\d+:\d/
+      (h, m, s) = so.split(/[:]/)
+    else
+      (m, s) = so.split(/[:]/)
     end
+    elapsed_seconds = ((d.to_i * 86400) + (h.to_i * 3600) + (m.to_i * 60) + s.to_i)
+
+    uptime_seconds Time.now.to_i - elapsed_seconds
+    uptime seconds_to_human(elapsed_seconds)
   end
 end

data/lib/ohai/plugins/azure.rb

@@ -1,4 +1,4 @@
-# Copyright:: Copyright (c) 2013-2016 Chef Software, Inc.
+# Copyright:: Copyright 2013-2017 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,23 +15,31 @@
 #
 
 Ohai.plugin(:Azure) do
+  require "ohai/mixin/azure_metadata"
+  require "ohai/mixin/http_helper"
+
+  include Ohai::Mixin::AzureMetadata
+  include Ohai::Mixin::HttpHelper
+
   provides "azure"
 
   collect_data do
-    # The azure hints are populated by the knife plugin for Azure.
-    # The project is located at https://github.com/chef/knife-azure
+    # Before we had the metadata endpoint we relied exclusively on
+    # the knife-azure plugin populating data to the hint file.
     # Please see the lib/chef/knife/azure_server_create.rb file in that
     # project for details
     azure_metadata_from_hints = hint?("azure")
     if azure_metadata_from_hints
-      Ohai::Log.debug("Plugin Azure: azure_metadata_from_hints is present.")
+      Ohai::Log.debug("Plugin Azure: Azure hint is present. Parsing any hint data.")
       azure Mash.new
       azure_metadata_from_hints.each { |k, v| azure[k] = v }
+      azure["metadata"] = parse_metadata
     elsif has_waagent? || has_dhcp_option_245?
-      Ohai::Log.debug("Plugin Azure: No hints present, but system appears to be on azure.")
+      Ohai::Log.debug("Plugin Azure: No hints present, but system appears to be on Azure.")
       azure Mash.new
+      azure["metadata"] = parse_metadata
     else
-      Ohai::Log.debug("Plugin Azure: No hints present for azure and doesn't appear to be azure.")
+      Ohai::Log.debug("Plugin Azure: No hints present and doesn't appear to be on Azure.")
       false
     end
   end
@@ -40,7 +48,7 @@ Ohai.plugin(:Azure) do
   # http://blog.mszcool.com/index.php/2015/04/detecting-if-a-virtual-machine-runs-in-microsoft-azure-linux-windows-to-protect-your-software-when-distributed-via-the-azure-marketplace/
   def has_waagent?
     if File.exist?("/usr/sbin/waagent") || Dir.exist?('C:\WindowsAzure')
-      Ohai::Log.debug("Plugin Azure: Found waagent used by MS Azure.")
+      Ohai::Log.debug("Plugin Azure: Found waagent used by Azure.")
       true
     end
   end
@@ -50,7 +58,7 @@ Ohai.plugin(:Azure) do
     if File.exist?("/var/lib/dhcp/dhclient.eth0.leases")
       File.open("/var/lib/dhcp/dhclient.eth0.leases").each do |line|
         if line =~ /unknown-245/
-          Ohai::Log.debug("Plugin Azure: Found unknown-245 DHCP option used by MS Azure.")
+          Ohai::Log.debug("Plugin Azure: Found unknown-245 DHCP option used by Azure.")
           has_245 = true
           break
         end
@@ -59,4 +67,56 @@ Ohai.plugin(:Azure) do
     has_245
   end
 
+  # create the basic structure we'll store our data in
+  def initialize_metadata_mash
+    metadata = Mash.new
+    metadata["compute"] = Mash.new
+    metadata["network"] = Mash.new
+    metadata["network"]["interfaces"] = Mash.new
+    %w{public_ipv4 local_ipv4 public_ipv6 local_ipv6}.each do |type|
+      metadata["network"][type] = []
+    end
+    metadata
+  end
+
+  def fetch_ip_data(data, type, field)
+    ips = []
+
+    data[type]["ipAddress"].each do |val|
+      ips << val[field] unless val[field].empty?
+    end
+    ips
+  end
+
+  def parse_metadata
+    return nil unless can_socket_connect?(Ohai::Mixin::AzureMetadata::AZURE_METADATA_ADDR, 80)
+
+    endpoint_data = fetch_metadata
+    return nil if endpoint_data.nil?
+    metadata = initialize_metadata_mash
+
+    # blindly add everything in compute to our data structure
+    endpoint_data["compute"].each do |k, v|
+      metadata["compute"][k] = v
+    end
+
+    # parse out per interface interface IP data
+    endpoint_data["network"]["interface"].each do |int|
+      metadata["network"]["interfaces"][int["macAddress"]] = Mash.new
+      metadata["network"]["interfaces"][int["macAddress"]]["mac"] = int["macAddress"]
+      metadata["network"]["interfaces"][int["macAddress"]]["public_ipv6"] = fetch_ip_data(int, "ipv6", "publicIpAddress")
+      metadata["network"]["interfaces"][int["macAddress"]]["public_ipv4"] = fetch_ip_data(int, "ipv4", "publicIpAddress")
+      metadata["network"]["interfaces"][int["macAddress"]]["local_ipv6"] = fetch_ip_data(int, "ipv6", "privateIpAddress")
+      metadata["network"]["interfaces"][int["macAddress"]]["local_ipv4"] = fetch_ip_data(int, "ipv4", "privateIpAddress")
+    end
+
+    # aggregate the total IP data
+    %w{public_ipv4 local_ipv4 public_ipv6 local_ipv6}.each do |type|
+      metadata["network"]["interfaces"].each_value do |val|
+        metadata["network"][type].concat val[type] unless val[type].empty?
+      end
+    end
+
+    metadata
+  end
 end

data/lib/ohai/plugins/cloud.rb

@@ -265,8 +265,10 @@ Ohai.plugin(:Cloud) do
 
   # Fill cloud hash with azure values
   def get_azure_values
-    @cloud_attr_obj.add_ipv4_addr(azure["public_ip"], :public)
-    @cloud_attr_obj.add_ipv4_addr(azure["private_ip"], :private)
+    azure["metadata"]["network"]["public_ipv4"].each { |ipaddr| @cloud_attr_obj.add_ipv4_addr(ipaddr, :public) }
+    azure["metadata"]["network"]["public_ipv6"].each { |ipaddr| @cloud_attr_obj.add_ipv6_addr(ipaddr, :public) }
+    azure["metadata"]["network"]["local_ipv4"].each { |ipaddr| @cloud_attr_obj.add_ipv4_addr(ipaddr, :private) }
+    azure["metadata"]["network"]["local_ipv6"].each { |ipaddr| @cloud_attr_obj.add_ipv6_addr(ipaddr, :private) }
     @cloud_attr_obj.public_hostname = azure["public_fqdn"]
     @cloud_attr_obj.provider = "azure"
   end

data/lib/ohai/plugins/digital_ocean.rb

@@ -15,10 +15,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require "ohai/mixin/do_metadata"
-require "ohai/mixin/http_helper"
-
 Ohai.plugin(:DigitalOcean) do
+  require "ohai/mixin/do_metadata"
+  require "ohai/mixin/http_helper"
+
   include Ohai::Mixin::DOMetadata
   include Ohai::Mixin::HttpHelper
 

data/lib/ohai/plugins/dragonflybsd/os.rb

@@ -18,9 +18,8 @@
 # limitations under the License.
 #
 
-require "ohai/mixin/os"
-
 Ohai.plugin(:OS) do
+  require "ohai/mixin/os"
   provides "os", "os_version"
 
   collect_data(:dragonflybsd) do

data/lib/ohai/plugins/ec2.rb

@@ -24,21 +24,20 @@
 # 3. DMI data mentions amazon. This catches HVM instances in a VPC
 # 4. Kernel data mentioned Amazon. This catches Windows HVM & paravirt instances
 
-require "ohai/mixin/ec2_metadata"
-require "ohai/mixin/http_helper"
-require "base64"
-
 Ohai.plugin(:EC2) do
+  require "ohai/mixin/ec2_metadata"
+  require "ohai/mixin/http_helper"
+  require "base64"
+
   include Ohai::Mixin::Ec2Metadata
   include Ohai::Mixin::HttpHelper
 
   provides "ec2"
-
   depends "dmi"
-  depends "kernel"
 
   # look for amazon string in dmi bios data
   # this gets us detection of HVM instances that are within a VPC
+  # @return [Boolean] do we have Amazon DMI data?
   def has_ec2_dmi?
     # detect a version of '4.2.amazon'
     if get_attribute(:dmi, :bios, :all_records, 0, :Version) =~ /amazon/
@@ -51,7 +50,9 @@ Ohai.plugin(:EC2) do
   end
 
   # looks for a xen UUID that starts with ec2
-  # this gets us detection of Linux HVM and Paravirt hosts
+  # uses the sys tree on Linux and a WMI query on windows
+  # this gets us detection of HVM and Paravirt hosts
+  # @return [Boolean] do we have a Xen UUID or not?
   def has_ec2_xen_uuid?
     if ::File.exist?("/sys/hypervisor/uuid")
       if ::File.read("/sys/hypervisor/uuid") =~ /^ec2/
@@ -63,24 +64,31 @@ Ohai.plugin(:EC2) do
     false
   end
 
-  # looks for the Amazon.com Organization in Windows Kernel data
-  # this gets us detection of Windows systems
-  def has_amazon_org?
-    # detect an Organization of 'Amazon.com'
-    if get_attribute(:kernel, :os_info, :organization) =~ /Amazon/
-      Ohai::Log.debug("Plugin EC2: has_amazon_org? == true")
-      true
+  # looks at the identifying number WMI value to see if it starts with ec2.
+  # this is actually the same value we're looking at in has_ec2_xen_uuid? on
+  # linux hosts
+  # @return [Boolean] do we have a Xen Identifying Number or not?
+  def has_ec2_identifying_number?
+    if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+    #  require "wmi-lite/wmi"
+      wmi = WmiLite::Wmi.new
+      if wmi.first_of("Win32_ComputerSystemProduct")["identifyingnumber"] =~ /^ec2/
+        Ohai::Log.debug("Plugin EC2: has_ec2_identifying_number? == true")
+        return true
+      end
     else
-      Ohai::Log.debug("Plugin EC2: has_amazon_org? == false")
+      Ohai::Log.debug("Plugin EC2: has_ec2_identifying_number? == false")
       false
     end
   end
 
+  # a single check that combines all the various detection methods for EC2
+  # @return [Boolean] Does the system appear to be on EC2
   def looks_like_ec2?
     return true if hint?("ec2")
 
     # Even if it looks like EC2 try to connect first
-    if has_ec2_xen_uuid? || has_ec2_dmi? || has_amazon_org?
+    if has_ec2_xen_uuid? || has_ec2_dmi? || has_ec2_identifying_number?
       return true if can_socket_connect?(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80)
     end
   end

data/lib/ohai/plugins/eucalyptus.rb

@@ -17,11 +17,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# eucalyptus metadata service is compatible with the ec2 service calls
-require "ohai/mixin/ec2_metadata"
-require "ohai/mixin/http_helper"
-
 Ohai.plugin(:Eucalyptus) do
+  # eucalyptus metadata service is compatible with the ec2 service calls
+  require "ohai/mixin/ec2_metadata"
+  require "ohai/mixin/http_helper"
+
   include Ohai::Mixin::Ec2Metadata
   include Ohai::Mixin::HttpHelper
 

data/lib/ohai/plugins/freebsd/os.rb

@@ -18,10 +18,9 @@
 # limitations under the License.
 #
 
-require "ohai/mixin/os"
-
 Ohai.plugin(:OS) do
   provides "os", "os_version"
+  require "ohai/mixin/os"
 
   collect_data(:freebsd) do
     os collect_os

data/lib/ohai/plugins/gce.rb

@@ -14,10 +14,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require "ohai/mixin/gce_metadata"
-require "ohai/mixin/http_helper"
-
 Ohai.plugin(:GCE) do
+  require "ohai/mixin/gce_metadata"
+  require "ohai/mixin/http_helper"
+
   include Ohai::Mixin::GCEMetadata
   include Ohai::Mixin::HttpHelper
 

data/lib/ohai/plugins/hostname.rb

@@ -25,10 +25,10 @@
 # limitations under the License.
 #
 
-require "socket"
-require "ipaddr"
-
 Ohai.plugin(:Hostname) do
+  require "socket"
+  require "ipaddr"
+
   provides "domain", "hostname", "fqdn", "machinename"
 
   # hostname : short hostname

data/lib/ohai/plugins/linux/cpu.rb

@@ -82,8 +82,39 @@ Ohai.plugin(:CPU) do
     end
 
     cpu cpuinfo
+
     cpu[:total] = cpu_number
-    cpu[:real] = real_cpu.keys.length
-    cpu[:cores] = real_cpu.keys.length * cpu["0"]["cores"].to_i
+
+    # use data we collected unless cpuinfo is lacking core information
+    # which is the case on older linux distros
+    if !real_cpu.empty? && cpu["0"]["cores"]
+      cpu[:real] = real_cpu.keys.length
+      cpu[:cores] = real_cpu.keys.length * cpu["0"]["cores"].to_i
+    else
+      begin
+        Ohai::Log.debug("Plugin CPU: Falling back to aggregate data from lscpu as real cpu & core data is missing in /proc/cpuinfo")
+        so = shell_out("lscpu")
+        if so.exitstatus == 0
+          lscpu_data = Mash.new
+          so.stdout.each_line do |line|
+            case line
+            when /^Thread\(s\) per core:\s(.+)/ # http://rubular.com/r/lOw2pRrw1q
+              lscpu_data[:threads] = $1.to_i
+            when /^Core\(s\) per socket:\s(.+)/ # http://rubular.com/r/lOw2pRrw1q
+              lscpu_data[:cores] = $1.to_i
+            when /^Socket\(s\):\s(.+)/ # http://rubular.com/r/DIzmPtJFvK
+              lscpu_data[:sockets] = $1.to_i
+            end
+          end
+          cpu[:total] = lscpu_data[:sockets] * lscpu_data[:cores] * lscpu_data[:threads]
+          cpu[:real] = lscpu_data[:sockets]
+          cpu[:cores] = lscpu_data[:sockets] * lscpu_data[:cores]
+        else
+          Ohai::Log.debug("Plugin CPU: Error executing lscpu. CPU data may not be available.")
+        end
+      rescue Ohai::Exceptions::Exec # util-linux isn't installed most likely
+        Ohai::Log.debug("Plugin CPU: Error executing lscpu. util-linux may not be installed.")
+      end
+    end
   end
 end

data/lib/ohai/plugins/linux/filesystem.rb

@@ -95,52 +95,60 @@ Ohai.plugin(:Filesystem) do
     fs = Mash.new
 
     # Grab filesystem data from df
-    so = shell_out("df -P")
-    so.stdout.each_line do |line|
-      case line
-      when /^Filesystem\s+1024-blocks/
-        next
-      when /^(.+?)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+\%)\s+(.+)$/
-        key = "#{$1},#{$6}"
-        fs[key] = Mash.new
-        fs[key][:device] = $1
-        fs[key][:kb_size] = $2
-        fs[key][:kb_used] = $3
-        fs[key][:kb_available] = $4
-        fs[key][:percent_used] = $5
-        fs[key][:mount] = $6
+    begin
+      so = shell_out("df -P")
+      so.stdout.each_line do |line|
+        case line
+        when /^Filesystem\s+1024-blocks/
+          next
+        when /^(.+?)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+\%)\s+(.+)$/
+          key = "#{$1},#{$6}"
+          fs[key] = Mash.new
+          fs[key][:device] = $1
+          fs[key][:kb_size] = $2
+          fs[key][:kb_used] = $3
+          fs[key][:kb_available] = $4
+          fs[key][:percent_used] = $5
+          fs[key][:mount] = $6
+        end
       end
-    end
 
-    # Grab filesystem inode data from df
-    so = shell_out("df -iP")
-    so.stdout.each_line do |line|
-      case line
-      when /^Filesystem\s+Inodes/
-        next
-      when /^(.+?)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+\%)\s+(.+)$/
-        key = "#{$1},#{$6}"
-        fs[key] ||= Mash.new
-        fs[key][:device] = $1
-        fs[key][:total_inodes] = $2
-        fs[key][:inodes_used] = $3
-        fs[key][:inodes_available] = $4
-        fs[key][:inodes_percent_used] = $5
-        fs[key][:mount] = $6
+      # Grab filesystem inode data from df
+      so = shell_out("df -iP")
+      so.stdout.each_line do |line|
+        case line
+        when /^Filesystem\s+Inodes/
+          next
+        when /^(.+?)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+\%)\s+(.+)$/
+          key = "#{$1},#{$6}"
+          fs[key] ||= Mash.new
+          fs[key][:device] = $1
+          fs[key][:total_inodes] = $2
+          fs[key][:inodes_used] = $3
+          fs[key][:inodes_available] = $4
+          fs[key][:inodes_percent_used] = $5
+          fs[key][:mount] = $6
+        end
       end
+    rescue Ohai::Exceptions::Exec
+      Ohai::Log.warn("Plugin Filesystem: df binary is not available. Some data will not be available.")
     end
 
     # Grab mount information from /bin/mount
-    so = shell_out("mount")
-    so.stdout.each_line do |line|
-      if line =~ /^(.+?) on (.+?) type (.+?) \((.+?)\)$/
-        key = "#{$1},#{$2}"
-        fs[key] = Mash.new unless fs.has_key?(key)
-        fs[key][:device] = $1
-        fs[key][:mount] = $2
-        fs[key][:fs_type] = $3
-        fs[key][:mount_options] = $4.split(",")
+    begin
+      so = shell_out("mount")
+      so.stdout.each_line do |line|
+        if line =~ /^(.+?) on (.+?) type (.+?) \((.+?)\)$/
+          key = "#{$1},#{$2}"
+          fs[key] = Mash.new unless fs.has_key?(key)
+          fs[key][:device] = $1
+          fs[key][:mount] = $2
+          fs[key][:fs_type] = $3
+          fs[key][:mount_options] = $4.split(",")
+        end
       end
+    rescue Ohai::Exceptions::Exec
+      Ohai::Log.warn("Plugin Filesystem: mount binary is not available. Some data will not be available.")
     end
 
     # We used to try to decide if we wanted to run lsblk or blkid