ohai 18.0.26 → 18.1.0

data/lib/ohai/plugins/zpools.rb

@@ -1,94 +1,94 @@
-# frozen_string_literal: true
-#
-# Author:: Jason J. W. Williams (williamsjj@digitar.com)
-# Copyright:: Copyright (c) Chef Software 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.
-#
-
-Ohai.plugin(:Zpools) do
-  provides "zpools"
-  depends "platform_family"
-
-  # If zpool status doesn't know about a field it returns '-'.
-  # We don't want to fill a field with that
-  def sanitize_value(value)
-    value == "-" ? nil : value
-  end
-
-  def gather_pool_info
-    pools = Mash.new
-    begin
-      # Grab ZFS zpools overall health and attributes
-      so = shell_out("zpool list -H -o name,size,alloc,free,cap,dedup,health,version")
-      so.stdout.lines do |line|
-        case line
-        when /^([-_0-9A-Za-z]*)\s+([.0-9]+[MGTPE])\s+([.0-9]+[MGTPE])\s+([.0-9]+[MGTPE])\s+(\d+%)\s+([.0-9]+x)\s+([-_0-9A-Za-z]+)\s+(\d+|-)$/
-          Ohai::Log.debug("Plugin Zpools: Parsing zpool list line: #{line.chomp}")
-          pools[$1] = Mash.new
-          pools[$1][:pool_size] = sanitize_value($2)
-          pools[$1][:pool_allocated] = sanitize_value($3)
-          pools[$1][:pool_free] = sanitize_value($4)
-          pools[$1][:capacity_used] = sanitize_value($5)
-          pools[$1][:dedup_factor] = sanitize_value($6)
-          pools[$1][:health] = sanitize_value($7)
-          pools[$1][:zpool_version] = sanitize_value($8)
-        end
-      end
-    rescue Ohai::Exceptions::Exec
-      Ohai::Log.debug('Plugin Zpools: Could not shell_out "zpool list -H -o name,size,alloc,free,cap,dedup,health,version". Skipping plugin.')
-    end
-    pools
-  end
-
-  collect_data(:solaris2, :linux, :freebsd, :openbsd, :netbsd, :dragonflybsd) do
-    pools = gather_pool_info
-
-    # Grab individual health for devices in the zpools
-    pools.each_key do |pool|
-      pools[pool][:devices] = Mash.new
-
-      # Run "zpool status" as non-root user (adm) so that
-      # the command won't try to open() each device which can
-      # hang the command if any of the disks are bad.
-      if platform_family == "solaris2"
-        command = "su adm -c \"zpool status #{pool}\""
-      else
-        # -L is used to give us real device names not label or uuid
-        # for example sda instead of ata-WDC_WD60EZAZ-00SF3B0_WD-WX32D203UXYK
-        command = "zpool status #{pool} -L"
-      end
-
-      so = shell_out(command)
-      so.stdout.lines do |line|
-        case line
-        # linux: http://rubular.com/r/J3wQC6E2lH
-        # solaris: http://rubular.com/r/FqOBzUQQ4p
-        # freebsd: http://rubular.com/r/RYkMNlytXl
-        when /^\s+((sd|c|ad|da|nvme|xvd)[-_a-zA-Z0-9]+)\s+([-_a-zA-Z0-9]+)\s+(\d+)\s+(\d+)\s+(\d+)$/
-          logger.trace("Plugin Zpools: Parsing zpool status line: #{line.chomp}")
-          pools[pool][:devices][$1] = Mash.new
-          pools[pool][:devices][$1][:state] = $3
-          pools[pool][:devices][$1][:errors] = Mash.new
-          pools[pool][:devices][$1][:errors][:read] = $4
-          pools[pool][:devices][$1][:errors][:write] = $5
-          pools[pool][:devices][$1][:errors][:checksum] = $6
-        end
-      end
-    end
-
-    # Set the zpools data
-    zpools pools unless pools.empty?
-  end
-end
+# frozen_string_literal: true
+#
+# Author:: Jason J. W. Williams (williamsjj@digitar.com)
+# Copyright:: Copyright (c) Chef Software 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.
+#
+
+Ohai.plugin(:Zpools) do
+  provides "zpools"
+  depends "platform_family"
+
+  # If zpool status doesn't know about a field it returns '-'.
+  # We don't want to fill a field with that
+  def sanitize_value(value)
+    value == "-" ? nil : value
+  end
+
+  def gather_pool_info
+    pools = Mash.new
+    begin
+      # Grab ZFS zpools overall health and attributes
+      so = shell_out("zpool list -H -o name,size,alloc,free,cap,dedup,health,version")
+      so.stdout.lines do |line|
+        case line
+        when /^([-_0-9A-Za-z]*)\s+([.0-9]+[MGTPE])\s+([.0-9]+[MGTPE])\s+([.0-9]+[MGTPE])\s+(\d+%)\s+([.0-9]+x)\s+([-_0-9A-Za-z]+)\s+(\d+|-)$/
+          Ohai::Log.debug("Plugin Zpools: Parsing zpool list line: #{line.chomp}")
+          pools[$1] = Mash.new
+          pools[$1][:pool_size] = sanitize_value($2)
+          pools[$1][:pool_allocated] = sanitize_value($3)
+          pools[$1][:pool_free] = sanitize_value($4)
+          pools[$1][:capacity_used] = sanitize_value($5)
+          pools[$1][:dedup_factor] = sanitize_value($6)
+          pools[$1][:health] = sanitize_value($7)
+          pools[$1][:zpool_version] = sanitize_value($8)
+        end
+      end
+    rescue Ohai::Exceptions::Exec
+      Ohai::Log.debug('Plugin Zpools: Could not shell_out "zpool list -H -o name,size,alloc,free,cap,dedup,health,version". Skipping plugin.')
+    end
+    pools
+  end
+
+  collect_data(:solaris2, :linux, :freebsd, :openbsd, :netbsd, :dragonflybsd) do
+    pools = gather_pool_info
+
+    # Grab individual health for devices in the zpools
+    pools.each_key do |pool|
+      pools[pool][:devices] = Mash.new
+
+      # Run "zpool status" as non-root user (adm) so that
+      # the command won't try to open() each device which can
+      # hang the command if any of the disks are bad.
+      if platform_family == "solaris2"
+        command = "su adm -c \"zpool status #{pool}\""
+      else
+        # -L is used to give us real device names not label or uuid
+        # for example sda instead of ata-WDC_WD60EZAZ-00SF3B0_WD-WX32D203UXYK
+        command = "zpool status #{pool} -L"
+      end
+
+      so = shell_out(command)
+      so.stdout.lines do |line|
+        case line
+        # linux: http://rubular.com/r/J3wQC6E2lH
+        # solaris: http://rubular.com/r/FqOBzUQQ4p
+        # freebsd: http://rubular.com/r/RYkMNlytXl
+        when /^\s+((sd|c|ad|da|nvme|xvd)[-_a-zA-Z0-9]+)\s+([-_a-zA-Z0-9]+)\s+(\d+)\s+(\d+)\s+(\d+)$/
+          logger.trace("Plugin Zpools: Parsing zpool status line: #{line.chomp}")
+          pools[pool][:devices][$1] = Mash.new
+          pools[pool][:devices][$1][:state] = $3
+          pools[pool][:devices][$1][:errors] = Mash.new
+          pools[pool][:devices][$1][:errors][:read] = $4
+          pools[pool][:devices][$1][:errors][:write] = $5
+          pools[pool][:devices][$1][:errors][:checksum] = $6
+        end
+      end
+    end
+
+    # Set the zpools data
+    zpools pools unless pools.empty?
+  end
+end

