ohai 13.12.6 → 14.0.28

data/lib/ohai/hints.rb

@@ -41,11 +41,11 @@ module Ohai
       Ohai.config[:hints_path].each do |path|
         filename = File.join(path, "#{name}.json")
         next unless File.exist?(filename)
-        Ohai::Log.debug("Found hint #{name}.json at #{filename}")
+        Ohai::Log.trace("Found hint #{name}.json at #{filename}")
         @hints[name] = parse_hint_file(filename)
       end
 
-      Ohai::Log.debug("Did not find hint #{name}.json in the hint path(s): #{Ohai.config[:hints_path].join(', ')} ") unless @hints.key?(name)
+      Ohai::Log.trace("Did not find hint #{name}.json in the hint path(s): #{Ohai.config[:hints_path].join(', ')} ") unless @hints.key?(name)
       @hints[name]
     end
   end

data/lib/ohai/loader.rb

@@ -44,27 +44,19 @@ module Ohai
           return []
         end
 
-        Ohai::Log.debug("Searching for Ohai plugins in #{plugin_dir}")
+        Ohai::Log.trace("Searching for Ohai plugins in #{plugin_dir}")
 
-        # escape_glob_dir does not exist in 12.7 or below
-        if ChefConfig::PathHelper.respond_to?(:escape_glob_dir)
-          escaped = ChefConfig::PathHelper.escape_glob_dir(plugin_dir)
-        else
-          escaped = ChefConfig::PathHelper.escape_glob(plugin_dir)
-        end
+        escaped = ChefConfig::PathHelper.escape_glob_dir(plugin_dir)
         Dir[File.join(escaped, "**", "*.rb")].map do |file|
           new(file, plugin_dir)
         end
       end
     end
 
-    # Simple struct to track a v6 plugin's class, file path, and the root of
-    # the plugin dir from which it was loaded.
-    V6PluginClass = Struct.new(:plugin_class, :plugin_path, :plugin_dir_path)
-
+    attr_reader :logger
     def initialize(controller)
       @controller = controller
-      @v6_plugin_classes = []
+      @logger = controller.logger.with_child(subsystem: "loader")
       @v7_plugin_classes = []
     end
 
@@ -81,14 +73,13 @@ module Ohai
         load_plugin_class(plugin_file.path, plugin_file.plugin_root)
       end
 
-      collect_v6_plugins
       collect_v7_plugins
     end
 
     def load_additional(from)
       from = [ Ohai.config[:plugin_path], from].flatten
       plugin_files_by_dir(from).collect do |plugin_file|
-        Ohai::Log.debug "Loading additional plugin: #{plugin_file}"
+        logger.trace "Loading additional plugin: #{plugin_file}"
         plugin = load_plugin_class(plugin_file.path, plugin_file.plugin_root)
         load_v7_plugin(plugin)
       end
@@ -97,14 +88,10 @@ module Ohai
     # Load a specified file as an ohai plugin and creates an instance of it.
     # Not used by ohai itself, but can be used to load a plugin for testing
     # purposes.
-    # plugin_dir_path is required when loading a v6 plugin.
     def load_plugin(plugin_path, plugin_dir_path = nil)
       plugin_class = load_plugin_class(plugin_path, plugin_dir_path)
       return nil unless plugin_class.kind_of?(Class)
-      case
-      when plugin_class < Ohai::DSL::Plugin::VersionVI
-        load_v6_plugin(plugin_class, plugin_path, plugin_dir_path)
-      when plugin_class < Ohai::DSL::Plugin::VersionVII
+      if plugin_class < Ohai::DSL::Plugin::VersionVII
         load_v7_plugin(plugin_class)
       else
         raise Exceptions::IllegalPluginDefinition, "cannot create plugin of type #{plugin_class}"
@@ -121,10 +108,10 @@ module Ohai
       # Read the contents of the plugin to understand if it's a V6 or V7 plugin.
       contents = ""
       begin
