ohai 6.24.2 → 7.0.0.rc.0

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

@@ -21,7 +21,14 @@
 # Windows_NT kernel, so we herby decree that "windows" will refer to all
 # platforms built upon the Windows_NT kernel and have access to win32 or win64
 # subsystems.
-platform os
-platform_version kernel['release']
-platform_family "windows"
+
+Ohai.plugin(:Platform) do
+  provides "platform", "platform_version", "platform_family"
+
+  collect_data(:windows) do
+    platform os
+    platform_version kernel['release']
+    platform_family "windows"
+  end
+end
 

data/lib/ohai/provides_map.rb

@@ -0,0 +1,184 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'ohai/mash'
+require 'ohai/exception'
+require 'ohai/mixin/os'
+require 'ohai/dsl'
+
+module Ohai
+  class ProvidesMap
+
+    attr_reader :map
+
+    def initialize
+      @map = Mash.new
+    end
+
+    def set_providers_for(plugin, provided_attributes)
+      unless plugin.kind_of?(Ohai::DSL::Plugin)
+        raise ArgumentError, "set_providers_for only accepts Ohai Plugin classes (got: #{plugin})"
+      end
+
+      provided_attributes.each do |attribute|
+        attrs = @map
+        parts = normalize_and_validate(attribute)
+        parts.each do |part|
+          attrs[part] ||= Mash.new
+          attrs = attrs[part]
+        end
+        attrs[:_plugins] ||= []
+        attrs[:_plugins] << plugin
+      end
+    end
+
+    # gather plugins providing exactly the attributes listed
+    def find_providers_for(attributes)
+      plugins = []
+      attributes.each do |attribute|
+        attrs = select_subtree(@map, attribute)
+        raise Ohai::Exceptions::AttributeNotFound, "No such attribute: \'#{attribute}\'" unless attrs
+        raise Ohai::Exceptions::ProviderNotFound, "Cannot find plugin providing attribute: \'#{attribute}\'" unless attrs[:_plugins]
+        plugins += attrs[:_plugins]
+      end
+      plugins.uniq
+    end
+
+    # This function is used to fetch the plugins for the attributes specified
+    # in the CLI options to Ohai.
+    # It first attempts to find the plugins for the attributes
+    # or the sub attributes given.
+    # If it can't find any, it looks for plugins that might
+    # provide the parents of a given attribute and returns the
+    # first parent found.
+    def deep_find_providers_for(attributes)
+      plugins = []
+      attributes.each do |attribute|
+        attrs = select_subtree(@map, attribute)
+
+        unless attrs
+          attrs = select_closest_subtree(@map, attribute)
+
+          unless attrs
+            raise Ohai::Exceptions::AttributeNotFound, "No such attribute: \'#{attribute}\'"
+          end
+        end
+
+        collect_plugins_in(attrs, plugins)
+      end
+
+      plugins.uniq
+    end
+
+    # This function is used to fetch the plugins from
+    # 'depends "languages"' statements in plugins.
+    # It gathers plugins providing each of the attributes listed, or the
+    # plugins providing the closest parent attribute
+    def find_closest_providers_for(attributes)
+      plugins = []
+      attributes.each do |attribute|
+        parts = normalize_and_validate(attribute)
+        raise Ohai::Exceptions::AttributeNotFound, "No such attribute: \'#{attribute}\'" unless @map[parts[0]]
+        attrs = select_closest_subtree(@map, attribute)
+        raise Ohai::Exceptions::ProviderNotFound, "Cannot find plugin providing attribute: \'#{attribute}\'" unless attrs
+        plugins += attrs[:_plugins]
+      end
+      plugins.uniq
+    end
+
+    def all_plugins(attribute_filter=nil)
+      if attribute_filter.nil?
+        collected = []
+        collect_plugins_in(map, collected).uniq
+      else
+        deep_find_providers_for(Array(attribute_filter))
+      end
+    end
+
+    private
+
+    def normalize_and_validate(attribute)
+      raise Ohai::Exceptions::AttributeSyntaxError, "Attribute contains duplicate '/' characters: #{attribute}" if attribute.match(/\/\/+/)
+      raise Ohai::Exceptions::AttributeSyntaxError, "Attribute contains a trailing '/': #{attribute}" if attribute.match(/\/$/)
+
+      parts = attribute.split('/')
+      parts.shift if parts.length != 0 && parts[0].length == 0 # attribute begins with a '/'
+      parts
+    end
+
+    def select_subtree(provides_map, attribute)
+      subtree = provides_map
+      parts = normalize_and_validate(attribute)
+      parts.each do |part|
+        return nil unless subtree[part]
+        subtree = subtree[part]
+      end
+      subtree
+    end
+
+    def select_closest_subtree(provides_map, attribute)
+      attr, *rest = normalize_and_validate(attribute)
+
+      # return nil if the top-level part of the attribute is not a
+      # top-level key in the provides_map (can't search any lower, and
+      # no information to return from this level of the search)
+      return nil unless provides_map[attr]
+
+      # attr is a key in the provides_map, search for the sub
+      # attribute under attr (if attribute = attr/sub1/sub2 then we
+      # search provides_map[attr] for sub1/sub2)
+      unless rest.empty?
+        subtree = select_closest_subtree(provides_map[attr], rest.join('/'))
+      end
+
+      if subtree.nil?
+        # no subtree of provides_map[attr] either 1) has a
+        # subattribute, 2) has a plugin providing a subattribute.
+        unless provides_map[attr][:_plugins]
+          # no providers for this attribute, this subtree won't do.
+          return nil # no providers for this attribute
+        else
+          # there are providers for this attribute, return its subtree
+          # to indicate this is the closest subtree
+          return provides_map[attr]
+        end
+      end
+
+      # we've already found a closest subtree or we've search all
+      # parent attributes of the original attribute and found no
+      # providers (subtree is nil in this case)
+      subtree
+    end
+
+    # Takes a section of the map, recursively searches for a `_plugins` key
+    # to find all the plugins in that section of the map. If given the whole
+    # map, it will find all of the plugins that have at least one provided
+    # attribute.
+    def collect_plugins_in(provides_map, collected)
+      provides_map.keys.each do |plugin|
+        if plugin.eql?("_plugins")
+          collected.concat(provides_map[plugin])
+        else
+          collect_plugins_in(provides_map[plugin], collected)
+        end
+      end
+      collected
+    end
+  end
+end

