ohai 8.26.1 → 13.0.0

data/lib/ohai/plugins/gce.rb

@@ -15,9 +15,11 @@
 # limitations under the License.
 
 require "ohai/mixin/gce_metadata"
+require "ohai/mixin/http_helper"
 
 Ohai.plugin(:GCE) do
   include Ohai::Mixin::GCEMetadata
+  include Ohai::Mixin::HttpHelper
 
   provides "gce"
 
@@ -27,7 +29,7 @@ Ohai.plugin(:GCE) do
   # true:: If gce metadata server found
   # false:: Otherwise
   def has_gce_metadata?
-    can_metadata_connect?(Ohai::Mixin::GCEMetadata::GCE_METADATA_ADDR, 80)
+    can_socket_connect?(Ohai::Mixin::GCEMetadata::GCE_METADATA_ADDR, 80)
   end
 
   # Identifies gce

data/lib/ohai/plugins/hostname.rb

@@ -76,24 +76,9 @@ Ohai.plugin(:Hostname) do
     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(:hpux, :default) do
     machinename from_cmd("hostname")
-    fqdn sigar_is_available? ? get_fqdn_from_sigar : resolve_fqdn
+    fqdn resolve_fqdn
     collect_hostname
     collect_domain
   end

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

@@ -1,6 +1,8 @@
 #
-# Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright (c) 2008-2016 Chef Software, Inc.
+# Author:: Phil Dibowitz <phil@ipom.com>
+# Author:: Adam Jacob <adam@chef.io>
+# Copyright:: Copyright (c) 2008-2017 Chef Software, Inc.
+# Copyright:: Copyright (c) 2015 Facebook, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,124 +20,160 @@
 
 Ohai.plugin(:Filesystem) do
   provides "filesystem"
+  provides "filesystem2"
 
-  def get_blk_cmd(attr, have_lsblk)
-    if have_lsblk
-      attr = "FSTYPE" if attr == "TYPE"
-      "lsblk -P -n -o NAME,#{attr}"
-    else
-      "blkid -s #{attr}"
+  def find_device(name)
+    %w{/dev /dev/mapper}.each do |dir|
+      path = File.join(dir, name)
+      return path if File.exist?(path)
     end
+    name
   end
 
-  def get_blk_regex(attr, have_lsblk)
+  def parse_line(line, have_lsblk)
     if have_lsblk
-      attr = "FSTYPE" if attr == "TYPE"
-      /^NAME="(\S+).*?" #{attr}="(\S+)"/
+      regex = /NAME="(\S+).*?" UUID="(\S*)" LABEL="(\S*)" FSTYPE="(\S*)"/
+      if line =~ regex
+        dev = $1
+        dev = find_device(dev) unless dev.start_with?("/")
+        uuid = $2
+        label = $3
+        fs_type = $4
+        return { :dev => dev, :uuid => uuid, :label => label, :fs_type => fs_type }
+      end
     else
-      /^(\S+): #{attr}="(\S+)"/
+      bits = line.split
+      dev = bits.shift.split(":")[0]
+      f = { :dev => dev }
+      bits.each do |keyval|
+        if keyval =~ /(\S+)="(\S+)"/
+          key = $1.downcase.to_sym
+          key = :fs_type if key == :type
+          f[key] = $2
+        end
+      end
+      return f
     end
+    return nil
   end
 
-  def find_device(name)
-    %w{/dev /dev/mapper}.each do |dir|
-      path = File.join(dir, name)
-      return path if File.exist?(path)
+  def generate_device_view(fs)
+    view = {}
+    fs.each_value do |entry|
+      view[entry[:device]] = Mash.new unless view[entry[:device]]
+      entry.each do |key, val|
+        next if %w{device mount}.include?(key)
+        view[entry[:device]][key] = val
+      end
+      view[entry[:device]][:mounts] ||= []
+      if entry[:mount]
+        view[entry[:device]][:mounts] << entry[:mount]
+      end
     end
-    name
+    view
+  end
+
+  def generate_mountpoint_view(fs)
+    view = {}
+    fs.each_value do |entry|
+      next unless entry[:mount]
+      view[entry[:mount]] = Mash.new unless view[entry[:mount]]
+      entry.each do |key, val|
+        next if %w{mount device}.include?(key)
+        view[entry[:mount]][key] = val
+      end
+      view[entry[:mount]][:devices] ||= []
+      if entry[:device]
+        view[entry[:mount]][:devices] << entry[:device]
+      end
+    end
+    view
   end
 
   collect_data(:linux) do
     fs = Mash.new
-    have_lsblk = File.executable?("/bin/lsblk")
 
     # Grab filesystem data from df
     so = shell_out("df -P")
-    so.stdout.lines do |line|
+    so.stdout.each_line do |line|
       case line
       when /^Filesystem\s+1024-blocks/
         next
       when /^(.+?)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+\%)\s+(.+)$/
-        filesystem = $1
-        fs[filesystem] = Mash.new
-        fs[filesystem][:kb_size] = $2
-        fs[filesystem][:kb_used] = $3
-        fs[filesystem][:kb_available] = $4
-        fs[filesystem][:percent_used] = $5
-        fs[filesystem][:mount] = $6
+        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
 
     # Grab filesystem inode data from df
     so = shell_out("df -iP")