data/lib/ohai/provides_map.rb

@@ -1,208 +1,208 @@
-# frozen_string_literal: true
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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_relative "mash"
-require_relative "exception"
-require_relative "mixin/os"
-require_relative "dsl"
-
-module Ohai
-  class ProvidesMap
-
-    attr_reader :map
-
-    def initialize
-      @map = Mash.new
-    end
-
-    # @param [Ohai::DSL::Plugin] plugin
-    # @param [Array] provided_attributes
-    #
-    # @return void
-    #
-    def set_providers_for(plugin, provided_attributes)
-      unless plugin.is_a?(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
-    #
-    # @param [Array] attributes
-    #
-    # @return [Array] plugin names
-    #
-    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.
-    #
-    # @param [Array] attributes
-    #
-    # @return [Array] plugin names
-    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
-    #
-    # @param [Array] attributes
-    #
-    # @return [Array] plugin names
-    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 %r{//+}.match?(attribute)
-      raise Ohai::Exceptions::AttributeSyntaxError, "Attribute contains a trailing '/': #{attribute}" if %r{/$}.match?(attribute)
-
-      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.each_key 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
+# frozen_string_literal: true
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright (c) Chef Software 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_relative "mash"
+require_relative "exception"
+require_relative "mixin/os"
+require_relative "dsl"
+
+module Ohai
+  class ProvidesMap
+
+    attr_reader :map
+
+    def initialize
+      @map = Mash.new
+    end
+
+    # @param [Ohai::DSL::Plugin] plugin
+    # @param [Array] provided_attributes
+    #
+    # @return void
+    #
+    def set_providers_for(plugin, provided_attributes)
+      unless plugin.is_a?(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
+    #
+    # @param [Array] attributes
+    #
+    # @return [Array] plugin names
+    #
+    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.
+    #
+    # @param [Array] attributes
+    #
+    # @return [Array] plugin names
+    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
+    #
+    # @param [Array] attributes
+    #
+    # @return [Array] plugin names
+    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 %r{//+}.match?(attribute)
+      raise Ohai::Exceptions::AttributeSyntaxError, "Attribute contains a trailing '/': #{attribute}" if %r{/$}.match?(attribute)
+
+      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.each_key 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