-        Ohai::Log.debug("Loading plugin at #{plugin_path}")
+        logger.trace("Loading plugin at #{plugin_path}")
         contents << IO.read(plugin_path)
       rescue IOError, Errno::ENOENT
-        Ohai::Log.warn("Unable to open or read plugin at #{plugin_path}")
+        logger.warn("Unable to open or read plugin at #{plugin_path}")
         return nil
       end
 
@@ -132,12 +119,10 @@ module Ohai
       if contents.include?("Ohai.plugin")
         load_v7_plugin_class(contents, plugin_path)
       else
-        Ohai::Log.warn("[DEPRECATION] Plugin at #{plugin_path} is a version 6 plugin. \
-Version 6 plugins will not be supported in Chef/Ohai 14. \
-Please upgrade your plugin to version 7 plugin format. \
-For more information visit here: docs.chef.io/ohai_custom.html")
-
-        load_v6_plugin_class(contents, plugin_path, plugin_dir_path)
+        raise Exceptions::IllegalPluginDefinition, "[DEPRECATION] Plugin at #{plugin_path}"\
+        " is a version 6 plugin. Version 6 plugins are no longer supported by Ohai. This"\
+        " plugin will need to be updated to the v7 Ohai plugin format. See"\
+        " https://docs.chef.io/ohai_custom.html for v7 syntax."
       end
     end
 
@@ -148,62 +133,28 @@ For more information visit here: docs.chef.io/ohai_custom.html")
       @controller.provides_map.set_providers_for(plugin, plugin_provides)
     end
 
-    def v6_dependency_solver
-      @controller.v6_dependency_solver
-    end
-
-    def collect_v6_plugins
-      @v6_plugin_classes.each do |plugin_spec|
-        plugin = load_v6_plugin(plugin_spec.plugin_class, plugin_spec.plugin_path, plugin_spec.plugin_dir_path)
-        loaded_v6_plugin(plugin, plugin_spec.plugin_path, plugin_spec.plugin_dir_path)
-      end
-    end
-
     def collect_v7_plugins
       @v7_plugin_classes.each do |plugin_class|
         load_v7_plugin(plugin_class)
       end
     end
 
-    def load_v6_plugin_class(contents, plugin_path, plugin_dir_path)
-      plugin_class = Class.new(Ohai::DSL::Plugin::VersionVI) { collect_contents(contents) }
-      @v6_plugin_classes << V6PluginClass.new(plugin_class, plugin_path, plugin_dir_path)
-      plugin_class
-    end
-
-    def load_v6_plugin(plugin_class, plugin_path, plugin_dir_path)
-      plugin_class.new(@controller, plugin_path, plugin_dir_path)
-    end
-
-    # Capture the plugin in @v6_dependency_solver if it is a V6 plugin
-    # to be able to resolve V6 dependencies later on.
-    # We are using the partial path in the dep solver as a key.
-    def loaded_v6_plugin(plugin, plugin_file_path, plugin_dir_path)
-      partial_path = Pathname.new(plugin_file_path).relative_path_from(Pathname.new(plugin_dir_path)).to_s
-
-      unless v6_dependency_solver.has_key?(partial_path)
-        v6_dependency_solver[partial_path] = plugin
-      else
-        Ohai::Log.debug("Plugin '#{plugin_file_path}' is already loaded.")
-      end
-    end
-
     def load_v7_plugin_class(contents, plugin_path)
-      plugin_class = eval(contents, TOPLEVEL_BINDING, plugin_path)
+      plugin_class = eval(contents, TOPLEVEL_BINDING, plugin_path) # rubocop: disable Security/Eval
       unless plugin_class.kind_of?(Class) && plugin_class < Ohai::DSL::Plugin
         raise Ohai::Exceptions::IllegalPluginDefinition, "Plugin file cannot contain any statements after the plugin definition"
       end
       plugin_class.sources << plugin_path
       @v7_plugin_classes << plugin_class unless @v7_plugin_classes.include?(plugin_class)
       plugin_class