-    so.stdout.lines do |line|
+    so.stdout.each_line do |line|
       case line
       when /^Filesystem\s+Inodes/
         next
       when /^(.+?)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+\%)\s+(.+)$/
-        filesystem = $1
-        fs[filesystem] ||= Mash.new
-        fs[filesystem][:total_inodes] = $2
-        fs[filesystem][:inodes_used] = $3
-        fs[filesystem][:inodes_available] = $4
-        fs[filesystem][:inodes_percent_used] = $5
-        fs[filesystem][:mount] = $6
+        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
 
     # Grab mount information from /bin/mount
     so = shell_out("mount")
-    so.stdout.lines do |line|
+    so.stdout.each_line do |line|
       if line =~ /^(.+?) on (.+?) type (.+?) \((.+?)\)$/
-        filesystem = $1
-        fs[filesystem] = Mash.new unless fs.has_key?(filesystem)
-        fs[filesystem][:mount] = $2
-        fs[filesystem][:fs_type] = $3
-        fs[filesystem][:mount_options] = $4.split(",")
+        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
 
     have_lsblk = File.exist?("/bin/lsblk")
+    if have_lsblk
+      cmd = "lsblk -n -P -o NAME,UUID,LABEL,FSTYPE"
+    else
+      # CentOS5 and other platforms don't have lsblk
+      cmd = "blkid"
+    end
 
-    # Gather more filesystem types via libuuid, even devices that's aren't mounted
-    cmd = get_blk_cmd("TYPE", have_lsblk)
-    regex = get_blk_regex("TYPE", have_lsblk)
     so = shell_out(cmd)
-    so.stdout.lines do |line|
-      if line =~ regex
-        filesystem = $1
-        type = $2
-        filesystem = find_device(filesystem) unless filesystem.start_with?("/")
-        fs[filesystem] = Mash.new unless fs.has_key?(filesystem)
-        fs[filesystem][:fs_type] = type
+    so.stdout.each_line do |line|
+      parsed = parse_line(line, have_lsblk)
+      next if parsed.nil?
+      # lsblk lists each device once, so we need to update all entries
+      # in the hash that are related to this device
+      keys_to_update = []
+      fs.each_key do |key|
+        keys_to_update << key if key.start_with?("#{parsed[:dev]},")
       end
-    end
 
-    # Gather device UUIDs via libuuid
-    cmd = get_blk_cmd("UUID", have_lsblk)
-    regex = get_blk_regex("UUID", have_lsblk)
-    so = shell_out(cmd)
-    so.stdout.lines do |line|
-      if line =~ regex
-        filesystem = $1
-        uuid = $2
-        filesystem = find_device(filesystem) unless filesystem.start_with?("/")
-        fs[filesystem] = Mash.new unless fs.has_key?(filesystem)
-        fs[filesystem][:uuid] = uuid
+      if keys_to_update.empty?
+        key = "#{parsed[:dev]},"
+        fs[key] = Mash.new
+        fs[key][:device] = parsed[:dev]
+        keys_to_update << key
       end
-    end
 
-    # Gather device labels via libuuid
-    cmd = get_blk_cmd("LABEL", have_lsblk)
-    regex = get_blk_regex("LABEL", have_lsblk)
-    so = shell_out(cmd)
-    so.stdout.lines do |line|
-      if line =~ regex
-        filesystem = $1
-        label = $2
-        filesystem = find_device(filesystem) unless filesystem.start_with?("/")
-        fs[filesystem] = Mash.new unless fs.has_key?(filesystem)
-        fs[filesystem][:label] = label
+      keys_to_update.each do |key|
+        [:fs_type, :uuid, :label].each do |subkey|
+          if parsed[subkey] && !parsed[subkey].empty?
+            fs[key][subkey] = parsed[subkey]
+          end
+        end
       end
     end
 
@@ -160,17 +198,28 @@ Ohai.plugin(:Filesystem) do
       f.close
       mounts.each_line do |line|
         if line =~ /^(\S+) (\S+) (\S+) (\S+) \S+ \S+$/
-          filesystem = $1
-          next if fs.has_key?(filesystem)
-          fs[filesystem] = Mash.new
-          fs[filesystem][:mount] = $2
-          fs[filesystem][:fs_type] = $3
-          fs[filesystem][:mount_options] = $4.split(",")
+          key = "#{$1},#{$2}"
+          next if fs.has_key?(key)
+          fs[key] = Mash.new
+          fs[key][:device] = $1
+          fs[key][:mount] = $2
+          fs[key][:fs_type] = $3
+          fs[key][:mount_options] = $4.split(",")
         end
       end
     end
 
+    by_pair = fs
+    by_device = generate_device_view(fs)
+    by_mountpoint = generate_mountpoint_view(fs)
+
+    fs_data = Mash.new
+    fs_data["by_device"] = by_device
+    fs_data["by_mountpoint"] = by_mountpoint
+    fs_data["by_pair"] = by_pair
+
     # Set the filesystem data
