ohai 16.4.12 → 16.7.18

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Author:: Joerg Herzinger <joerg.herzinger@oiml.at>
 # Author:: Phil Dibowitz <phil@ipom.com>

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Author:: Davide Cavalca (<dcavalca@fb.com>)
 # Copyright:: Copyright (c) 2016 Facebook
@@ -20,10 +21,10 @@ 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
+    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

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Author:: Tim Smith <tsmith@limelight.com>
 # Author:: Phil Dibowitz <phild@ipomc.com>
@@ -53,9 +54,9 @@ Ohai.plugin(:Mdadm) do
 
   collect_data(:linux) do
     # gather a list of all raid arrays
-    if File.exist?("/proc/mdstat")
+    if file_exist?("/proc/mdstat")
       devices = {}
-      File.open("/proc/mdstat").each do |line|
+      file_open("/proc/mdstat").each do |line|
         if line =~ /(md[0-9]+)/
           device = Regexp.last_match[1]
           pieces = line.split(/\s+/)

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

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

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

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Chris Read <chris.read@gmail.com>
-# Copyright:: Copyright (c) 2008-2017, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -35,7 +36,7 @@ Ohai.plugin(:Network) do
   end
 
   def ipv6_enabled?
-    File.exist? "/proc/net/if_inet6"
+    file_exist? "/proc/net/if_inet6"
   end
 
   def ethtool_binary_path
@@ -43,11 +44,11 @@ Ohai.plugin(:Network) do
   end
 
   def is_openvz?
-    @openvz ||= ::File.directory?("/proc/vz")
+    @openvz ||= file_directory?("/proc/vz")
   end
 
   def is_openvz_host?
-    is_openvz? && ::File.directory?("/proc/bc")
+    is_openvz? && file_directory?("/proc/bc")
   end
 
   def extract_neighbors(family, iface, neigh_attr)
@@ -141,12 +142,12 @@ Ohai.plugin(:Network) do
   # using a temporary var to hold routes and their interface name
   def parse_routes(family, iface)
     iface.collect do |i, iv|
-      if iv[:routes]
-        iv[:routes].collect do |r|
-          r.merge(dev: i) if r[:family] == family[:name]
-        end.compact
-      end
-    end.compact.flatten
+      next unless iv[:routes]
+
+      iv[:routes].collect do |r|
+        r.merge(dev: i) if r[:family] == family[:name]
+      end.compact # @todo: when we drop ruby 2.6 this should be a filter_map
+    end.compact.flatten # @todo: when we drop ruby 2.6 this should be a filter_map
   end
 
   # determine layer 1 details for the interface using ethtool
@@ -264,7 +265,7 @@ Ohai.plugin(:Network) do
         end
         key, val = line.split(/:\s+/)
         if val
-          coalesce_key = "#{key.downcase.tr(" ", "_")}"
+          coalesce_key = key.downcase.tr(" ", "_").to_s
           iface[tmp_int]["coalesce_params"][coalesce_key] = val.to_i
         end
       end
@@ -289,7 +290,7 @@ Ohai.plugin(:Network) do
         if val.nil?
           val = ""
         end
-        driver_key = "#{key.downcase.tr(" ", "_")}"
+        driver_key = key.downcase.tr(" ", "_").to_s
         iface[tmp_int]["driver_info"][driver_key] = val.chomp
       end
     end
@@ -646,7 +647,7 @@ Ohai.plugin(:Network) do
           logger.trace("Plugin Network: #{default_prefix}_interface set to #{default_route[:dev]}")
 
           # setting gateway to 0.0.0.0 or :: if the default route is a link level one
