ohai 8.26.1 → 13.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 45d066cc35bc83eb5adba2d23ebc9a4e39451d072a6e1fda5e53a68c50741246
-  data.tar.gz: 78bd290648898961bc06912973654fad4e75c374f837998dfb0cb018c9c66fe4
+SHA1:
+  metadata.gz: 436fe05bd654044a382621b353229fc436bc3a4c
+  data.tar.gz: a785069184b37a9a057e061da997d47d55c1e161
 SHA512:
-  metadata.gz: e4f8708b309cc4d5b8fd7ae63a09c2ea07b0fa6e878c03abfea9b1628c39fb26875b4bb3bad8d3713c55a17cdc310d30fe01ac40cbd8b3cf8e42d63993b29167
-  data.tar.gz: 8a114eb384b9561d749117610a675e630b94d5beae99de7633495eb944b429b096a70664427136f6dfc11ad94759869d21910b67a9311a42c4df81d47bca24ab
+  metadata.gz: 334239f6d9138eda450ad1fac4bb8da0439b290dfa1d2551377bf37dcd082778f121cbdb5f4398a936bb98670cb030bbe22bea952cd8fa4216bba06a0b18360e
+  data.tar.gz: ea555c1670d775894b74c3b3b5a677e4b69c9097b121e518d1c50c5b7c3dc3dc2a4134bba7f28e1894137865131decf22f4d443d7adfa6b6207ec8301dfd19ac

data/Gemfile

@@ -3,9 +3,7 @@ source "https://rubygems.org"
 gemspec
 
 group :development do
-  gem "sigar", :platform => "ruby"
-
-  gem "chefstyle", "0.4.0"
+  gem "chefstyle"
   gem "overcommit", ">= 0.34.1"
   gem "pry-byebug"
   gem "pry-stack_explorer"
@@ -16,5 +14,6 @@ group :development do
   gem "rspec-mocks", "~> 3.0"
   gem "rspec-collection_matchers", "~> 1.0"
   gem "rspec_junit_formatter"
-  gem "activesupport", "< 5.0" if RUBY_VERSION <= "2.2.2" # github_changelog_generator dep
+  gem "github_changelog_generator", git: "https://github.com/tduffield/github-changelog-generator", branch: "adjust-tag-section-mapping"
+  gem "ipaddr_extensions"
 end

data/Rakefile

@@ -22,3 +22,17 @@ require "rubocop/rake_task"
 RuboCop::RakeTask.new(:style) do |task|
   task.options += ["--display-cop-names", "--no-color"]
 end
+
+begin
+  require "github_changelog_generator/task"
+
+  GitHubChangelogGenerator::RakeTask.new :changelog do |config|
+    config.future_release = Ohai::VERSION
+    config.max_issues = 0
+    config.add_issues_wo_labels = false
+    config.enhancement_labels = "enhancement,Enhancement,New Feature,Feature".split(",")
+    config.bug_labels = "bug,Bug,Improvement,Upstream Bug".split(",")
+    config.exclude_labels = "duplicate,question,invalid,wontfix,no_changelog,Exclude From Changelog,Question,Discussion".split(",")
+  end
+rescue LoadError
+end

data/lib/ohai/application.rb

@@ -88,6 +88,7 @@ class Ohai::Application
   end
 
   def run_application
+    config[:invoked_from_cli] = true
     ohai = Ohai::System.new(config)
     ohai.all_plugins(@attributes)
 

data/lib/ohai/config.rb

@@ -19,7 +19,6 @@
 
 require "chef-config/config"
 require "ohai/exception"
-require "ohai/log"
 require "ohai/plugin_config"
 
 module Ohai
@@ -28,99 +27,14 @@ module Ohai
   # Reopens ChefConfig::Config to add Ohai configuration settings.
   # see: https://github.com/chef/chef/blob/master/lib/chef/config.rb
   class Config