-    filesystem fs
+    filesystem fs_data
+    filesystem2 fs_data
   end
 end

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

@@ -1,8 +1,6 @@
 #
 # Author:: Tim Smith <tsmith@limelight.com>
-# Author:: Phil Dibowitz <phild@ipomc.com>
 # Copyright:: Copyright (c) 2013-2014, Limelight Networks, Inc.
-# Copyright:: Copyright (c) 2017 Facebook, Inc.
 # Plugin:: mdadm
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -54,52 +52,15 @@ Ohai.plugin(:Mdadm) do
   collect_data(:linux) do
     # gather a list of all raid arrays
     if File.exist?("/proc/mdstat")
-      devices = {}
+      devices = []
       File.open("/proc/mdstat").each do |line|
-        if line =~ /(md[0-9]+)/
-          device = Regexp.last_match[1]
-          pieces = line.split(/\s+/)
-          # there are variable numbers of fields until you hit the raid level
-          # everything after that is members...
-          # unless the array is inactive, in which case you don't get a raid
-          # level.
-          members = pieces.drop_while { |x| !x.start_with?("raid", "inactive") }
-          # and drop that too
-          members.shift unless members.empty?
-          devices[device] = {
-            "active" => [],
-            "spare" => [],
-            "journal" => nil,
-          }
-          members.each do |member|
-            # We want to match the device, and optionally the type
-            # most entries will look like:
-            #   sdc1[5]
-            # but some will look like:
-            #   sdc1[5](J)
-            # where the format is:
-            #   <device>[<number in array>](<type>)
-            # Type can be things like "J" for a journal device, or "S" for
-            # a spare device.
-            m = member.match(/(.+)\[\d+\](?:\((\w)\))?/)
-            member_device = m[1]
-            member_type = m[2]
-            case member_type
-            when "J"
-              devices[device]["journal"] = member_device
-            when "S"
-              devices[device]["spare"] << member_device
-            else
-              devices[device]["active"] << member_device
-            end
-          end
-        end
+        devices << Regexp.last_match[1] if line =~ /(md[0-9]+)/
       end
 
       # create the mdadm mash and gather individual information if devices are present
       unless devices.empty?
         mdadm Mash.new
-        devices.keys.sort.each do |device|
+        devices.sort.each do |device|
           mdadm[device] = Mash.new
 
           # gather detailed information on the array
@@ -107,9 +68,6 @@ Ohai.plugin(:Mdadm) do
 
           # if the mdadm command was sucessful pass so.stdout to create_raid_device_mash to grab the tidbits we want
           mdadm[device] = create_raid_device_mash(so.stdout) if so.stdout
-          mdadm[device]["members"] = devices[device]["active"]
-          mdadm[device]["spares"] = devices[device]["spare"]
-          mdadm[device]["journal"] = devices[device]["journal"]
         end
       end
     end

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

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Chris Read <chris.read@gmail.com>
-# Copyright:: Copyright (c) 2008-2016 Chef Software, Inc.
+# Copyright:: Copyright (c) 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -215,31 +215,6 @@ Ohai.plugin(:Network) do
         net_counters[tmp_int] = Mash.new unless net_counters[tmp_int]
       end
 
-      if line =~ /^\s+(ip6tnl|ipip)/
-        iface[tmp_int][:tunnel_info] = {}
-        words = line.split
-        words.each_with_index do |word, index|
-          case word
-          when "external"
-            iface[tmp_int][:tunnel_info][word] = true
-          when "any", "ipip6", "ip6ip6"
-            iface[tmp_int][:tunnel_info][:proto] = word
-          when "remote",
-               "local",
-               "encaplimit",
-               "hoplimit",
-               "tclass",
-               "flowlabel",
-               "addrgenmode",
-               "numtxqueues",
-               "numrxqueues",
-               "gso_max_size",
-               "gso_max_segs"
-            iface[tmp_int][:tunnel_info][word] = words[index + 1]
-          end
-        end
-      end
-
       if line =~ /(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/
         int = on_rx ? :rx : :tx
         net_counters[tmp_int][int] = Mash.new unless net_counters[tmp_int][int]

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

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright (c) 2015-2016 Chef Software, Inc.
+# Copyright:: Copyright (c) 2015-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -107,8 +107,10 @@ Ohai.plugin(:Platform) do
     case platform
     when /debian/, /ubuntu/, /linuxmint/, /raspbian/, /cumulus/
       "debian"
-    when /oracle/, /centos/, /redhat/, /scientific/, /enterpriseenterprise/, /amazon/, /xenserver/, /cloudlinux/, /ibm_powerkvm/, /parallels/, /nexus_centos/ # Note that 'enterpriseenterprise' is oracle's LSB "distributor ID"
+    when /oracle/, /centos/, /redhat/, /scientific/, /enterpriseenterprise/, /xenserver/, /cloudlinux/, /ibm_powerkvm/, /parallels/, /nexus_centos/ # Note that 'enterpriseenterprise' is oracle's LSB "distributor ID"
       "rhel"
+    when /amazon/
+      "amazon"
     when /suse/
       "suse"
     when /fedora/, /pidora/, /arista_eos/