data/lib/ohai/runner.rb

@@ -0,0 +1,109 @@
+#
+# Author:: Claire McQuin (<claire@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License. You may
+# obtain a copy of the license at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either expressed or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+#
+
+require 'ohai/dsl'
+
+module Ohai
+  class Runner
+
+    # safe_run: set to true if this runner will run plugins in
+    # safe-mode. default false.
+    def initialize(controller, safe_run = false)
+      @provides_map = controller.provides_map
+      @safe_run = safe_run
+    end
+
+    # Runs plugins and any un-run dependencies.
+    # If force is set to true, then this plugin and its dependencies
+    # will be run even if they have been run before.
+    def run_plugin(plugin)
+      unless plugin.kind_of?(Ohai::DSL::Plugin)
+        raise Ohai::Exceptions::InvalidPlugin, "Invalid plugin #{plugin} (must be an Ohai::DSL::Plugin or subclass)"
+      end
+
+      if Ohai::Config[:disabled_plugins].include?(plugin.name)
+        Ohai::Log.debug("Skipping disabled plugin #{plugin.name}")
+        return false
+      end
+
+      begin
+        case plugin.version
+        when :version7
+          run_v7_plugin(plugin)
+        when :version6
+          run_v6_plugin(plugin)
+        else
+          raise Ohai::Exceptions::InvalidPlugin, "Invalid plugin version #{plugin.version} for plugin #{plugin}"
+        end
+      rescue Ohai::Exceptions::Error
+        raise
+      rescue Exception,Errno::ENOENT => e
+        Ohai::Log.debug("Plugin #{plugin.name} threw exception #{e.inspect} #{e.backtrace.join("\n")}")
+      end
+    end
+
+    def run_v6_plugin(plugin)
+      return true if plugin.has_run?
+
+      @safe_run ? plugin.safe_run : plugin.run
+    end
+
+    def run_v7_plugin(plugin)
+      visited = [ plugin ]
+      while !visited.empty?
+        next_plugin = visited.pop
+
+        next if next_plugin.has_run?
+
+        if visited.include?(next_plugin)
+          raise Ohai::Exceptions::DependencyCycle, "Dependency cycle detected. Please refer to the following plugins: #{get_cycle(visited, plugin).join(", ") }"
+        end
+
+        dependency_providers = fetch_plugins(next_plugin.dependencies)
+
+        # Remove the already ran plugins from dependencies if force is not set
+        # Also remove the plugin that we are about to run from dependencies as well.
+        dependency_providers.delete_if { |dep_plugin|
+          dep_plugin.has_run? || dep_plugin.eql?(next_plugin)
+        }
+
+        if dependency_providers.empty?
+          @safe_run ? next_plugin.safe_run : next_plugin.run
+        else
+          visited << next_plugin << dependency_providers.first
+        end
+      end
+    end
+
+    def fetch_plugins(attributes)
+      @provides_map.find_closest_providers_for(attributes)
+    end
+
+    # Given a list of plugins and the first plugin in the cycle,
+    # returns the list of plugin source files responsible for the
+    # cycle. Does not include plugins that aren't a part of the cycle
+    def get_cycle(plugins, cycle_start)
+      cycle = plugins.drop_while { |plugin| !plugin.eql?(cycle_start) }
+      names = []
+      cycle.each { |plugin| names << plugin.name }
+      names
+    end
+
+  end
+end

