ohai 16.5.6 → 16.6.5

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

@@ -35,7 +35,7 @@ Ohai.plugin(:Virtualization) do
   end
 
   def fusion_exists?
-    ::File.exist?("/Applications/VMware\ Fusion.app/")
+    file_exist?("/Applications/VMware\ Fusion.app/")
   end
 
   def docker_exists?

data/lib/ohai/plugins/dmi.rb

@@ -76,7 +76,7 @@ Ohai.plugin(:DMI) do
           dmi[:table_location] = table_location[1]
 
         elsif ( handle = handle_line.match(line) )
-          unless Ohai::Common::DMI.whitelisted_ids.include?(handle[2].to_i)
+          unless Ohai::Common::DMI.allowlisted_ids.include?(handle[2].to_i)
             dmi_record = nil
             next
           end

data/lib/ohai/plugins/ec2.rb

@@ -97,8 +97,8 @@ Ohai.plugin(:EC2) do
   # @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)
+    if file_exist?(path)
+      file_read(path)
     end
   end
 
@@ -122,11 +122,17 @@ Ohai.plugin(:EC2) do
       fetch_metadata.each do |k, v|
         # fetch_metadata returns IAM security credentials, including the IAM user's
         # secret access key. We'd rather not have ohai send this information
-        # to the server.
-        # http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AESDG-chapter-instancedata.html#instancedata-data-categories
-        next if k == "iam" && !hint?("iam")
-
-        ec2[k] = v
+        # to the server. If the instance is associated with an IAM role we grab
+        # only the "info" key and the IAM role name.
+        # https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-categories.html
+        if k == "iam" && !hint?("iam")
+          ec2[:iam] = v.select { |key, value| key == "info" }
+          if v["security-credentials"] && v["security-credentials"].keys.length == 1
+            ec2[:iam]["role_name"] = v["security-credentials"].keys[0]
+          end
+        else
+          ec2[k] = v
+        end
       end
       ec2[:userdata] = fetch_userdata
       ec2[:account_id] = fetch_dynamic_data["accountId"]

data/lib/ohai/plugins/filesystem.rb

@@ -29,7 +29,7 @@ Ohai.plugin(:Filesystem) do
   def find_device(name)
     %w{/dev /dev/mapper}.each do |dir|
       path = File.join(dir, name)
-      return path if File.exist?(path)
+      return path if file_exist?(path)
     end
     name
   end
@@ -371,11 +371,11 @@ Ohai.plugin(:Filesystem) do
     end
 
     # Grab any missing mount information from /proc/mounts
-    if File.exist?("/proc/mounts")
+    if file_exist?("/proc/mounts")
       mounts = ""
       # Due to https://tickets.opscode.com/browse/OHAI-196
       # we have to non-block read dev files. Ew.
-      f = File.open("/proc/mounts")
+      f = file_open("/proc/mounts")
       loop do
         data = f.read_nonblock(4096)
         mounts << data

data/lib/ohai/plugins/gce.rb

@@ -40,8 +40,8 @@ Ohai.plugin(:GCE) do
   # @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)
+    if file_exist?(path)
+      file_read(path)
     end
   end
 

data/lib/ohai/plugins/init_package.rb

@@ -20,6 +20,6 @@ Ohai.plugin(:InitPackage) do
   provides "init_package"
 
   collect_data(:linux) do
-    init_package File.exist?("/proc/1/comm") ? File.open("/proc/1/comm").gets.chomp : "init"
+    init_package file_exist?("/proc/1/comm") ? file_open("/proc/1/comm").gets.chomp : "init"
   end
 end

data/lib/ohai/plugins/joyent.rb

@@ -25,7 +25,7 @@ Ohai.plugin(:Joyent) do
   depends "os", "platform", "virtualization"
 
   def collect_product_file
-    data = ::File.read("/etc/product") rescue nil
+    data = file_read("/etc/product") rescue nil
     if data
       data.strip.split("\n")
     else
@@ -34,7 +34,7 @@ Ohai.plugin(:Joyent) do
   end
 
   def collect_pkgsrc
-    data = ::File.read("/opt/local/etc/pkg_install.conf") rescue nil
+    data = file_read("/opt/local/etc/pkg_install.conf") rescue nil
     if data
       /PKG_PATH=(.*)/.match(data)[1] rescue nil
     end

data/lib/ohai/plugins/kernel.rb

@@ -156,6 +156,10 @@ Ohai.plugin(:Kernel) do
     ].include?(name)
   end
 
+  collect_data(:target) do
+    # intentionally left blank
+  end
+
   collect_data(:default) do
     kernel init_kernel
   end
@@ -204,8 +208,8 @@ Ohai.plugin(:Kernel) do
       if line =~ /([a-zA-Z0-9\_]+)\s+(\d+)\s+(\d+)/
         modules[$1] = { size: $2, refcount: $3 }
         # Making sure to get the module version that has been loaded
-        if File.exist?("/sys/module/#{$1}/version")
-          version = File.read("/sys/module/#{$1}/version").chomp.strip
+        if file_exist?("/sys/module/#{$1}/version")
+          version = file_read("/sys/module/#{$1}/version").chomp.strip
           modules[$1]["version"] = version unless version.empty?
         end
       end
