ohai 16.10.6 → 17.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 586f4b057af4307f5fb1abd420939bdb2320dade9b63723fbbcc58135a645a9b
-  data.tar.gz: b2c45c824a6ef7d69702f365f3e4d24bafe53b03afbfe0911e4bca8484556ad4
+  metadata.gz: 3e30d1da39ec42887fd2cb097f22f5cfeb0662275c11abe0a5b647f317f9a44b
+  data.tar.gz: 92330832131633f2c132857481898d6e3a0f3f966bfc122d91f33b416e400c1f
 SHA512:
-  metadata.gz: 1e9e3ef34974d09ee07eb5c492a9e80028ea8d80c6afa38e86921de16f6a1f85884bb032129fe8322b0bb1942d9447012f3f89f7d027591feecd82a8211a389a
-  data.tar.gz: 01fa6b22eee2fdfbead5f062efb6d346fc508b5b375edcddba0d56ed41c107b6a168e7532c573195b39f3a9b1ccdb24a67a3f914c056d2bedf88f1ac3e8aabe4
+  metadata.gz: 5ac054f71a2c0fae3566af336a08de3b5277c3bf7fc2e7c7fee076eb949018aba6aed602b28deffd9d97c6a543cb2cafefc42af0d820f6eaaa688e38867842d6
+  data.tar.gz: 0b63b2a16cb614b7c33e90decce218654e1d92ce6a394a041dd8a906ce18ac65fda3028fdfd1523dc145d4ab7f3af8d868f3950384e2cc36d186c57d25478af4

data/Gemfile

@@ -4,19 +4,19 @@ source "https://rubygems.org"
 gemspec
 
 # pull these gems from master of chef/chef so that we're testing against what we will release
-gem "chef-config", git: "https://github.com/chef/chef", branch: "chef-16", glob: "chef-config/chef-config.gemspec"
-gem "chef-utils", git: "https://github.com/chef/chef", branch: "chef-16", glob: "chef-utils/chef-utils.gemspec"
+gem "chef-config", git: "https://github.com/chef/chef", branch: "master", glob: "chef-config/chef-config.gemspec"
+gem "chef-utils", git: "https://github.com/chef/chef", branch: "master", glob: "chef-utils/chef-utils.gemspec"
 
 # NOTE: do not submit PRs to add pry as a dep, add to your Gemfile.local
 group :development do
-  gem "chefstyle", "1.6.2"
+  gem "chefstyle", git: "https://github.com/chef/chefstyle.git", branch: "master"
   gem "ipaddr_extensions"
   gem "rake", ">= 10.1.0"
   gem "rspec-collection_matchers", "~> 1.0"
   gem "rspec-core", "~> 3.0"
   gem "rspec-expectations", "~> 3.0"
   gem "rspec-mocks", "~> 3.0"
-  gem "rubocop-performance", "1.9.2"
+  gem "rubocop-performance", "1.10.2"
   gem "rubocop-rspec"
 end
 