data/lib/ohai/system.rb

@@ -16,225 +16,158 @@
 # limitations under the License.
 #
 
-require 'ohai/mash'
+require 'ohai/loader'
 require 'ohai/log'
-require 'ohai/mixin/from_file'
+require 'ohai/mash'
+require 'ohai/runner'
+require 'ohai/dsl'
 require 'ohai/mixin/command'
+require 'ohai/mixin/os'
 require 'ohai/mixin/string'
+require 'ohai/mixin/constant_helper'
+require 'ohai/provides_map'
+require 'ohai/hints'
 require 'mixlib/shellout'
 
 require 'yajl'
 
 module Ohai
   class System
-    attr_accessor :data, :seen_plugins, :hints
+    include Ohai::Mixin::ConstantHelper
 
-    include Ohai::Mixin::FromFile
-    include Ohai::Mixin::Command
+    attr_accessor :data
+    attr_reader :provides_map
+    attr_reader :v6_dependency_solver
 
     def initialize
-      @data = Mash.new
-      @seen_plugins = Hash.new
-      @providers = Mash.new
       @plugin_path = ""
-      @hints = Hash.new
-    end
-
-    def [](key)
-      @data[key]
+      reset_system
     end
 
-    def []=(key, value)
-      @data[key] = value
-    end
+    def reset_system
+      @data = Mash.new
+      @provides_map = ProvidesMap.new
 
-    def each(&block)
-      @data.each do |key, value|
-        block.call(key, value)
-      end
-    end
+      @v6_dependency_solver = Hash.new
 
-    def attribute?(name)
-      @data.has_key?(name)
-    end
+      @loader = Ohai::Loader.new(self)
+      @runner = Ohai::Runner.new(self, true)
 
-    def set(name, *value)
-      set_attribute(name, *value)
-    end
+      Ohai::Hints.refresh_hints()
 
-    def from(cmd)
-      status, stdout, stderr = run_command(:command => cmd)
-      return "" if stdout.nil? || stdout.empty?
-      stdout.strip
+      # Remove the previously defined plugins
+      recursive_remove_constants(Ohai::NamedPlugin)
     end
 
-    def provides(*paths)
-      paths.each do |path|
-        parts = path.split('/')
-        h = @providers
-        unless parts.length == 0
-          parts.shift if parts[0].length == 0
-          parts.each do |part|
-            h[part] ||= Mash.new
-            h = h[part]
-          end
-        end
-        h[:_providers] ||= []
-        h[:_providers] << @plugin_path
-      end
+    def [](key)
+      @data[key]
     end
 
-    # Set the value equal to the stdout of the command, plus run through a regex - the first piece of match data is the value.
-    def from_with_regex(cmd, *regex_list)
-      regex_list.flatten.each do |regex|
-        status, stdout, stderr = run_command(:command => cmd)
-        return "" if stdout.nil? || stdout.empty?
-        stdout.chomp!.strip
-        md = stdout.match(regex)
-        return md[1]
-      end
-    end
-    
-    def set_attribute(name, *values)
-      @data[name] = Array18(*values)
-      @data[name]
-    end
+    def all_plugins(attribute_filter=nil)
+      # Reset the system when all_plugins is called since this function
+      # can be run multiple times in order to pick up any changes in the
+      # config or plugins with Chef.
+      reset_system
 