-    # These methods need to be defined before they are used as config defaults,
-    # otherwise they will get method_missing'd to nil.
-
-    class << self
-      def merge_deprecated_config
-        [ :hints_path, :plugin_path ].each do |option|
-          if has_key?(option) && send(option) != send("default_#{option}".to_sym)
-            Ohai::Log.warn(option_deprecated(option))
-          end
-        end
-
-        ohai.merge!(configuration)
-      end
-
-      def default_hints_path
-        [ ChefConfig::Config.platform_specific_path("/etc/chef/ohai/hints") ]
-      end
-
-      def default_plugin_path
-        [ File.expand_path(File.join(File.dirname(__FILE__), "plugins")), ChefConfig::Config.platform_specific_path("/etc/chef/ohai/plugins") ]
-      end
-    end
-
-    # Copy deprecated configuration options into the ohai config context.
-
-    # Keep "old" config defaults around so anyone calling Ohai::Config[:key]
-    # won't be broken. Also allows users to append to configuration options
-    # (e.g., Ohai::Config[:plugin_path] << some_path) in their config files.
-    default :disabled_plugins, []
-    default :hints_path, default_hints_path
-    default :log_level, :auto
-    default :log_location, STDERR
-    default :plugin_path, default_plugin_path
-
-    # Log deprecation warning when a top-level configuration option is set.
-    # TODO: Should we implement a config_attr_reader so that deprecation
-    # warnings will be generatd on read?
-    [
-      :directory,
-      :disabled_plugins,
-      :log_level,
-      :log_location,
-      :version,
-    ].each do |option|
-      # https://docs.chef.io/config_rb_client.html#ohai-settings
-      # hints_path and plugin_path are intentionally excluded here; warnings for
-      # setting these attributes are generated in merge_deprecated_config since
-      # append (<<) operations bypass the config writer.
-      config_attr_writer option do |value|
-        # log_level and log_location are common configuration options for chef
-        # and other chef applications. When configuration files are read there
-        # is no distinction between log_level and Ohai::Config[:log_level] and
-        # we may emit a false deprecation warning. The deprecation warnings for
-        # these settings reflect that possibility.
-        # Furthermore, when the top-level config settings are removed we will
-        # need to ensure that Ohai.config[:log_level] can be set by writing
-        # log_level in a configuration file for consistent behavior with chef.
-        deprecation_warning = if [ :log_level, :log_location ].include?(value)
-                                option_might_be_deprecated(option)
-                              else
-                                option_deprecated(option)
-                              end
-        Ohai::Log.warn(deprecation_warning)
-        value
-      end
-    end
 
     config_context :ohai do
       default :disabled_plugins, []
-      default :hints_path, Ohai::Config.default_hints_path
+      default :hints_path, [ ChefConfig::Config.platform_specific_path("/etc/chef/ohai/hints") ]
       default :log_level, :auto
       default :log_location, STDERR
       default :plugin, Ohai::PluginConfig.new { |h, k| h[k] = Ohai::PluginConfig.new }
-      default :plugin_path, Ohai::Config.default_plugin_path
-      default :critical_plugins, []
-    end
-
-    class << self
-      def option_deprecated(option)
-        <<-EOM.chomp!.tr("\n", " ")
-Ohai::Config[:#{option}] is set. Ohai::Config[:#{option}] is deprecated and will
-be removed in future releases of ohai. Use ohai.#{option} in your configuration
-file to configure :#{option} for ohai.
-        EOM
-      end
-
-      def option_might_be_deprecated(option)
-        option_deprecated(option) + <<-EOM.chomp!.tr("\n", " ")
- If your configuration file is used with other applications which configure
-:#{option}, and you have not configured Ohai::Config[:#{option}], you may
-disregard this warning.
-        EOM
-      end
+      default :plugin_path, [ File.expand_path(File.join(File.dirname(__FILE__), "plugins")), ChefConfig::Config.platform_specific_path("/etc/chef/ohai/plugins") ]
     end
   end
 

data/lib/ohai/dsl/plugin.rb

@@ -85,12 +85,10 @@ module Ohai
       include Ohai::Util::FileHelper
 
       attr_reader :data
-      attr_reader :failed
 
       def initialize(data)
         @data = data
         @has_run = false
-        @failed = false
       end
 
       def run
@@ -185,10 +183,8 @@ module Ohai
         begin
           self.run
         rescue Ohai::Exceptions::Error => e
-          @failed = true
           raise e
         rescue => e
-          @failed = true
           Ohai::Log.debug("Plugin #{self.name} threw #{e.inspect}")
           e.backtrace.each { |line| Ohai::Log.debug( line ) }
         end

data/lib/ohai/exception.rb

@@ -29,6 +29,5 @@ module Ohai
     class DependencyNotFound < Error; end
     class AttributeSyntaxError < Error; end
     class PluginConfigError < Error; end
-    class CriticalPluginFailure < Error; end
   end
 end

data/lib/ohai/loader.rb

@@ -70,8 +70,8 @@ module Ohai
 
     # Searches all plugin paths and returns an Array of PluginFile objects
     # representing each plugin file.
-    def plugin_files_by_dir
-      Array(Ohai.config[:plugin_path]).inject([]) do |plugin_files, plugin_path|
+    def plugin_files_by_dir(dir = Ohai.config[:plugin_path])
+      Array(dir).inject([]) do |plugin_files, plugin_path|
         plugin_files + PluginFile.find_all_in(plugin_path)
       end
     end
@@ -85,6 +85,15 @@ module Ohai
       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}"