@@ -230,7 +234,7 @@ Ohai.plugin(:Kernel) do
     so = shell_out("uname -s")
     kernel[:os] = so.stdout.split($/)[0]
 
-    so = File.open("/etc/release", &:gets)
+    so = file_open("/etc/release", &:gets)
     md = /(?<update>\d.*\d)/.match(so)
     kernel[:update] = md[:update] if md
 

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

@@ -20,24 +20,24 @@ Ohai.plugin(:BlockDevice) do
   provides "block_device"
 
   collect_data(:linux) do
-    if File.exist?("/sys/block")
+    if file_exist?("/sys/block")
       block = Mash.new
-      Dir["/sys/block/*"].each do |block_device_dir|
+      dir_glob("/sys/block/*").each do |block_device_dir|
         dir = File.basename(block_device_dir)
         block[dir] = Mash.new
         %w{size removable}.each do |check|
-          if File.exist?("/sys/block/#{dir}/#{check}")
-            File.open("/sys/block/#{dir}/#{check}") { |f| block[dir][check] = f.read_nonblock(1024).strip }
+          if file_exist?("/sys/block/#{dir}/#{check}")
+            file_open("/sys/block/#{dir}/#{check}") { |f| block[dir][check] = f.read_nonblock(1024).strip }
           end
         end
         %w{model rev state timeout vendor queue_depth}.each do |check|
-          if File.exist?("/sys/block/#{dir}/device/#{check}")
-            File.open("/sys/block/#{dir}/device/#{check}") { |f| block[dir][check] = f.read_nonblock(1024).strip }
+          if file_exist?("/sys/block/#{dir}/device/#{check}")
+            file_open("/sys/block/#{dir}/device/#{check}") { |f| block[dir][check] = f.read_nonblock(1024).strip }
           end
         end
         %w{rotational physical_block_size logical_block_size}.each do |check|
-          if File.exist?("/sys/block/#{dir}/queue/#{check}")
-            File.open("/sys/block/#{dir}/queue/#{check}") { |f| block[dir][check] = f.read_nonblock(1024).strip }
+          if file_exist?("/sys/block/#{dir}/queue/#{check}")
+            file_open("/sys/block/#{dir}/queue/#{check}") { |f| block[dir][check] = f.read_nonblock(1024).strip }
           end
         end
       end

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

@@ -25,7 +25,7 @@ Ohai.plugin(:Interrupts) do
   # format: comma-separate list of 32bit bitmask in hex
   # each bit is a CPU, right to left ordering (i.e. CPU0 is rightmost)
   def parse_smp_affinity(path, cpus)
-    masks = File.read(path).strip
+    masks = file_read(path).strip
     bit_masks = []
     masks.split(",").each do |mask|
       bit_masks << mask.rjust(8, "0").to_i(16).to_s(2)
@@ -47,7 +47,7 @@ Ohai.plugin(:Interrupts) do
       parse_smp_affinity("/proc/irq/default_smp_affinity", cpus)
 
     interrupts[:irq] = Mash.new
-    File.open("/proc/interrupts").each do |line|
+    file_open("/proc/interrupts").each do |line|
       # Documentation: https://www.kernel.org/doc/Documentation/filesystems/proc.txt
       # format is "{irqn}: {CPUn...} [type] [vector] [device]"
       irqn, fields = line.split(":", 2)
@@ -70,7 +70,7 @@ Ohai.plugin(:Interrupts) do
         interrupts[:irq][irqn][:vector],
         interrupts[:irq][irqn][:device] =
           fields[cpus].split
-        if File.exist?("/proc/irq/#{irqn}/smp_affinity")
+        if file_exist?("/proc/irq/#{irqn}/smp_affinity")
           interrupts[:irq][irqn][:smp_affinity_by_cpu] =
             parse_smp_affinity("/proc/irq/#{irqn}/smp_affinity", cpus)
         end

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

@@ -22,7 +22,7 @@ Ohai.plugin(:LSB) do
   collect_data(:linux) do
     lsb Mash.new
 
-    if File.exist?("/usr/bin/lsb_release")
+    if file_exist?("/usr/bin/lsb_release")
       # From package redhat-lsb on Fedora/Redhat, lsb-release on Debian/Ubuntu
       shell_out("lsb_release -a").stdout.lines do |line|
         case line
@@ -38,9 +38,9 @@ Ohai.plugin(:LSB) do
           lsb[:id] = line
         end
       end
-    elsif File.exist?("/etc/lsb-release")
+    elsif file_exist?("/etc/lsb-release")
       # Old, non-standard Debian support
-      File.open("/etc/lsb-release").each do |line|
+      file_open("/etc/lsb-release").each do |line|
         case line
         when /^DISTRIB_ID=["']?(.+?)["']?$/
           lsb[:id] = $1

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

@@ -20,10 +20,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

@@ -53,9 +53,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

@@ -25,7 +25,7 @@ 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+) (.+)$/
         memory[:total] = "#{$1}#{$2}"

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

@@ -35,7 +35,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 +43,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)

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

@@ -43,9 +43,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 +64,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 +77,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 +88,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")
@@ -178,18 +178,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 +197,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 +243,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 +285,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/virtualization.rb

@@ -51,15 +51,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 +68,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 +92,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 +103,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 +129,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 +142,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 +153,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 +188,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 +199,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 +224,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 +233,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 +248,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"