ohai 18.2.6 → 19.0.3

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

@@ -1,36 +1,36 @@
-# frozen_string_literal: true
-#
-# Author:: Davide Cavalca (<dcavalca@fb.com>)
-# Copyright:: Copyright (c) 2016 Facebook
-# 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.
-#
-
-Ohai.plugin(:Machineid) do
-  provides "machine_id"
-
-  collect_data(:linux) do
-    if file_exist?("/etc/machine-id")
-      mid = file_read("/etc/machine-id").chomp
-    elsif file_exist?("/var/lib/dbus/machine-id")
-      mid = file_read("/var/lib/dbus/machine-id").chomp
-    else
-      mid = nil
-    end
-
-    if mid
-      machine_id mid
-    end
-  end
-end
+# frozen_string_literal: true
+#
+# Author:: Davide Cavalca (<dcavalca@fb.com>)
+# Copyright:: Copyright (c) 2016 Facebook
+# 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.
+#
+
+Ohai.plugin(:Machineid) do
+  provides "machine_id"
+
+  collect_data(:linux) do
+    if file_exist?("/etc/machine-id")
+      mid = file_read("/etc/machine-id").chomp
+    elsif file_exist?("/var/lib/dbus/machine-id")
+      mid = file_read("/var/lib/dbus/machine-id").chomp
+    else
+      mid = nil
+    end
+
+    if mid
+      machine_id mid
+    end
+  end
+end

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