data/lib/ohai/mixin/alibaba_metadata.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+#
+# Author:: Tim Smith (<tsmith@chef.io>)
+# Copyright:: Copyright (c) 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" unless defined?(Net::HTTP)
+
+module Ohai
+  module Mixin
+    #
+    # This code parses the Alibaba Instance Metadata API to provide details
+    # of the running instance.
+    #
+    # Note: As of 2021-02-07 there is only one API release so we're not implementing
+    # logic like the ec2 or azure mixins where we have to find the latest supported
+    # release
+    module AlibabaMetadata
+
+      ALI_METADATA_ADDR ||= "100.100.100.200"
+
+      def http_get(uri)
+        conn = Net::HTTP.start(ALI_METADATA_ADDR)
+        conn.read_timeout = 6
+        conn.keep_alive_timeout = 6
+        conn.get("/2016-01-01/#{uri}", { "User-Agent" => "chef-ohai/#{Ohai::VERSION}" })
+      end
+
+      def fetch_metadata(id = "")
+        response = http_get(id)
+        return nil unless response.code == "200"
+
+        if json?(response.body)
+          data = String(response.body)
+          parser = FFI_Yajl::Parser.new
+          parser.parse(data)
+        elsif response.body.include?("\n")
+          temp = {}
+          response.body.split("\n").each do |sub_attr|
+            temp[sanitize_key(sub_attr)] = fetch_metadata("#{id}/#{sub_attr}")
+          end
+          temp
+        else
+          response.body
+        end
+      end
+
+      # @param [String] data that might be JSON
+      #
+      # @return [Boolean] is the data JSON or not?
+      def json?(data)
+        data = String(data)
+        parser = FFI_Yajl::Parser.new
+        begin
+          parser.parse(data)
+          true
+        rescue FFI_Yajl::ParseError
+          false
+        end
+      end
+
+      # @param data [String]
+      #
+      # @return [Boolean] is there a trailing /?
+      def has_trailing_slash?(data)
+        !!( data =~ %r{/$} )
+      end
+
+      def sanitize_key(key)
+        key.gsub(%r{\-|/}, "_")
+      end
+    end
+  end
+end

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

@@ -24,14 +24,15 @@ Ohai.plugin(:Virtualization) do
     virtualization Mash.new
 
     lpar_no, lpar_name = shell_out("uname -L").stdout.split(nil, 2)
+    lpar_no = lpar_no.to_i
 
-    unless lpar_no.to_i == -1 || (lpar_no.to_i == 1 && lpar_name == "NULL")
+    unless lpar_no == -1 || (lpar_no == 1 && lpar_name == "NULL")
       virtualization[:lpar_no] = lpar_no
       virtualization[:lpar_name] = lpar_name
     end
 
-    wpar_no = shell_out("uname -W").stdout.strip
-    if wpar_no.to_i > 0
+    wpar_no = shell_out("uname -W").stdout.strip.to_i
+    if wpar_no > 0
       virtualization[:wpar_no] = wpar_no
     else
       # the below parses the output of lswpar in the long format

data/lib/ohai/plugins/alibaba.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+#
+# Author:: Tim Smith (<tsmith@chef.io>)
+# Copyright:: Copyright (c) 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.
+
+# How we detect Alibaba from easiest to hardest & least reliable
+# 1. Ohai alibaba hint exists. This always works
+# 2. DMI sys_vendor data mentions alibaba.
+
+Ohai.plugin(:Alibaba) do
+  require_relative "../mixin/alibaba_metadata"
+  require_relative "../mixin/http_helper"
+
+  include Ohai::Mixin::AlibabaMetadata
+  include Ohai::Mixin::HttpHelper
+
+  provides "alibaba"
+
+  # look for alibaba string in dmi sys_vendor data within the sys tree.
+  # this works even if the system lacks dmidecode use by the Dmi plugin
+  # @return [Boolean] do we have Alibaba DMI data?
+  def has_ali_dmi?
+    if /Alibaba/.match?(file_val_if_exists("/sys/class/dmi/id/sys_vendor"))
+      logger.trace("Plugin Alibaba: has_ali_dmi? == true")
+      true
+    else
+      logger.trace("Plugin Alibaba: has_ali_dmi? == false")
+      false
+    end
+  end
+
+  # return the contents of a file if the file exists
+  # @param path[String] abs path to the file
+  # @return [String] contents of the file if it exists
+  def file_val_if_exists(path)
+    if file_exist?(path)
+      file_read(path)
+    end
+  end
+
+  # a single check that combines all the various detection methods for Alibaba
+  # @return [Boolean] Does the system appear to be on Alibaba
+  def looks_like_alibaba?
+    return true if hint?("alibaba") || has_ali_dmi?
+  end
+
+  collect_data do
+    if looks_like_alibaba?
+      logger.trace("Plugin Alibaba: looks_like_alibaba? == true")
+      alibaba Mash.new
+      fetch_metadata.each do |k, v|
+        alibaba[k] = v
+      end
+    else
+      logger.trace("Plugin Alibaba: looks_like_alibaba? == false")
+      false
+    end
+  end
+end