-    def get_attribute(name)
-      @data[name]
+      load_plugins
+      run_plugins(true, attribute_filter)
     end
-    
-    def hint?(name)
-      @json_parser ||= Yajl::Parser.new
-      
-      return @hints[name] if @hints[name]
-      
-      Ohai::Config[:hints_path].each do |path|
-        filename = File.join(path, "#{name}.json")
-        if File.exist?(filename)
-          begin
-            hash = @json_parser.parse(File.read(filename))
-            @hints[name] = hash || Hash.new # hint should exist because the file did, even if it didn't contain anything
-          rescue Yajl::ParseError => e
-            Ohai::Log.error("Could not parse hint file at #{filename}: #{e.message}")
-          end
-        end
-      end
 
-      @hints[name]
+    def load_plugins
+      @loader.load_all
     end
-    
 
-    def all_plugins
-      require_plugin('os')
-
-      Ohai::Config[:plugin_path].each do |path|
-        [
-          Dir[File.join(path, '*')],
-          Dir[File.join(path, @data[:os], '**', '*')]
-        ].flatten.each do |file|
-          file_regex = Regexp.new("#{File.expand_path(path)}#{File::SEPARATOR}(.+).rb$")
-          md = file_regex.match(file)
-          if md
-            plugin_name = md[1].gsub(File::SEPARATOR, "::")
-            require_plugin(plugin_name) unless @seen_plugins.has_key?(plugin_name)
-          end
-        end
+    def run_plugins(safe = false, attribute_filter = nil)
+      # First run all the version 6 plugins
+      @v6_dependency_solver.values.each do |v6plugin|
+        @runner.run_plugin(v6plugin)
       end
-      unless RUBY_PLATFORM =~ /mswin|mingw32|windows/
-        # Catch any errant children who need to be reaped
-        begin
-          true while Process.wait(-1, Process::WNOHANG)
-        rescue Errno::ECHILD
-        end
-      end
-      true
-    end
 
-    def collect_providers(providers)
-      refreshments = []
-      if providers.is_a?(Mash)
-        providers.keys.each do |provider|
-          if provider.eql?("_providers")
-            refreshments << providers[provider]
-          else
-            refreshments << collect_providers(providers[provider])
-          end
-        end
-      else
-        refreshments << providers
+      # Then run all the version 7 plugins
+      begin
+        @provides_map.all_plugins(attribute_filter).each { |plugin|
+          @runner.run_plugin(plugin)
+        }
+      rescue Ohai::Exceptions::AttributeNotFound, Ohai::Exceptions::DependencyCycle => e
+        Ohai::Log.error("Encountered error while running plugins: #{e.inspect}")
+        raise
       end
-      refreshments.flatten.uniq
     end
 
-    def refresh_plugins(path = '/')
-      parts = path.split('/')
-      if parts.length == 0
-        h = @providers
+    def pathify_v6_plugin(plugin_name)
+      path_components = plugin_name.split("::")
+      File.join(path_components) + ".rb"
+    end
+
+    #
+    # Below APIs are from V6.
+    # Make sure that you are not breaking backwards compatibility
+    # if you are changing any of the APIs below.
+    #
+    def require_plugin(plugin_ref, force=false)
+      plugins = [ ]
+      # This method is only callable by version 6 plugins.
+      # First we check if there exists a v6 plugin that fulfills the dependency.
+      if @v6_dependency_solver.has_key? pathify_v6_plugin(plugin_ref)
+        # Note that: partial_path looks like Plugin::Name
+        # keys for @v6_dependency_solver are in form 'plugin/name.rb'
+        plugins << @v6_dependency_solver[pathify_v6_plugin(plugin_ref)]
       else