@@ -1,120 +1,120 @@
-# frozen_string_literal: true
-#
-# 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");
-# 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.
-#
-
-Ohai.plugin(:Mdadm) do
-  provides "mdadm"
-
-  def create_raid_device_mash(stdout)
-    device_mash = Mash.new
-    device_mash[:device_counts] = Mash.new
-    stdout.lines.each do |line|
-      case line
-      when /Version\s+: ([0-9.]+)/
-        device_mash[:version] = Regexp.last_match[1].to_f
-      when /Raid Level\s+: raid([0-9]+)/
-        device_mash[:level] = Regexp.last_match[1].to_i
-      when /Array Size.*\(([0-9.]+)/
-        device_mash[:size] = Regexp.last_match[1].to_f
-      when /State\s+: ([a-z]+)/
-        device_mash[:state] = Regexp.last_match[1]
-      when /UUID\s+: ([0-9a-z:]+)/
-        device_mash[:UUID] = Regexp.last_match[1]
-      when /Total Devices\s+: ([0-9]+)/
-        device_mash[:device_counts][:total] = Regexp.last_match[1].to_i
-      when /Raid Devices\s+: ([0-9]+)/
-        device_mash[:device_counts][:raid] = Regexp.last_match[1].to_i
-      when /Working Devices\s+: ([0-9]+)/
-        device_mash[:device_counts][:working] = Regexp.last_match[1].to_i
-      when /Failed Devices\s+: ([0-9]+)/
-        device_mash[:device_counts][:failed] = Regexp.last_match[1].to_i
-      when /Active Devices\s+: ([0-9]+)/
-        device_mash[:device_counts][:active] = Regexp.last_match[1].to_i
-      when /Spare Devices\s+: ([0-9]+)/
-        device_mash[:device_counts][:spare] = Regexp.last_match[1].to_i
-      end
-    end
-    device_mash
-  end
-
-  collect_data(:linux) do
-    # gather a list of all raid arrays
-    if file_exist?("/proc/mdstat")
-      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
-      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|
-          mdadm[device] = Mash.new
-
-          # gather detailed information on the array
-          so = shell_out("mdadm --detail /dev/#{device}")
-
-          # if the mdadm command was successful 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
-  end
-end
+# frozen_string_literal: true
+#
+# 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");
+# 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.
+#
+
+Ohai.plugin(:Mdadm) do
+  provides "mdadm"
+
+  def create_raid_device_mash(stdout)
+    device_mash = Mash.new
+    device_mash[:device_counts] = Mash.new
+    stdout.lines.each do |line|
+      case line
+      when /Version\s+: ([0-9.]+)/
+        device_mash[:version] = Regexp.last_match[1].to_f
+      when /Raid Level\s+: raid([0-9]+)/
+        device_mash[:level] = Regexp.last_match[1].to_i
+      when /Array Size.*\(([0-9.]+)/
+        device_mash[:size] = Regexp.last_match[1].to_f
+      when /State\s+: ([a-z]+)/
+        device_mash[:state] = Regexp.last_match[1]
+      when /UUID\s+: ([0-9a-z:]+)/
+        device_mash[:UUID] = Regexp.last_match[1]
+      when /Total Devices\s+: ([0-9]+)/
+        device_mash[:device_counts][:total] = Regexp.last_match[1].to_i
+      when /Raid Devices\s+: ([0-9]+)/
+        device_mash[:device_counts][:raid] = Regexp.last_match[1].to_i
+      when /Working Devices\s+: ([0-9]+)/
+        device_mash[:device_counts][:working] = Regexp.last_match[1].to_i
+      when /Failed Devices\s+: ([0-9]+)/
+        device_mash[:device_counts][:failed] = Regexp.last_match[1].to_i
+      when /Active Devices\s+: ([0-9]+)/
+        device_mash[:device_counts][:active] = Regexp.last_match[1].to_i
+      when /Spare Devices\s+: ([0-9]+)/
+        device_mash[:device_counts][:spare] = Regexp.last_match[1].to_i
+      end
+    end
+    device_mash
+  end
+
+  collect_data(:linux) do
+    # gather a list of all raid arrays
+    if file_exist?("/proc/mdstat")
+      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
+      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|
+          mdadm[device] = Mash.new
+
+          # gather detailed information on the array
+          so = shell_out("mdadm --detail /dev/#{device}")
+
+          # if the mdadm command was successful 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
+  end
+end

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

@@ -1,106 +1,106 @@
-# frozen_string_literal: true
-#
-# Author:: Adam Jacob (<adam@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.
-#
-
-Ohai.plugin(:Memory) do
-  provides "memory", "memory/swap"
-
-  collect_data(:linux) do
-    memory Mash.new
-    memory[:swap] = Mash.new
-    memory[:hugepages] = Mash.new
-    memory[:directmap] = Mash.new
-
-    file_open("/proc/meminfo").each do |line|
-      case line
-      when /^MemTotal:\s+(\d+) (.+)/
-        memory[:total] = "#{$1}#{$2}"
-      when /^MemFree:\s+(\d+) (.+)/
-        memory[:free] = "#{$1}#{$2}"
-      when /^MemAvailable:\s+(\d+) (.+)/
-        memory[:available] = "#{$1}#{$2}"
-      when /^Buffers:\s+(\d+) (.+)/
-        memory[:buffers] = "#{$1}#{$2}"
-      when /^Cached:\s+(\d+) (.+)/
-        memory[:cached] = "#{$1}#{$2}"
-      when /^Active:\s+(\d+) (.+)/
-        memory[:active] = "#{$1}#{$2}"
-      when /^Inactive:\s+(\d+) (.+)/
-        memory[:inactive] = "#{$1}#{$2}"
-      when /^HighTotal:\s+(\d+) (.+)/
-        memory[:high_total] = "#{$1}#{$2}"
-      when /^HighFree:\s+(\d+) (.+)/
-        memory[:high_free] = "#{$1}#{$2}"
-      when /^LowTotal:\s+(\d+) (.+)/
-        memory[:low_total] = "#{$1}#{$2}"
-      when /^LowFree:\s+(\d+) (.+)/
-        memory[:low_free] = "#{$1}#{$2}"
-      when /^Dirty:\s+(\d+) (.+)/
-        memory[:dirty] = "#{$1}#{$2}"
-      when /^Writeback:\s+(\d+) (.+)/
-        memory[:writeback] = "#{$1}#{$2}"
-      when /^AnonPages:\s+(\d+) (.+)/
-        memory[:anon_pages] = "#{$1}#{$2}"
-      when /^Mapped:\s+(\d+) (.+)/
-        memory[:mapped] = "#{$1}#{$2}"
-      when /^Slab:\s+(\d+) (.+)/
-        memory[:slab] = "#{$1}#{$2}"
-      when /^SReclaimable:\s+(\d+) (.+)/
-        memory[:slab_reclaimable] = "#{$1}#{$2}"
-      when /^SUnreclaim:\s+(\d+) (.+)/
-        memory[:slab_unreclaim] = "#{$1}#{$2}"
-      when /^PageTables:\s+(\d+) (.+)/
-        memory[:page_tables] = "#{$1}#{$2}"
-      when /^NFS_Unstable:\s+(\d+) (.+)/
-        memory[:nfs_unstable] = "#{$1}#{$2}"
-      when /^Bounce:\s+(\d+) (.+)/
-        memory[:bounce] = "#{$1}#{$2}"
-      when /^CommitLimit:\s+(\d+) (.+)/
-        memory[:commit_limit] = "#{$1}#{$2}"
-      when /^Committed_AS:\s+(\d+) (.+)/
-        memory[:committed_as] = "#{$1}#{$2}"
-      when /^VmallocTotal:\s+(\d+) (.+)/
-        memory[:vmalloc_total] = "#{$1}#{$2}"
-      when /^VmallocUsed:\s+(\d+) (.+)/
-        memory[:vmalloc_used] = "#{$1}#{$2}"
-      when /^VmallocChunk:\s+(\d+) (.+)/
-        memory[:vmalloc_chunk] = "#{$1}#{$2}"
-      when /^SwapCached:\s+(\d+) (.+)/
-        memory[:swap][:cached] = "#{$1}#{$2}"
-      when /^SwapTotal:\s+(\d+) (.+)/
-        memory[:swap][:total] = "#{$1}#{$2}"
-      when /^SwapFree:\s+(\d+) (.+)/
-        memory[:swap][:free] = "#{$1}#{$2}"
-      when /^HugePages_Total:\s+(\d+)/
-        memory[:hugepages][:total] = $1.to_s
-      when /^HugePages_Free:\s+(\d+)/
-        memory[:hugepages][:free] = $1.to_s
-      when /^HugePages_Rsvd:\s+(\d+)/
-        memory[:hugepages][:reserved] = $1.to_s
-      when /^HugePages_Surp:\s+(\d+)/
-        memory[:hugepages][:surplus] = $1.to_s
-      when /^Hugepagesize:\s+(\d+) (.+)/
-        memory[:hugepage_size] = "#{$1}#{$2}"
-      when /^Hugetlb:\s+(\d+) (.+)/
-        memory[:hugetlb] = "#{$1}#{$2}"
-      when /^DirectMap([0-9]+[a-zA-Z]):\s+(\d+) (.+)/
-        memory[:directmap][$1.to_sym] = "#{$2}#{$3}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+#
+# Author:: Adam Jacob (<adam@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.
+#
+
+Ohai.plugin(:Memory) do
+  provides "memory", "memory/swap"
+
+  collect_data(:linux) do
+    memory Mash.new
+    memory[:swap] = Mash.new
+    memory[:hugepages] = Mash.new
+    memory[:directmap] = Mash.new
+
+    file_open("/proc/meminfo").each do |line|
+      case line
+      when /^MemTotal:\s+(\d+) (.+)/
+        memory[:total] = "#{$1}#{$2}"
+      when /^MemFree:\s+(\d+) (.+)/
+        memory[:free] = "#{$1}#{$2}"
+      when /^MemAvailable:\s+(\d+) (.+)/
+        memory[:available] = "#{$1}#{$2}"
+      when /^Buffers:\s+(\d+) (.+)/
+        memory[:buffers] = "#{$1}#{$2}"
+      when /^Cached:\s+(\d+) (.+)/
+        memory[:cached] = "#{$1}#{$2}"
+      when /^Active:\s+(\d+) (.+)/
+        memory[:active] = "#{$1}#{$2}"
+      when /^Inactive:\s+(\d+) (.+)/
+        memory[:inactive] = "#{$1}#{$2}"
+      when /^HighTotal:\s+(\d+) (.+)/
+        memory[:high_total] = "#{$1}#{$2}"
+      when /^HighFree:\s+(\d+) (.+)/
+        memory[:high_free] = "#{$1}#{$2}"
+      when /^LowTotal:\s+(\d+) (.+)/
+        memory[:low_total] = "#{$1}#{$2}"
+      when /^LowFree:\s+(\d+) (.+)/
+        memory[:low_free] = "#{$1}#{$2}"
+      when /^Dirty:\s+(\d+) (.+)/
+        memory[:dirty] = "#{$1}#{$2}"
+      when /^Writeback:\s+(\d+) (.+)/
+        memory[:writeback] = "#{$1}#{$2}"
+      when /^AnonPages:\s+(\d+) (.+)/
+        memory[:anon_pages] = "#{$1}#{$2}"
+      when /^Mapped:\s+(\d+) (.+)/
+        memory[:mapped] = "#{$1}#{$2}"
+      when /^Slab:\s+(\d+) (.+)/
+        memory[:slab] = "#{$1}#{$2}"
+      when /^SReclaimable:\s+(\d+) (.+)/
+        memory[:slab_reclaimable] = "#{$1}#{$2}"
+      when /^SUnreclaim:\s+(\d+) (.+)/
+        memory[:slab_unreclaim] = "#{$1}#{$2}"
+      when /^PageTables:\s+(\d+) (.+)/
+        memory[:page_tables] = "#{$1}#{$2}"
+      when /^NFS_Unstable:\s+(\d+) (.+)/
+        memory[:nfs_unstable] = "#{$1}#{$2}"
+      when /^Bounce:\s+(\d+) (.+)/
+        memory[:bounce] = "#{$1}#{$2}"
+      when /^CommitLimit:\s+(\d+) (.+)/
+        memory[:commit_limit] = "#{$1}#{$2}"
+      when /^Committed_AS:\s+(\d+) (.+)/
+        memory[:committed_as] = "#{$1}#{$2}"
+      when /^VmallocTotal:\s+(\d+) (.+)/
+        memory[:vmalloc_total] = "#{$1}#{$2}"
+      when /^VmallocUsed:\s+(\d+) (.+)/
+        memory[:vmalloc_used] = "#{$1}#{$2}"
+      when /^VmallocChunk:\s+(\d+) (.+)/
+        memory[:vmalloc_chunk] = "#{$1}#{$2}"
+      when /^SwapCached:\s+(\d+) (.+)/
+        memory[:swap][:cached] = "#{$1}#{$2}"
+      when /^SwapTotal:\s+(\d+) (.+)/
+        memory[:swap][:total] = "#{$1}#{$2}"
+      when /^SwapFree:\s+(\d+) (.+)/
+        memory[:swap][:free] = "#{$1}#{$2}"
+      when /^HugePages_Total:\s+(\d+)/
+        memory[:hugepages][:total] = $1.to_s
+      when /^HugePages_Free:\s+(\d+)/
+        memory[:hugepages][:free] = $1.to_s
+      when /^HugePages_Rsvd:\s+(\d+)/
+        memory[:hugepages][:reserved] = $1.to_s
+      when /^HugePages_Surp:\s+(\d+)/
+        memory[:hugepages][:surplus] = $1.to_s
+      when /^Hugepagesize:\s+(\d+) (.+)/
+        memory[:hugepage_size] = "#{$1}#{$2}"
+      when /^Hugetlb:\s+(\d+) (.+)/
+        memory[:hugetlb] = "#{$1}#{$2}"
+      when /^DirectMap([0-9]+[a-zA-Z]):\s+(\d+) (.+)/
+        memory[:directmap][$1.to_sym] = "#{$2}#{$3}"
+      end
+    end
+  end
+end