data/lib/ohai/plugins/c.rb

@@ -85,14 +85,12 @@ Ohai.plugin(:C) do
 
   def collect_glibc
     # glibc
-    ["/lib/libc.so.6", "/lib64/libc.so.6"].each do |glibc|
-      collect( Ohai.abs_path( glibc )) do |so|
-        description = so.stdout.split($/).first
-        if description =~ /(\d+\.\d+\.?\d*)/
-          @c[:glibc] = Mash.new
-          @c[:glibc][:version] = $1
-          @c[:glibc][:description] = description
-        end
+    collect("ldd --version") do |so|
+      description = so.stdout.split($/).first
+      if description =~ /(\d+\.\d+\.?\d*)/
+        @c[:glibc] = Mash.new
+        @c[:glibc][:version] = $1
+        @c[:glibc][:description] = description
       end
     end
   end

data/lib/ohai/plugins/chef.rb

@@ -20,9 +20,19 @@
 Ohai.plugin(:Chef) do
   provides "chef_packages/chef"
 
+  def chef_effortless?
+    # Determine if client is being run as a Habitat package.
+    if Chef::CHEF_ROOT.include?("hab/pkgs/chef/chef")
+      # Determine if client is running in zero mode which would show it is using the Effortless pattern.
+      # Explicitly set response to true or nil, not false
+      ChefConfig::Config["chef_server_url"].include?("chefzero://")
+    end
+  end
+
   collect_data(:default, :target) do
     begin
       require "chef/version"
+      require "chef-config/config" unless defined?(ChefConfig::Config)
     rescue Gem::LoadError
       logger.trace("Plugin Chef: Unable to load the chef gem to determine the version")
       # this catches when you've done a major version bump of ohai, but
@@ -35,5 +45,6 @@ Ohai.plugin(:Chef) do
     chef_packages[:chef] = Mash.new
     chef_packages[:chef][:version] = Chef::VERSION
     chef_packages[:chef][:chef_root] = Chef::CHEF_ROOT
+    chef_packages[:chef][:chef_effortless] = chef_effortless?
   end
 end

data/lib/ohai/plugins/cloud.rb

@@ -18,6 +18,7 @@
 Ohai.plugin(:Cloud) do
   provides "cloud"
 
+  depends "alibaba"
   depends "ec2"
   depends "gce"
   depends "rackspace"
@@ -118,7 +119,22 @@ Ohai.plugin(:Cloud) do
     end
   end
 
-  #---------------------------------------
+  #--------------------------------------
+  # Alibaba Cloud
+  #--------------------------------------
+
+  def on_alibaba?
+    alibaba != nil
+  end
+
+  def get_alibaba_values
+    @cloud_attr_obj.add_ipv4_addr(alibaba["meta_data"]["eipv4"], :public)
+    @cloud_attr_obj.add_ipv4_addr(alibaba["meta_data"]["private_ipv4"], :private)
+    @cloud_attr_obj.local_hostname = alibaba["meta_data"]["hostname"]
+    @cloud_attr_obj.provider = "alibaba"
+  end
+
+  #--------------------------------------
   # Google Compute Engine (gce)
   #--------------------------------------
 
@@ -133,9 +149,9 @@ Ohai.plugin(:Cloud) do
       end
     end.flatten.compact
 
-    private_ips = gce["instance"]["networkInterfaces"].collect do |interface|
+    private_ips = gce["instance"]["networkInterfaces"].filter_map do |interface|
       interface["ip"]
-    end.compact
+    end
 
     public_ips.each { |ipaddr| @cloud_attr_obj.add_ipv4_addr(ipaddr, :public) }
     private_ips.each { |ipaddr| @cloud_attr_obj.add_ipv4_addr(ipaddr, :private) }
@@ -334,6 +350,7 @@ Ohai.plugin(:Cloud) do
     get_azure_values if on_azure?
     get_digital_ocean_values if on_digital_ocean?
     get_softlayer_values if on_softlayer?