-          network["#{default_prefix}_gateway"] = default_route[:via] ? default_route[:via] : family[:default_route].chomp("/0")
+          network["#{default_prefix}_gateway"] = default_route[:via] || family[:default_route].chomp("/0")
           logger.trace("Plugin Network: #{default_prefix}_gateway set to #{network["#{default_prefix}_gateway"]}")
 
           # deduce the default route the user most likely cares about to pick {ip,mac,ip6}address below

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright (c) 2015-2017, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -43,9 +44,9 @@ Ohai.plugin(:Platform) do
   # @returns [Hash] the file parsed into a Hash or nil
   #
   def read_os_release_info(file)
-    return nil unless File.exist?(file)
+    return nil unless file_exist?(file)
 
-    File.read(file).split.inject({}) do |map, line|
+    file_read(file).split.inject({}) do |map, line|
       key, value = line.split("=")
       map[key] = value.gsub(/\A"|"\Z/, "") if value
       map
@@ -64,7 +65,7 @@ Ohai.plugin(:Platform) do
       begin
         os_release_info = read_os_release_info("/etc/os-release")
         cisco_release_info = os_release_info["CISCO_RELEASE_INFO"] if os_release_info
-        if cisco_release_info && File.exist?(cisco_release_info)
+        if cisco_release_info && file_exist?(cisco_release_info)
           os_release_info.merge!(read_os_release_info(cisco_release_info))
         end
         os_release_info
@@ -77,7 +78,7 @@ Ohai.plugin(:Platform) do
   # @returns [Boolean] if we are Cisco according to /etc/os-release
   #
   def os_release_file_is_cisco?
-    File.exist?("/etc/os-release") && os_release_info["CISCO_RELEASE_INFO"]
+    file_exist?("/etc/os-release") && os_release_info["CISCO_RELEASE_INFO"]
   end
 
   #
@@ -88,7 +89,7 @@ Ohai.plugin(:Platform) do
   # @returns [String] bigip Linux version from /etc/f5-release
   #
   def bigip_version
-    release_contents = File.read("/etc/f5-release")
+    release_contents = file_read("/etc/f5-release")
     release_contents.match(/BIG-IP release (\S*)/)[1] # http://rubular.com/r/O8nlrBVqSb
   rescue NoMethodError, Errno::ENOENT, Errno::EACCES # rescue regex failure, file missing, or permission denied
     logger.warn("Detected F5 Big-IP, but /etc/f5-release could not be parsed to determine platform_version")
@@ -132,7 +133,7 @@ Ohai.plugin(:Platform) do
   #
   def platform_family_from_platform(plat)
     case plat
-    when /debian/, /ubuntu/, /linuxmint/, /raspbian/, /cumulus/, /kali/
+    when /debian/, /ubuntu/, /linuxmint/, /raspbian/, /cumulus/, /kali/, /pop/
       # apt-get+dpkg almost certainly goes here
       "debian"
     when /oracle/, /centos/, /redhat/, /scientific/, /enterpriseenterprise/, /xcp/, /xenserver/, /cloudlinux/, /ibm_powerkvm/, /parallels/, /nexus_centos/, /clearos/, /bigip/ # Note that 'enterpriseenterprise' is oracle's LSB "distributor ID"
@@ -178,18 +179,18 @@ Ohai.plugin(:Platform) do
   # @deprecated
   def legacy_platform_detection
     # platform [ and platform_version ? ] should be lower case to avoid dealing with RedHat/Redhat/redhat matching
-    if File.exist?("/etc/oracle-release")
-      contents = File.read("/etc/oracle-release").chomp
+    if file_exist?("/etc/oracle-release")
+      contents = file_read("/etc/oracle-release").chomp
       platform "oracle"
       platform_version get_redhatish_version(contents)
-    elsif File.exist?("/etc/enterprise-release")
-      contents = File.read("/etc/enterprise-release").chomp
+    elsif file_exist?("/etc/enterprise-release")
+      contents = file_read("/etc/enterprise-release").chomp
       platform "oracle"
       platform_version get_redhatish_version(contents)
-    elsif File.exist?("/etc/f5-release")
+    elsif file_exist?("/etc/f5-release")
       platform "bigip"
       platform_version bigip_version
-    elsif File.exist?("/etc/debian_version")
+    elsif file_exist?("/etc/debian_version")
       # Ubuntu and Debian both have /etc/debian_version
       # Ubuntu should always have a working lsb, debian does not by default
       if /Ubuntu/i.match?(lsb[:id])
@@ -197,25 +198,25 @@ Ohai.plugin(:Platform) do
         platform_version lsb[:release]
       else
         platform "debian"
-        platform_version File.read("/etc/debian_version").chomp
+        platform_version file_read("/etc/debian_version").chomp
       end
-    elsif File.exist?("/etc/parallels-release")
-      contents = File.read("/etc/parallels-release").chomp
+    elsif file_exist?("/etc/parallels-release")
+      contents = file_read("/etc/parallels-release").chomp
       platform get_redhatish_platform(contents)
       platform_version contents.match(/(\d\.\d\.\d)/)[0]
-    elsif File.exist?("/etc/Eos-release")
+    elsif file_exist?("/etc/Eos-release")
       platform "arista_eos"
-      platform_version File.read("/etc/Eos-release").strip.split[-1]
-    elsif File.exist?("/etc/redhat-release")
-      contents = File.read("/etc/redhat-release").chomp
+      platform_version file_read("/etc/Eos-release").strip.split[-1]
+    elsif file_exist?("/etc/redhat-release")
+      contents = file_read("/etc/redhat-release").chomp
       platform get_redhatish_platform(contents)
       platform_version get_redhatish_version(contents)
-    elsif File.exist?("/etc/system-release")
-      contents = File.read("/etc/system-release").chomp
+    elsif file_exist?("/etc/system-release")
+      contents = file_read("/etc/system-release").chomp
       platform get_redhatish_platform(contents)
       platform_version get_redhatish_version(contents)
-    elsif File.exist?("/etc/SuSE-release")
-      suse_release = File.read("/etc/SuSE-release")
+    elsif file_exist?("/etc/SuSE-release")
+      suse_release = file_read("/etc/SuSE-release")
       suse_version = suse_release.scan(/VERSION = (\d+)\nPATCHLEVEL = (\d+)/).flatten.join(".")
       suse_version = suse_release[/VERSION = ([\d\.]{2,})/, 1] if suse_version == ""
       platform_version suse_version
@@ -243,16 +244,16 @@ Ohai.plugin(:Platform) do
       end
 
       platform_version os_release_info["VERSION"]
-    elsif File.exist?("/etc/slackware-version")
+    elsif file_exist?("/etc/slackware-version")
       platform "slackware"
-      platform_version File.read("/etc/slackware-version").scan(/(\d+|\.+)/).join
-    elsif File.exist?("/etc/exherbo-release")
+      platform_version file_read("/etc/slackware-version").scan(/(\d+|\.+)/).join
+    elsif file_exist?("/etc/exherbo-release")
       platform "exherbo"
       # no way to determine platform_version in a rolling release distribution
       # kernel release will be used - ex. 3.13
       platform_version shell_out("/bin/uname -r").stdout.strip
-    elsif File.exist?("/usr/lib/os-release")
-      contents = File.read("/usr/lib/os-release")
+    elsif file_exist?("/usr/lib/os-release")
+      contents = file_read("/usr/lib/os-release")
       if /clear-linux-os/.match?(contents) # Clear Linux https://clearlinux.org/
         platform "clearlinux"
         platform_version contents[/VERSION_ID=(\d+)/, 1]
@@ -285,14 +286,14 @@ Ohai.plugin(:Platform) do
   def determine_os_version
     # centos only includes the major version in os-release for some reason
     if os_release_info["ID"] == "centos"
-      get_redhatish_version(File.read("/etc/redhat-release").chomp)
+      get_redhatish_version(file_read("/etc/redhat-release").chomp)
     else
       os_release_info["VERSION_ID"] || shell_out("/bin/uname -r").stdout.strip
     end
   end
 
   collect_data(:linux) do
-    if ::File.exist?("/etc/os-release")
+    if file_exist?("/etc/os-release")
       logger.trace("Plugin platform: Using /etc/os-release for platform detection")
 
       # fixup os-release names to ohai platform names

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Author:: Davide Cavalca <dcavalca@fb.com>
 # Copyright:: Copyright (c) 2020 Facebook

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Author:: Davide Cavalca <dcavalca@fb.com>
 # Copyright:: Copyright (c) 2016 Facebook

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Author:: Joshua Miller <joshmiller@fb.com>
 # Copyright:: Copyright (c) 2019 Facebook

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Author:: Davide Cavalca <dcavalca@fb.com>
 # Copyright:: Copyright (c) 2017 Facebook

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 #
 # Author:: Thom May (<thom@clearairturbulence.org>)
-# Copyright:: Copyright (c) 2009-2016 Chef Software, Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -51,15 +52,15 @@ Ohai.plugin(:Virtualization) do
     # - may be able to determine if under paravirt from /dev/xen/evtchn (See OHAI-253)
     # - Additional edge cases likely should not change the above assumptions
     #   but rather be additive - btm
-    if File.exist?("/proc/xen")
+    if file_exist?("/proc/xen")
       virtualization[:system] = "xen"
       # Assume guest
       virtualization[:role] = "guest"
       virtualization[:systems][:xen] = "guest"
 
       # This file should exist on most Xen systems, normally empty for guests
-      if File.exist?("/proc/xen/capabilities")
-        if /control_d/i.match?(File.read("/proc/xen/capabilities"))
+      if file_exist?("/proc/xen/capabilities")
+        if /control_d/i.match?(file_read("/proc/xen/capabilities"))
           logger.trace("Plugin Virtualization: /proc/xen/capabilities contains control_d. Detecting as Xen host")
           virtualization[:role] = "host"
           virtualization[:systems][:xen] = "host"
@@ -68,8 +69,8 @@ Ohai.plugin(:Virtualization) do
     end
 
     # Detect Virtualbox from kernel module
-    if File.exist?("/proc/modules")
-      modules = File.read("/proc/modules")
+    if file_exist?("/proc/modules")
+      modules = file_read("/proc/modules")
       if /^vboxdrv/.match?(modules)
         logger.trace("Plugin Virtualization: /proc/modules contains vboxdrv. Detecting as vbox host")
         virtualization[:system] = "vbox"
@@ -92,8 +93,8 @@ Ohai.plugin(:Virtualization) do
     end
 
     # Detect paravirt KVM/QEMU from cpuinfo, report as KVM
-    if File.exist?("/proc/cpuinfo")
-      if /QEMU Virtual CPU|Common KVM processor|Common 32-bit KVM processor/.match?(File.read("/proc/cpuinfo"))
+    if file_exist?("/proc/cpuinfo")
+      if /QEMU Virtual CPU|Common KVM processor|Common 32-bit KVM processor/.match?(file_read("/proc/cpuinfo"))
         logger.trace("Plugin Virtualization: /proc/cpuinfo lists a KVM paravirt CPU string. Detecting as kvm guest")
         virtualization[:system] = "kvm"
         virtualization[:role] = "guest"
@@ -103,9 +104,9 @@ Ohai.plugin(:Virtualization) do
 
     # Detect KVM systems via /sys
     # guests will have the hypervisor cpu feature that hosts don't have
-    if File.exist?("/sys/devices/virtual/misc/kvm")
+    if file_exist?("/sys/devices/virtual/misc/kvm")
       virtualization[:system] = "kvm"
-      if /hypervisor/.match?(File.read("/proc/cpuinfo"))
+      if /hypervisor/.match?(file_read("/proc/cpuinfo"))
         logger.trace("Plugin Virtualization: /sys/devices/virtual/misc/kvm present and /proc/cpuinfo lists the hypervisor feature. Detecting as kvm guest")
         virtualization[:role] = "guest"
         virtualization[:systems][:kvm] = "guest"
@@ -129,12 +130,12 @@ Ohai.plugin(:Virtualization) do
 
     # Detect OpenVZ / Virtuozzo.
     # http://wiki.openvz.org/BC_proc_entries
-    if File.exist?("/proc/bc/0")
+    if file_exist?("/proc/bc/0")
       logger.trace("Plugin Virtualization: /proc/bc/0 exists. Detecting as openvz host")
       virtualization[:system] = "openvz"
       virtualization[:role] = "host"
       virtualization[:systems][:openvz] = "host"
-    elsif File.exist?("/proc/vz")
+    elsif file_exist?("/proc/vz")
       logger.trace("Plugin Virtualization: /proc/vz exists. Detecting as openvz guest")
       virtualization[:system] = "openvz"
       virtualization[:role] = "guest"
@@ -142,9 +143,9 @@ Ohai.plugin(:Virtualization) do
     end
 
     # Detect Hyper-V guest and the hostname of the host
-    if File.exist?("/var/lib/hyperv/.kvp_pool_3")
+    if file_exist?("/var/lib/hyperv/.kvp_pool_3")
       logger.trace("Plugin Virtualization: /var/lib/hyperv/.kvp_pool_3 contains string indicating Hyper-V guest")
-      data = File.read("/var/lib/hyperv/.kvp_pool_3")
+      data = file_read("/var/lib/hyperv/.kvp_pool_3")
       hyperv_host = data[/\HostName(.*?)HostingSystemEditionId/, 1].scan(/[[:print:]]/).join.downcase
       virtualization[:system] = "hyperv"
       virtualization[:role] = "guest"
@@ -153,8 +154,8 @@ Ohai.plugin(:Virtualization) do
     end
 
     # Detect Linux-VServer
-    if File.exist?("/proc/self/status")
-      proc_self_status = File.read("/proc/self/status")
+    if file_exist?("/proc/self/status")
+      proc_self_status = file_read("/proc/self/status")
       vxid = proc_self_status.match(/^(s_context|VxID):\s*(\d+)$/)
       if vxid && vxid[2]
         virtualization[:system] = "linux-vserver"
@@ -188,8 +189,8 @@ Ohai.plugin(:Virtualization) do
     #
     # Full notes, https://tickets.opscode.com/browse/OHAI-551
     # Kernel docs, https://www.kernel.org/doc/Documentation/cgroups
-    if File.exist?("/proc/self/cgroup")
-      cgroup_content = File.read("/proc/self/cgroup")
+    if file_exist?("/proc/self/cgroup")
+      cgroup_content = file_read("/proc/self/cgroup")
       # These two REs catch many different examples. Here's a specific one
       # from when it is docker and there is no subsystem name.
       # https://rubular.com/r/dV13hiU9KxmiWB
@@ -199,17 +200,17 @@ Ohai.plugin(:Virtualization) do
         virtualization[:system] = $1
         virtualization[:role] = "guest"
         virtualization[:systems][$1.to_sym] = "guest"
-      elsif /container=lxc/.match?(File.read("/proc/1/environ"))
+      elsif /container=lxc/.match?(file_read("/proc/1/environ"))
         logger.trace("Plugin Virtualization: /proc/1/environ indicates lxc container. Detecting as lxc guest")
         virtualization[:system] = "lxc"
         virtualization[:role] = "guest"
         virtualization[:systems][:lxc] = "guest"
-      elsif /container=systemd-nspawn/.match?(File.read("/proc/1/environ"))
+      elsif /container=systemd-nspawn/.match?(file_read("/proc/1/environ"))
         logger.trace("Plugin Virtualization: /proc/1/environ indicates nspawn container. Detecting as nspawn guest")
         virtualization[:system] = "nspawn"
         virtualization[:role] = "guest"
         virtualization[:systems][:nspawn] = "guest"
-      elsif lxc_version_exists? && File.read("/proc/self/cgroup") =~ %r{\d:[^:]+:/$}
+      elsif lxc_version_exists? && file_read("/proc/self/cgroup") =~ %r{\d:[^:]+:/$}
         # lxc-version shouldn't be installed by default
         # Even so, it is likely we are on an LXC capable host that is not being used as such
         # So we're cautious here to not overwrite other existing values (OHAI-573)
@@ -224,7 +225,7 @@ Ohai.plugin(:Virtualization) do
         # If so, we may need to look further for a differentiator (OHAI-573)
         virtualization[:systems][:lxc] = "host"
       end
-    elsif File.exist?("/.dockerenv") || File.exist?("/.dockerinit")
+    elsif file_exist?("/.dockerenv") || file_exist?("/.dockerinit")
       logger.trace("Plugin Virtualization: .dockerenv or .dockerinit exist. Detecting as docker guest")
       virtualization[:system] = "docker"
       virtualization[:role] = "guest"
@@ -233,7 +234,7 @@ Ohai.plugin(:Virtualization) do
 
     # Detect LXD
     # See https://github.com/lxc/lxd/blob/master/doc/dev-lxd.md
-    if File.exist?("/dev/lxd/sock")
+    if file_exist?("/dev/lxd/sock")
       logger.trace("Plugin Virtualization: /dev/lxd/sock exists. Detecting as lxd guest")
       virtualization[:system] = "lxd"
       virtualization[:role] = "guest"
@@ -248,7 +249,7 @@ Ohai.plugin(:Virtualization) do
       # Snap based installations utilize '/var/snap/lxd/common/lxd/'
       #   - includes all future releases starting with 2.21, and will be the only source of 3.1+ feature releases post-bionic
       ["/var/lib/lxd/devlxd", "/var/snap/lxd/common/lxd/devlxd"].each do |devlxd|
-        if File.exist?(devlxd)
+        if file_exist?(devlxd)
           logger.trace("Plugin Virtualization: #{devlxd} exists. Detecting as lxd host")
           virtualization[:system] = "lxd"
           virtualization[:role] = "host"