-        parts.shift if parts[0].length == 0
-        h = @providers
-        parts.each do |part|
-          break unless h.has_key?(part)
-          h = h[part]
+        # While looking up V7 plugins we need to convert the plugin_ref to an attribute.
+        attribute = plugin_ref.gsub("::", "/")
+        begin
+          plugins = @provides_map.find_providers_for([attribute])
+        rescue Ohai::Exceptions::AttributeNotFound
+          Ohai::Log.debug("Can not find any v7 plugin that provides #{attribute}")
+          plugins = [ ]
         end
       end
 
-      refreshments = collect_providers(h)
-      Ohai::Log.debug("Refreshing plugins: #{refreshments.join(", ")}")
-      
-      # remove the hints cache
-      @hints = Hash.new
-
-      refreshments.each do |r|
-        @seen_plugins.delete(r) if @seen_plugins.has_key?(r)
-      end
-      refreshments.each do |r|
-        require_plugin(r) unless @seen_plugins.has_key?(r)
+      if plugins.empty?
+        raise Ohai::Exceptions::DependencyNotFound, "Can not find a plugin for dependency #{plugin_ref}"
+      else
+        plugins.each do |plugin|
+          begin
+            @runner.run_plugin(plugin)
+          rescue SystemExit, Interrupt
+            raise
+          rescue Ohai::Exceptions::DependencyCycle, Ohai::Exceptions::AttributeNotFound => e
+            Ohai::Log.error("Encountered error while running plugins: #{e.inspect}")
+            raise
+          rescue Exception,Errno::ENOENT => e
+            Ohai::Log.debug("Plugin #{plugin.name} threw exception #{e.inspect} #{e.backtrace.join("\n")}")
+          end
+        end
       end
     end
 
-    def require_plugin(plugin_name, force=false)
-      unless force
-        return true if @seen_plugins[plugin_name]
-      end
-
-      if Ohai::Config[:disabled_plugins].include?(plugin_name)
-        Ohai::Log.debug("Skipping disabled plugin #{plugin_name}")
-        return false
-      end
-
-      @plugin_path = plugin_name
-
-      filename = "#{plugin_name.gsub("::", File::SEPARATOR)}.rb"
-
-      Ohai::Config[:plugin_path].each do |path|
-        check_path = File.expand_path(File.join(path, filename))
-        begin
-          @seen_plugins[plugin_name] = true
-          Ohai::Log.debug("Loading plugin #{plugin_name}")
-          from_file(check_path)
-          return true
-        rescue Errno::ENOENT => e
-          Ohai::Log.debug("No #{plugin_name} at #{check_path}")
-        rescue SystemExit, Interrupt
-          raise
-        rescue Exception,Errno::ENOENT => e
-          Ohai::Log.debug("Plugin #{plugin_name} threw exception #{e.inspect} #{e.backtrace.join("\n")}")
-        end
+    # Re-runs plugins that provide the attributes specified by
+    # +attribute_filter+. If +attribute_filter+ is not given, re-runs all
+    # plugins.
+    #
+    # Note that dependencies will not be re-run, so you must specify all of the
+    # attributes you want refreshed in the +attribute_filter+
+    #
+    # This method takes a naive approach to v6 plugins: it simply re-runs all
+    # of them whenever called.
+    def refresh_plugins(attribute_filter=nil)
+      Ohai::Hints.refresh_hints()
+      @provides_map.all_plugins(attribute_filter).each do |plugin|
+        plugin.reset!
       end
+      run_plugins(true, attribute_filter)
     end
 
-    # Sneaky!  Lets us stub out require_plugin when testing plugins, but still
-    # call the real require_plugin to kick the whole thing off.
-    alias :_require_plugin :require_plugin
-
+    #
     # Serialize this object as a hash
+    #
     def to_json
       Yajl::Encoder.new.encode(@data)
     end
 
+    #
     # Pretty Print this object as JSON
+    #
     def json_pretty_print(item=nil)
       Yajl::Encoder.new(:pretty => true).encode(item || @data)
     end
@@ -258,19 +191,5 @@ module Ohai
         raise ArgumentError, "I can only generate JSON for Hashes, Mashes, Arrays and Strings. You fed me a #{data.class}!"
       end
     end
-
-    def method_missing(name, *args)
-      return get_attribute(name) if args.length == 0
-
-      set_attribute(name, *args)
-    end
-
-    private
-    
-    def Array18(*args)
-      return nil if args.empty?
-      return args.first if args.length == 1
-      return *args
-    end
   end
 end