+    get_alibaba_values if on_alibaba?
 
     cloud @cloud_attr_obj.cloud_mash
   end

data/lib/ohai/plugins/cpu.rb

@@ -9,6 +9,7 @@
 # Author:: Prabhu Das (<prabhu.das@clogeny.com>)
 # Author:: Isa Farnik (<isa@chef.io>)
 # Author:: Doug MacEachern <dougm@vmware.com>
+# Author:: Lance Albertson <lance@osuosl.org>
 # Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
@@ -46,13 +47,213 @@ Ohai.plugin(:CPU) do
     cpuinfo
   end
 
-  collect_data(:linux) do
+  # Convert a string that looks like range of CPUs to an array
+  # Given the following range: 1-7
+  # Convert it into an array: [1, 2, 3, 4, 5, 6, 7]
+  def range_str_to_a(range)
+    range.split(",").each_with_object([]) do |cpu, arr|
+      if /\d+-\d+/.match?(cpu.to_s)
+        arr << Range.new(*cpu.split("-").map(&:to_i)).to_a
+      else
+        arr << cpu.to_i
+      end
+    end.flatten
+  end
+
+  def parse_lscpu(cpu_info)
+    lscpu_info = Mash.new
+    begin
+      so = shell_out("lscpu")
+      cpu_cores = shell_out("lscpu -p=CPU,CORE,SOCKET")
+      if so.exitstatus == 0 && cpu_cores.exitstatus == 0
+        lscpu_info[:numa_node_cpus] = Mash.new
+        lscpu_info[:vulnerability] = Mash.new
+        so.stdout.each_line do |line|
+          case line
+          when /^Architecture:\s+(.+)/
+            lscpu_info[:architecture] = $1.to_s
+          when /^CPU op-mode\(s\):\s+(.+)/
+            lscpu_info[:cpu_opmodes] = $1.split(", ")
+          when /^Byte Order:\s+(.+)/
+            lscpu_info[:byte_order] = $1.downcase
+          when /^Address sizes:\s+(.+)/
+            lscpu_info[:address_sizes] = $1.split(", ")
+          when /^CPU\(s\):\s+(.+)/
+            lscpu_info[:cpus] = $1.to_i
+          when /^On-line CPU\(s\) list:\s+(.+)/
+            cpu_range = range_str_to_a($1)
+            if cpu_range == [0]
+              lscpu_info[:cpus_online] = 0
+            else
+              lscpu_info[:cpus_online] = cpu_range.length
+            end
+          when /^Off-line CPU\(s\) list:\s+(.+)/
+            cpu_range = range_str_to_a($1)
+            if cpu_range == [0]
+              lscpu_info[:cpus_offline] = 0
+            else
+              lscpu_info[:cpus_offline] = cpu_range.length
+            end
+          when /^Thread\(s\) per core:\s+(.+)/ # http://rubular.com/r/lOw2pRrw1q
+            lscpu_info[:threads_per_core] = $1.to_i
+          when /^Core\(s\) per socket:\s+(.+)/ # http://rubular.com/r/lOw2pRrw1q
+            lscpu_info[:cores_per_socket] = $1.to_i
+          when /^Socket\(s\):\s+(.+)/ # http://rubular.com/r/DIzmPtJFvK
+            lscpu_info[:sockets] = $1.to_i
+          when /^Socket\(s\) per book:\s+(.+)/
+            lscpu_info[:sockets_per_book] = $1.to_i
+          when /^Book\(s\) per drawer:\s+(.+)/
+            lscpu_info[:books_per_drawer] = $1.to_i
+          when /^Drawer\(s\):\s+(.+)/
+            lscpu_info[:drawers] = $1.to_i
+          when /^NUMA node\(s\):\s+(.+)/
+            lscpu_info[:numa_nodes] = $1.to_i
+          when /^Vendor ID:\s+(.+)/
+            lscpu_info[:vendor_id] = $1
+          when /^Machine type:\s+(.+)/
+            lscpu_info[:machine_type] = $1
+          when /^CPU family:\s+(.+)/
+            lscpu_info[:family] = $1
+          when /^Model:\s+(.+)/
+            lscpu_info[:model] = $1
+          when /^Model name:\s+(.+)/
+            lscpu_info[:model_name] = $1
+          when /^Stepping:\s+(.+)/
+            lscpu_info[:stepping] = $1
+          when /^CPU MHz:\s+(.+)/
+            lscpu_info[:mhz] = $1
+          when /^CPU static MHz:\s+(.+)/
+            lscpu_info[:mhz] = $1
+          when /^CPU max MHz:\s+(.+)/
+            lscpu_info[:mhz_max] = $1
+          when /^CPU min MHz:\s+(.+)/
+            lscpu_info[:mhz_min] = $1
+          when /^CPU dynamic MHz:\s+(.+)/
+            lscpu_info[:mhz_dynamic] = $1
+          when /^BogoMIPS:\s+(.+)/
+            lscpu_info[:bogomips] = $1
+          when /^Virtualization:\s+(.+)/
+            lscpu_info[:virtualization] = $1
+          when /^Virtualization type:\s+(.+)/
+            lscpu_info[:virtualization_type] = $1
+          when /^Hypervisor vendor:\s+(.+)/
+            lscpu_info[:hypervisor_vendor] = $1
+          when /^Dispatching mode:\s+(.+)/
+            lscpu_info[:dispatching_mode] = $1
+          when /^L1d cache:\s+(.+)/
+            lscpu_info[:l1d_cache] = $1
+          when /^L1i cache:\s+(.+)/
+            lscpu_info[:l1i_cache] = $1
+          when /^L2 cache:\s+(.+)/
+            lscpu_info[:l2_cache] = $1
+          when /^L2d cache:\s+(.+)/
+            lscpu_info[:l2d_cache] = $1
+          when /^L2i cache:\s+(.+)/
+            lscpu_info[:l2i_cache] = $1
+          when /^L3 cache:\s+(.+)/
+            lscpu_info[:l3_cache] = $1
+          when /^L4 cache:\s+(.+)/
+            lscpu_info[:l4_cache] = $1
+          when /^NUMA node(\d+) CPU\(s\):\s+(.+)/
+            numa_node = $1
+            cpus = $2
+            lscpu_info[:numa_node_cpus][numa_node] = range_str_to_a(cpus)
+          when /^Vulnerability (.+?):\s+(.+)/ # https://rubular.com/r/aKtSD1ypUlKbGm
+            name = $1.strip.downcase.tr(" ", "_")
+            description = $2.strip
+            lscpu_info[:vulnerability][name] = Mash.new
+            lscpu_info[:vulnerability][name] = description
+          when /^Flags:\s+(.+)/
+            lscpu_info[:flags] = $1.split(" ").sort
+            # flags are "features" on aarch64 and s390x so add it for backwards computability
+            lscpu_info[:features] = lscpu_info[:flags] if lscpu_info[:architecture].match?(/aarch64|s390x/)
+          end
+        end
+
+        case lscpu_info[:architecture]
+        when "s390x"
+          # Add data from /proc/cpuinfo that isn't available from lscpu
+          lscpu_info[:bogomips_per_cpu] = cpu_info[:bogomips_per_cpu]
+          lscpu_info[:version] = cpu_info["0"][:version]
+          lscpu_info[:identification] = cpu_info["0"][:identification]
+          lscpu_info[:machine] = cpu_info["0"][:machine]
+          lscpu_total = lscpu_info[:sockets_per_book] * lscpu_info[:cores_per_socket] * lscpu_info[:threads_per_core] * lscpu_info[:books_per_drawer] * lscpu_info[:drawers]
+          lscpu_real = lscpu_info[:sockets_per_book]
+          lscpu_cores = lscpu_info[:sockets_per_book] * lscpu_info[:cores_per_socket] * lscpu_info[:books_per_drawer] * lscpu_info[:drawers]
+        when "ppc64le"
+          # Add data from /proc/cpuinfo that isn't available from lscpu
+          lscpu_info[:timebase] = cpu_info[:timebase]
+          lscpu_info[:platform] = cpu_info[:platform]
+          lscpu_info[:machine_model] = cpu_info[:machine_model]
+          lscpu_info[:machine] = cpu_info[:machine]
+          lscpu_info[:firmware] = cpu_info[:firmware] if cpu_info[:firmware]
+          lscpu_info[:mmu] = cpu_info[:mmu] if cpu_info[:mmu]
+          lscpu_info[:mhz] = cpu_info["0"][:mhz]
+          lscpu_total = lscpu_info[:sockets] * lscpu_info[:cores_per_socket] * lscpu_info[:threads_per_core]
+          lscpu_real = lscpu_info[:sockets]
+          lscpu_cores = lscpu_info[:sockets] * lscpu_info[:cores_per_socket]
+        else
+          lscpu_total = lscpu_info[:sockets] * lscpu_info[:cores_per_socket] * lscpu_info[:threads_per_core]
+          lscpu_real = lscpu_info[:sockets]
+          lscpu_cores = lscpu_info[:sockets] * lscpu_info[:cores_per_socket]
+        end
+
+        # Enumerate cpus and fill out data to provide backwards compatibility data
+        cpu_cores.stdout.each_line do |line|
+          current_cpu = nil
+          current_core = nil
+          current_socket = nil
+
+          case line
+          # skip comments
+          when /^#/
+            next
+          # Parse data from "lscpu -p=CPU,CORE,SOCKET"
+          when /(\d+),(\d+),(\d+)/
+            current_cpu = $1
+            current_core = $2
+            current_socket = $3
+          end
+          lscpu_info[current_cpu] = Mash.new
+          lscpu_info[current_cpu][:vendor_id] = lscpu_info[:vendor_id] if lscpu_info[:vendor_id]
+          lscpu_info[current_cpu][:family] = lscpu_info[:family] if lscpu_info[:family]
+          lscpu_info[current_cpu][:model] = lscpu_info[:model] if lscpu_info[:model]
+          lscpu_info[current_cpu][:model_name] = lscpu_info[:model_name] if lscpu_info[:model_name]
+          lscpu_info[current_cpu][:stepping] = lscpu_info[:stepping] if lscpu_info[:stepping]
+          lscpu_info[current_cpu][:mhz] = lscpu_info[:mhz] if lscpu_info[:mhz]
+          lscpu_info[current_cpu][:bogomips] = lscpu_info[:bogomips] if lscpu_info[:bogomips]
+          # Per cpu cache_size is only really available from /proc/cpuinfo on x86
+          lscpu_info[current_cpu][:cache_size] = cpu_info[current_cpu][:cache_size] if cpu_info[current_cpu] && cpu_info[current_cpu][:cache_size]
+          lscpu_info[current_cpu][:physical_id] = current_socket
+          lscpu_info[current_cpu][:core_id] = current_core
+          lscpu_info[current_cpu][:cores] = lscpu_info[:cores_per_socket].to_s
+          lscpu_info[current_cpu][:flags] = lscpu_info[:flags] if lscpu_info[:flags]
+          lscpu_info[current_cpu][:features] = lscpu_info[:flags] if lscpu_info[:architecture].match?(/aarch64|s390x/)
+          if lscpu_info[:architecture] == "s390x"
+            lscpu_info[current_cpu][:version] = cpu_info[current_cpu][:version] if cpu_info[current_cpu][:version]
+            lscpu_info[current_cpu][:identification] = cpu_info[current_cpu][:identification] if cpu_info[current_cpu][:identification]
+            lscpu_info[current_cpu][:machine] = cpu_info[current_cpu][:machine] if cpu_info[current_cpu][:machine]
+          end
+        end
+        lscpu_info[:total] = lscpu_total
+        lscpu_info[:real] = lscpu_real
+        lscpu_info[:cores] = lscpu_cores
+      else
+        logger.trace("Plugin CPU: Error executing lscpu. CPU data may not be available.")
+      end
+    rescue Ohai::Exceptions::Exec # util-linux isn't installed most likely
+      logger.trace("Plugin CPU: Error executing lscpu. util-linux may not be installed.")
+    end
+    lscpu_info
+  end
+
+  def parse_cpuinfo
     cpuinfo = Mash.new
     real_cpu = Mash.new
     cpu_number = 0
     current_cpu = nil
 