-    rescue SystemExit, Interrupt
+    rescue SystemExit, Interrupt # rubocop: disable Lint/ShadowedException
       raise
     rescue Ohai::Exceptions::InvalidPluginName => e
-      Ohai::Log.warn("Plugin Name Error: <#{plugin_path}>: #{e.message}")
+      logger.warn("Plugin Name Error: <#{plugin_path}>: #{e.message}")
     rescue Ohai::Exceptions::IllegalPluginDefinition => e
-      Ohai::Log.warn("Plugin Definition Error: <#{plugin_path}>: #{e.message}")
+      logger.warn("Plugin Definition Error: <#{plugin_path}>: #{e.message}")
     rescue NoMethodError => e
-      Ohai::Log.warn("Plugin Method Error: <#{plugin_path}>: unsupported operation \'#{e.name}\'")
+      logger.warn("Plugin Method Error: <#{plugin_path}>: unsupported operation \'#{e.name}\'")
     rescue SyntaxError => e
       # split on occurrences of
       #    <env>: syntax error,
@@ -212,15 +163,15 @@ For more information visit here: docs.chef.io/ohai_custom.html")
       parts = e.message.split(/<.*>[:[0-9]+]*: syntax error, /)
       parts.each do |part|
         next if part.length == 0
-        Ohai::Log.warn("Plugin Syntax Error: <#{plugin_path}>: #{part}")
+        logger.warn("Plugin Syntax Error: <#{plugin_path}>: #{part}")
       end
     rescue Exception, Errno::ENOENT => e
-      Ohai::Log.warn("Plugin Error: <#{plugin_path}>: #{e.message}")
-      Ohai::Log.debug("Plugin Error: <#{plugin_path}>: #{e.inspect}, #{e.backtrace.join('\n')}")
+      logger.warn("Plugin Error: <#{plugin_path}>: #{e.message}")
+      logger.trace("Plugin Error: <#{plugin_path}>: #{e.inspect}, #{e.backtrace.join('\n')}")
     end
 
     def load_v7_plugin(plugin_class)
-      plugin = plugin_class.new(@controller.data)
+      plugin = plugin_class.new(@controller.data, @controller.logger)
       collect_provides(plugin)
       plugin
     end

data/lib/ohai/log.rb

@@ -25,7 +25,7 @@ module Ohai
     # this class loading initalization is so that we don't lose early logger
     # messages when run from the CLI?
     init(STDERR)
-    level = :info
+    level = :info # rubocop:disable Lint/UselessAssignment
 
   end
 end

data/lib/ohai/mixin/azure_metadata.rb

@@ -28,11 +28,11 @@ module Ohai
       def http_get(uri)
         conn = Net::HTTP.start(AZURE_METADATA_ADDR)
         conn.read_timeout = 6
-        conn.get(uri, initheader = { "Metadata" => "true" })
+        conn.get(uri, { "Metadata" => "true" })
       end
 
       def fetch_metadata
-        Ohai::Log.debug("Mixin AzureMetadata: Fetching metadata from host #{AZURE_METADATA_ADDR} at #{AZURE_METADATA_URL}")
+        logger.trace("Mixin AzureMetadata: Fetching metadata from host #{AZURE_METADATA_ADDR} at #{AZURE_METADATA_URL}")
         response = http_get(AZURE_METADATA_URL)
         if response.code == "200"
           begin
@@ -40,11 +40,11 @@ module Ohai
             parser = FFI_Yajl::Parser.new
             parser.parse(data)
           rescue FFI_Yajl::ParseError
-            Ohai::Log.warn("Mixin AzureMetadata: Metadata response is NOT valid JSON")
+            logger.warn("Mixin AzureMetadata: Metadata response is NOT valid JSON")
             nil
           end
         else