+        plugin = load_plugin_class(plugin_file.path, plugin_file.plugin_root)
+        load_v7_plugin(plugin)
+      end
+    end
+
     # 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.

data/lib/ohai/log.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright (c) 2008-2016 Chef Software, Inc.
+# Copyright:: Copyright (c) 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,6 +22,8 @@ module Ohai
   class Log
     extend Mixlib::Log
 
+    # this class loading initalization is so that we don't lose early logger
+    # messages when run from the CLI?
     init(STDERR)
     level = :info
 

data/lib/ohai/mixin/command.rb

@@ -1,5 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Tim Smith (<tsmith@chef.io>)
 # Copyright:: Copyright (c) 2008-2016 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -17,12 +18,7 @@
 #
 
 require "ohai/exception"
-require "ohai/config"
 require "ohai/log"
-require "stringio"
-require "tmpdir"
-require "fcntl"
-require "etc"
 require "mixlib/shellout"
 
 module Ohai
@@ -48,319 +44,6 @@ module Ohai
       end
 
       module_function :shell_out
-
-      def run_command(args = {})
-        Ohai::Log.warn("Ohai::Mixin::Command run_command is deprecated and will be removed in Ohai 9.0.0")
-        if args.has_key?(:creates)
-          if File.exists?(args[:creates])
-            Ohai::Log.debug("Skipping #{args[:command]} - creates #{args[:creates]} exists.")
-            return false
-          end
-        end
-
-        stdout_string = nil
-        stderr_string = nil
-
-        args[:cwd] ||= Dir.tmpdir
-        unless File.directory?(args[:cwd])
-          raise Ohai::Exceptions::Exec, "#{args[:cwd]} does not exist or is not a directory"
-        end
-
-        status = nil
-        Dir.chdir(args[:cwd]) do
-          status, stdout_string, stderr_string = run_command_backend(args[:command], args[:timeout])
-
-          if stdout_string
-            Ohai::Log.debug("---- Begin #{args[:command]} STDOUT ----")
-            Ohai::Log.debug(stdout_string.strip)
-            Ohai::Log.debug("---- End #{args[:command]} STDOUT ----")
-          end
-          if stderr_string
-            Ohai::Log.debug("---- Begin #{args[:command]} STDERR ----")
-            Ohai::Log.debug(stderr_string.strip)
-            Ohai::Log.debug("---- End #{args[:command]} STDERR ----")
-          end
-
-          args[:returns] ||= 0
-          args[:no_status_check] ||= false
-          if status.exitstatus != args[:returns] && (not args[:no_status_check])
-            raise Ohai::Exceptions::Exec, "#{args[:command_string]} returned #{status.exitstatus}, expected #{args[:returns]}"
-          else
-            Ohai::Log.debug("Ran #{args[:command_string]} (#{args[:command]}) returned #{status.exitstatus}")
-          end
-        end
-        return status, stdout_string, stderr_string
-      end
-
-      module_function :run_command
-
-      def run_command_unix(command, timeout)
-        stderr_string, stdout_string, status = "", "", nil
-
-        exec_processing_block = lambda do |pid, stdin, stdout, stderr|
-          stdout_string, stderr_string = stdout.string.chomp, stderr.string.chomp
-        end
-
-        if timeout
-          begin
-            Timeout.timeout(timeout) do
-              status = popen4(command, {}, &exec_processing_block)
-            end
-          rescue Timeout::Error => e
-            Chef::Log.error("#{command} exceeded timeout #{timeout}")
-            raise(e)
-          end
-        else
-          status = popen4(command, {}, &exec_processing_block)
-        end
-        return status, stdout_string, stderr_string
-      end
-
-      def run_command_windows(command, timeout)
-        shellout_opts = {}
-        shellout_opts[:timeout] = timeout if timeout
-
-        m = Mixlib::ShellOut.new(command, shellout_opts)
-        m.run_command
-        [m.status, m.stdout, m.stderr]
-      end
-
-      if RUBY_PLATFORM =~ /mswin|mingw32|windows/
-        alias :run_command_backend :run_command_windows
-      else
-        alias :run_command_backend :run_command_unix
-      end
-      # This is taken directly from Ara T Howard's Open4 library, and then
-      # modified to suit the needs of Ohai.  Any bugs here are most likely
-      # my own, and not Ara's.
-      #
-      # The original appears in external/open4.rb in its unmodified form.
-      #
-      # Thanks Ara!
-      def popen4(cmd, args = {}, &b)
-        Ohai::Log.warn("Ohai::Mixin::Command popen4 is deprecated and will be removed in Ohai 9.0.0")
-
-        # Disable garbage collection to work around possible bug in MRI
-        # Ruby 1.8 suffers from intermittent segfaults believed to be due to GC while IO.select
-        # See OHAI-330 / CHEF-2916 / CHEF-1305
-        GC.disable
-
-        # Waitlast - this is magic.
-        #
-        # Do we wait for the child process to die before we yield
-        # to the block, or after?  That is the magic of waitlast.
-        #
-        # By default, we are waiting before we yield the block.
-        args[:waitlast] ||= false
-
-        args[:user] ||= nil
-        unless args[:user].kind_of?(Integer)
-          args[:user] = Etc.getpwnam(args[:user]).uid if args[:user]
-        end
-        args[:group] ||= nil
-        unless args[:group].kind_of?(Integer)
-          args[:group] = Etc.getgrnam(args[:group]).gid if args[:group]
-        end
-        args[:environment] ||= {}
-
-        # Default on C locale so parsing commands output can be done
-        # independently of the node's default locale.
-        # "LC_ALL" could be set to nil, in which case we also must ignore it.
-        unless args[:environment].has_key?("LC_ALL")
-          args[:environment]["LC_ALL"] = "C"
-        end
-
-        pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
-
-        verbose = $VERBOSE
-        begin
-          $VERBOSE = nil
-          ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-
-          cid = fork do
-            Process.setsid
-
-            pw.last.close
-            STDIN.reopen pw.first
-            pw.first.close
-
-            pr.first.close
-            STDOUT.reopen pr.last
-            pr.last.close
-
-            pe.first.close
-            STDERR.reopen pe.last
-            pe.last.close
-
-            STDOUT.sync = STDERR.sync = true
-
-            if args[:group]
-              Process.egid = args[:group]
-              Process.gid = args[:group]
-            end
-
-            if args[:user]
-              Process.euid = args[:user]
-              Process.uid = args[:user]
-            end
-
-            args[:environment].each do |key, value|
-              ENV[key] = value
-            end
-
-            if args[:umask]
-              umask = ((args[:umask].respond_to?(:oct) ? args[:umask].oct : args[:umask].to_i) & 007777)
-              File.umask(umask)
-            end
-
-            begin
-              if cmd.kind_of?(Array)
-                exec(*cmd)
-              else
-                exec(cmd)
-              end
-              raise "forty-two"
-            rescue Exception => e
-              Marshal.dump(e, ps.last)
-              ps.last.flush
-            end
-            ps.last.close unless ps.last.closed?
-            exit!
-          end
-        ensure
-          $VERBOSE = verbose
-        end
-
-        [pw.first, pr.last, pe.last, ps.last].each { |fd| fd.close }
-
-        begin
-          e = Marshal.load ps.first
-          pw.last.close
-          pr.first.close
-          pe.first.close
-          Process.wait(cid)
-          raise(Exception === e ? e : "unknown failure!")
-        rescue EOFError # If we get an EOF error, then the exec was successful
-          42
-        ensure
-          ps.first.close
-        end
-
-        pw.last.sync = true
-
-        pi = [pw.last, pr.first, pe.first]
-
-        if b
-          begin
-            if args[:waitlast]
-              b[cid, *pi]
-              # send EOF so that if the child process is reading from STDIN
-              # it will actually finish up and exit
-              pi[0].close_write
-              Process.waitpid2(cid).last
-            else
-              # This took some doing.
-              # The trick here is to close STDIN
-              # Then set our end of the childs pipes to be O_NONBLOCK
-              # Then wait for the child to die, which means any IO it
-              # wants to do must be done - it's dead.  If it isn't,
-              # it's because something totally skanky is happening,
-              # and we don't care.
-              o = StringIO.new
-              e = StringIO.new
-
-              #pi[0].close
-
-              stdout = pi[1]
-              stderr = pi[2]
-
-              stdout.sync = true
-              stderr.sync = true
-
-              stdout.fcntl(Fcntl::F_SETFL, pi[1].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
-              stderr.fcntl(Fcntl::F_SETFL, pi[2].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
-
-              stdout_finished = false
-              stderr_finished = false
-
-              results = nil
-
-              while !stdout_finished || !stderr_finished
-                begin
-                  channels_to_watch = []
-                  channels_to_watch << stdout if !stdout_finished
-                  channels_to_watch << stderr if !stderr_finished
-                  ready = IO.select(channels_to_watch, nil, nil, 1.0)
-                rescue Errno::EAGAIN
-                ensure
-                  results = Process.waitpid2(cid, Process::WNOHANG)
-                  if results
-                    stdout_finished = true
-                    stderr_finished = true
-                  end
-                end
-
-                if ready && ready.first.include?(stdout)
-                  line = results ? stdout.gets(nil) : stdout.gets
-                  if line
-                    o.write(line)
-                  else
-                    stdout_finished = true
-                  end
-                end
-                if ready && ready.first.include?(stderr)
-                  line = results ? stderr.gets(nil) : stderr.gets
-                  if line
-                    e.write(line)
-                  else
-                    stderr_finished = true
-                  end
-                end
-              end
-              results = Process.waitpid2(cid) unless results
-              o.rewind
-              e.rewind
-
-              # **OHAI-275**
-              # The way we read from the pipes causes ruby to mark the strings
-              # as ASCII-8BIT (i.e., binary), but the content should be encoded
-              # as the default external encoding. For example, a command may
-              # return data encoded as UTF-8, but the strings will be marked as
-              # ASCII-8BIT. Later, when you attempt to print the values as
-              # UTF-8, Ruby will try to convert them and fail, raising an
-              # error.
-              #
-              # Ruby always marks strings as binary when read from IO in
-              # incomplete chunks, since you may have split the data within a
-              # multibyte char. In our case, we concat the chunks back
-              # together, so any multibyte chars will be reassembled.
-              #
-              # Note that all of this applies only to Ruby 1.9, which we check
-              # for by making sure that the Encoding class exists and strings
-              # have encoding methods.
-              if "".respond_to?(:force_encoding) && defined?(Encoding)
-                o.string.force_encoding(Encoding.default_external)
-                o.string.encode!("UTF-8", :invalid => :replace, :undef => :replace, :replace => "?")
-                e.string.force_encoding(Encoding.default_external)
-                e.string.encode!("UTF-8", :invalid => :replace, :undef => :replace, :replace => "?")
-              end
-              b[cid, pi[0], o, e]
-              results.last
-            end
-          ensure
-            pi.each { |fd| fd.close unless fd.closed? }
-          end
-        else
-          [cid, pw.last, pr.first, pe.first]
-        end
-      rescue Errno::ENOENT
-        raise Ohai::Exceptions::Exec, "command #{cmd} doesn't exist or is not in the PATH"
-      ensure
-        # we disabled GC entering
-        GC.enable
-      end
-
-      module_function :popen4
     end
   end
 end