-    file_open("/proc/cpuinfo").each do |line|
+    file_open("/proc/cpuinfo").each_line do |line|
       case line
       when /processor\s+:\s(.+)/
         cpuinfo[$1] = Mash.new
@@ -68,7 +269,11 @@ Ohai.plugin(:CPU) do
       when /cpu family\s+:\s(.+)/
         cpuinfo[current_cpu]["family"] = $1
       when /model\s+:\s(.+)/
-        cpuinfo[current_cpu]["model"] = $1
+        model = $1
+        cpuinfo[current_cpu]["model"] = model
+        # ppc has "model" at the end of /proc/cpuinfo. In addition it should always include a include a dash or "IBM".
+        # So let's put this in cpu/model on ppc
+        cpuinfo["machine_model"] = model if model.match?(/-|IBM/)
       when /stepping\s+:\s(.+)/
         cpuinfo[current_cpu]["stepping"] = $1
       when /physical id\s+:\s(.+)/
@@ -94,6 +299,24 @@ Ohai.plugin(:CPU) do
         cpuinfo["bogomips_per_cpu"] = $1
       when /features\s+:\s(.+)/
         cpuinfo["features"] = $1.split
+      # ppc64le
+      when /revision\s+:\s(.+)/
+        cpuinfo[current_cpu]["model"] = $1
+      when /cpu\s+:\s(.+)/
+        cpuinfo[current_cpu]["model_name"] = $1
+      when /clock\s+:\s(.+)/
+        cpuinfo[current_cpu]["mhz"] = $1
+      when /timebase\s+:\s(.+)/
+        cpuinfo["timebase"] = $1
+      when /platform\s+:\s(.+)/
+        cpuinfo["platform"] = $1
+      when /machine\s+:\s(.+)/
+        cpuinfo["machine"] = $1
+      when /firmware\s+:\s(.+)/
+        cpuinfo["firmware"] = $1
+      when /MMU\s+:\s(.+)/
+        cpuinfo["mmu"] = $1
+      # s390x
       when /processor\s(\d):\s(.+)/
         current_cpu = $1
         cpu_number += 1