-          Ohai::Log.warn("Mixin AzureMetadata: Received response code #{response.code} requesting metadata")
+          logger.warn("Mixin AzureMetadata: Received response code #{response.code} requesting metadata")
           nil
         end
       end

data/lib/ohai/mixin/command.rb

@@ -37,13 +37,13 @@ module Ohai
         so = Mixlib::ShellOut.new(cmd, options)
         begin
           so.run_command
-          Ohai::Log.debug("Plugin #{name}: ran '#{cmd}' and returned #{so.exitstatus}")
+          logger.trace("Plugin #{name}: ran '#{cmd}' and returned #{so.exitstatus}")
           so
         rescue Errno::ENOENT => e
-          Ohai::Log.debug("Plugin #{name}: ran '#{cmd}' and failed #{e.inspect}")
+          logger.trace("Plugin #{name}: ran '#{cmd}' and failed #{e.inspect}")
           raise Ohai::Exceptions::Exec, e
         rescue Mixlib::ShellOut::CommandTimeout => e
-          Ohai::Log.debug("Plugin #{name}: ran '#{cmd}' and timed out after #{options[:timeout]} seconds")
+          logger.trace("Plugin #{name}: ran '#{cmd}' and timed out after #{options[:timeout]} seconds")
           raise Ohai::Exceptions::Exec, e
         end
       end

data/lib/ohai/mixin/dmi_decode.rb

@@ -44,8 +44,6 @@ module ::Ohai::Mixin::DmiDecode
         return "bhyve"
       when /Manufacturer: Veertu/
         return "veertu"
-      when /Manufacturer: Amazon EC2/
-        return "amazonec2"
       end
     end
     nil

data/lib/ohai/mixin/do_metadata.rb

@@ -35,7 +35,7 @@ module Ohai
           parser = FFI_Yajl::Parser.new
           parser.parse(response.body)
         when "404"
-          Ohai::Log.debug("Mixin DOMetadata: Encountered 404 response retrieving Digital Ocean metadata: #{uri} ; continuing.")
+          logger.trace("Mixin DOMetadata: Encountered 404 response retrieving Digital Ocean metadata: #{uri} ; continuing.")
           {}
         else
           raise "Mixin DOMetadata: Encountered error retrieving Digital Ocean metadata (#{uri} returned #{response.code} response)"

data/lib/ohai/mixin/ec2_metadata.rb

@@ -43,16 +43,16 @@ module Ohai
       EC2_SUPPORTED_VERSIONS = %w{ 1.0 2007-01-19 2007-03-01 2007-08-29 2007-10-10 2007-12-15
                                    2008-02-01 2008-09-01 2009-04-04 2011-01-01 2011-05-01 2012-01-12
                                    2014-02-25 2014-11-05 2015-10-20 2016-04-19 2016-06-30 2016-09-02 }
-      EC2_ARRAY_VALUES = %w{security-groups}
+      EC2_ARRAY_VALUES = %w{security-groups local_ipv4s}
       EC2_ARRAY_DIR    = %w{network/interfaces/macs}
       EC2_JSON_DIR     = %w{iam}
 
       def best_api_version
         @api_version ||= begin
-          Ohai::Log.debug("Mixin EC2: Fetching http://#{EC2_METADATA_ADDR}/ to determine the latest supported metadata release")
+          logger.trace("Mixin EC2: Fetching http://#{EC2_METADATA_ADDR}/ to determine the latest supported metadata release")
           response = http_client.get("/")
           if response.code == "404"
-            Ohai::Log.debug("Mixin EC2: Received HTTP 404 from metadata server while determining API version, assuming 'latest'")
+            logger.trace("Mixin EC2: Received HTTP 404 from metadata server while determining API version, assuming 'latest'")
             return "latest"
           elsif response.code != "200"
             raise "Mixin EC2: Unable to determine EC2 metadata version (returned #{response.code} response)"