@@ -108,40 +331,28 @@ Ohai.plugin(:CPU) do
       end
     end
 
-    cpu cpuinfo
-
-    cpu[:total] = cpu_number
-
     # 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
+    if !real_cpu.empty? && cpuinfo["0"]["cores"]
+      logger.trace("Plugin CPU: Error executing lscpu. CPU data may not be available.")
+      cpuinfo[:real] = real_cpu.keys.length
+      cpuinfo[:cores] = real_cpu.keys.length * cpuinfo["0"]["cores"].to_i
     else
-      begin
-        logger.trace("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
-          logger.trace("Plugin CPU: Error executing lscpu. CPU data may not be available.")
-        end
-      rescue Ohai::Exceptions::Exec # util-linux isn't installed most likely
-        logger.trace("Plugin CPU: Error executing lscpu. util-linux may not be installed.")
-      end
+      logger.trace("Plugin CPU: real cpu & core data is missing in /proc/cpuinfo and lscpu")
+    end
+    cpuinfo[:total] = cpu_number
+    cpuinfo
+  end
+
+  collect_data(:linux) do
+    cpuinfo = parse_cpuinfo
+    lscpu = parse_lscpu(cpuinfo)
+
+    # If we don't have any data from lscpu then get it from /proc/cpuinfo
+    if lscpu.empty?
+      cpu cpuinfo
+    else
+      cpu lscpu
     end
   end