@@ -62,9 +62,9 @@ module Ohai
           versions = response.body.split("\n").sort
           until versions.empty? || EC2_SUPPORTED_VERSIONS.include?(versions.last)
             pv = versions.pop
-            Ohai::Log.debug("Mixin EC2: EC2 lists metadata version: #{pv} not yet supported by Ohai") unless pv == "latest"
+            logger.trace("Mixin EC2: EC2 lists metadata version: #{pv} not yet supported by Ohai") unless pv == "latest"
           end
-          Ohai::Log.debug("Mixin EC2: Latest supported EC2 metadata version: #{versions.last}")
+          logger.trace("Mixin EC2: Latest supported EC2 metadata version: #{versions.last}")
           if versions.empty?
             raise "Mixin EC2: Unable to determine EC2 metadata version (no supported entries found)"
           end
@@ -88,13 +88,13 @@ module Ohai
       #   `nil` and continue the run instead of failing it.
       def metadata_get(id, api_version)
         path = "/#{api_version}/meta-data/#{id}"
-        Ohai::Log.debug("Mixin EC2: Fetching http://#{EC2_METADATA_ADDR}#{path}")
+        logger.trace("Mixin EC2: Fetching http://#{EC2_METADATA_ADDR}#{path}")
         response = http_client.get(path)
         case response.code
         when "200"
           response.body
         when "404"
-          Ohai::Log.debug("Mixin EC2: Encountered 404 response retrieving EC2 metadata path: #{path} ; continuing.")
+          logger.trace("Mixin EC2: Encountered 404 response retrieving EC2 metadata path: #{path} ; continuing.")
           nil
         else
           raise "Mixin EC2: Encountered error retrieving EC2 metadata (#{path} returned #{response.code} response)"
@@ -169,7 +169,7 @@ module Ohai
       end
 
       def fetch_userdata
-        Ohai::Log.debug("Mixin EC2: Fetching http://#{EC2_METADATA_ADDR}/#{best_api_version}/user-data/")
+        logger.trace("Mixin EC2: Fetching http://#{EC2_METADATA_ADDR}/#{best_api_version}/user-data/")
         response = http_client.get("/#{best_api_version}/user-data/")
         response.code == "200" ? response.body : nil
       end

data/lib/ohai/mixin/gce_metadata.rb

@@ -28,11 +28,7 @@ module Ohai
       def http_get(uri)
         conn = Net::HTTP.start(GCE_METADATA_ADDR)
         conn.read_timeout = 6
-        conn.get(uri, {
-                        "Metadata-Flavor" => "Google",
-                        "User-Agent" => "chef-ohai/#{Ohai::VERSION}",
-                      }
-                )
+        conn.get(uri, { "Metadata-Flavor" => "Google" })
       end
 
       def fetch_metadata(id = "")

data/lib/ohai/mixin/http_helper.rb

@@ -25,7 +25,7 @@ module Ohai
         begin
           saddr = Socket.pack_sockaddr_in(port, addr)
         rescue SocketError => e # generally means dns resolution error
-          Ohai::Log.debug("Mixin HttpHelper: can_socket_connect? failed setting up socket connection: #{e}")
+          logger.trace("Mixin HttpHelper: can_socket_connect? failed setting up socket connection: #{e}")
           return false
         end
 
@@ -34,7 +34,7 @@ module Ohai
         begin
           t.connect_nonblock(saddr)
         rescue Errno::EINPROGRESS
-          r, w, e = IO.select(nil, [t], nil, timeout)
+          _r, w, _e = IO.select(nil, [t], nil, timeout)
           if !w.nil?
             connected = true
           else
@@ -48,7 +48,7 @@ module Ohai
           end
         rescue SystemCallError
         end
-        Ohai::Log.debug("Mixin HttpHelper: can_socket_connect? == #{connected}")
+        logger.trace("Mixin HttpHelper: can_socket_connect? == #{connected}")
         connected
       end
     end

data/lib/ohai/mixin/scaleway_metadata.rb

@@ -0,0 +1,46 @@
+#
+# Author:: Jonathan Amiez (<jonathan.amiez@gmail.com>)
+# 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"
+
+module Ohai
+  module Mixin
+    module ScalewayMetadata
+
+      SCALEWAY_METADATA_ADDR = "169.254.42.42" unless defined?(SCALEWAY_METADATA_ADDR)
+      SCALEWAY_METADATA_URL = "/conf?format=json" unless defined?(SCALEWAY_METADATA_URL)
+
+      def http_client
+        Net::HTTP.start(SCALEWAY_METADATA_ADDR).tap { |h| h.read_timeout = 6 }
+      end
+
+      def fetch_metadata
+        uri = "#{SCALEWAY_METADATA_URL}"
+        response = http_client.get(uri)
+        case response.code
+        when "200"
+          parser = FFI_Yajl::Parser.new
+          parser.parse(response.body)
+        when "404"
+          logger.trace("Mixin ScalewayMetadata: Encountered 404 response retrieving Scaleway metadata: #{uri} ; continuing.")
+          {}
+        else
+          raise "Mixin ScalewayMetadata: Encountered error retrieving Scaleway metadata (#{uri} returned #{response.code} response)"
+        end
+      end
+    end
+  end
+end

data/lib/ohai/mixin/softlayer_metadata.rb

@@ -25,7 +25,7 @@ module ::Ohai::Mixin::SoftlayerMetadata
   SOFTLAYER_API_QUERY_URL = "https://api.service.softlayer.com/rest/v3.1/SoftLayer_Resource_Metadata" unless defined?(SOFTLAYER_API_QUERY_URL)
 
   def fetch_metadata
-    metadata = {
+    {
       "public_fqdn"   => fetch_metadata_item("getFullyQualifiedDomainName.txt"),
       "local_ipv4"    => fetch_metadata_item("getPrimaryBackendIpAddress.txt"),
       "public_ipv4"   => fetch_metadata_item("getPrimaryIpAddress.txt"),
@@ -54,11 +54,11 @@ module ::Ohai::Mixin::SoftlayerMetadata
     if res.code.to_i.between?(200, 299)
       res.body
     else
-      ::Ohai::Log.error("Mixin Softlayer: Unable to fetch item #{full_url}: status (#{res.code}) body (#{res.body})")
+      logger.error("Mixin Softlayer: Unable to fetch item #{full_url}: status (#{res.code}) body (#{res.body})")
       nil
     end
   rescue => e
-    ::Ohai::Log.error("Mixin Softlayer: Unable to fetch softlayer metadata from #{u}: #{e.class}: #{e.message}")
+    logger.error("Mixin Softlayer: Unable to fetch softlayer metadata from #{u}: #{e.class}: #{e.message}")
     raise e
   end
 end

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

@@ -59,7 +59,7 @@ Ohai.plugin(:Filesystem) do
       else
         key = fields[0] + ":" + fields[1]
         oldie[key] ||= Mash.new
-        oldie[key][:mount] = fields[2]
+        oldie[key][:mount] = fields[1]
         oldie[key][:fs_type] = fields[3]
         oldie[key][:mount_options] = fields[7].split(",")
       end

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

@@ -25,7 +25,7 @@ Ohai.plugin(:Memory) do
     memory[:swap] = Mash.new
 
     meminfo = shell_out("svmon -G -O unit=MB,summary=longreal | grep '[0-9]'").stdout
-    total_in_mb, u, free_in_mb = meminfo.split
+    total_in_mb, _u, free_in_mb = meminfo.split
     memory[:total] = "#{total_in_mb.to_i * 1024}kB"
     memory[:free] = "#{free_in_mb.to_i * 1024}kB"