rfacter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 57a9d18faa5cfba3610ad4e136cc0f6b67674f7e
+  data.tar.gz: ddc6e4a94f5cb61e2ff6133c46d1eb1bda340eed
+SHA512:
+  metadata.gz: e2633c5de708b220c5d8cb5bb39aadb635cce530fe9d7a5d1c228860c82f3f698c54ca4d45f33850fd796914e6a53b69f96f3efaa2908583eb6b3cd2a585c20f
+  data.tar.gz: b6ebc55e51bfb161ef8363e3f1381e9b4ce5d37ef21bfc27eee45b101c055c2a279a747bd36049f2b0c59c5752de9fa8426d4af7931c1e7f9646576a6f198244

data/bin/rfacter

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rfacter/cli'
+
+RFacter::CLI.run(ARGV)

data/lib/rfacter/cli.rb

@@ -0,0 +1,51 @@
+require 'forwardable'
+require 'json'
+
+require 'rfacter'
+
+require_relative 'config'
+require_relative 'node'
+require_relative 'util/collection'
+
+module RFacter::CLI
+  extend SingleForwardable
+
+  delegate([:logger] => :@config)
+
+  def self.run(argv)
+    names = RFacter::Config.configure_from_argv!(argv)
+    @config = RFacter::Config.config
+
+    if @config.nodes.empty?
+      @config.nodes['localhost'] = RFacter::Node.new('localhost')
+    end
+
+    logger.info('cli::run') { "Configured nodes: #{@config.nodes.values.map(&:hostname)}" }
+
+    collection = RFacter::Util::Collection.new
+    collection.load_all
+
+    facts = @config.nodes.values.inject(Hash.new) do |h, node|
+      node_facts = if names.empty?
+        collection.to_hash(node)
+      else
+        names.inject(Hash.new) do |n, name|
+          n[name] = collection.value(name, node)
+          n
+        end
+      end
+
+      # TODO: Implement proper per-node Fact caching so that we don't just
+      # reset the colleciton on each loop.
+      collection.flush
+
+      h[node.hostname] = node_facts
+      h
+    end
+
+
+    puts JSON.pretty_generate(facts)
+
+    exit 0
+  end
+end

data/lib/rfacter/config/settings.rb

@@ -0,0 +1,31 @@
+require 'rfacter'
+require_relative '../util/logger'
+
+# Class for top-level RFacter configuration
+#
+# Instances of this class hold top-level configuration values and shared
+# service objects such as loggers.
+#
+# @since 0.1.0
+class RFacter::Config::Settings
+  # Access the logger instance
+  #
+  # The object stored here should conform to the interface prresented by
+  # the Ruby logger.
+  #
+  # @return [Logger]
+  attr_reader :logger
+
+  # A list of nodes to operate on
+  #
+  # @return [Hash{String => RFacter::Node}] A list of URIs identifying nodes along with the
+  #   schemes to use when contacting them.
+  attr_reader :nodes
+
+  def initialize(**options)
+    @logger = RFacter::Util::Logger.new($stderr)
+    @logger.level = Logger::WARN
+
+    @nodes = Hash.new
+  end
+end

data/lib/rfacter/config.rb

@@ -0,0 +1,87 @@
+require 'optparse'
+require 'optparse/uri'
+require 'logger'
+
+require 'rfacter'
+
+require_relative 'config/settings'
+require_relative 'node'
+
+# Stores and sets global configuration
+#
+# This module stores a global instance of {RFacter::Config::Settings}
+# and contains methods for initializing the settings instance from
+# various sources.
+#
+# @since 0.1.0
+module RFacter::Config
+  # Return global configuration
+  #
+  # @return [RFacter::Config::Settings]
+  def self.config
+    @settings ||= RFacter::Config::Settings.new
+  end
+
+  # Set global configuration from an argument vector
+  #
+  # This method calls {.parse_argv} and uses the results to update the
+  # settings instance returned by {.config}.
+  #
+  # @param argv [Array<String>] A list of strings passed as command line
+  #   arguments.
+  #
+  # @return [Array<string>] An array of command line arguments that were
+  #   not consumed by the parser.
+  def self.configure_from_argv!(argv)
+    args, _ = parse_argv(argv, self.config)
+
+    args
+  end
+
+  # Configure a settings instance by parsing an argument vector
+  #
+  # @param argv [Array<String>] Command line arguments as an array of
+  #   strings.
+  #
+  # @param settings [RFacter::Config::Settings, nil] A settings object to
+  #   configure. A new object will be created if nothing is passed.
+  #
+  # @return [Array<Array<String>, RFacter::Config::Settings>>] A tuple
+  #   containing a configured instance of {RFacter::Config::Settings}
+  #   followed by an array of command line arguments that were not consumed
+  #   by the parser.
+  def self.parse_argv(argv, settings = nil)
+    settings ||= RFacter::Config::Settings.new
+    parser = OptionParser.new
+    args = argv.dup
+
+    parser.separator("\nOptions\n=======")
+
+    parser.on('--version', 'Print version number and exit.') do
+      puts RFacter::VERSION
+      exit 0
+    end
+
+    parser.on('-h', '--help', 'Print this help message.') do
+      puts parser.help
+      exit 0
+    end
+
+    parser.on('-v', '--verbose', 'Raise log level to INFO.') do
+      settings.logger.level = Logger::INFO
+    end
+
+    parser.on('-d', '--debug', 'Raise log level to DEBUG.') do
+      settings.logger.level = Logger::DEBUG
+    end
+
+    parser.on('-n', '--node', '=MANDATORY', URI, 'Add a node by URI.') do |uri|
+      node = RFacter::Node.new(uri)
+      settings.nodes[node.hostname] = node
+    end
+
+    parser.parse!(args)
+
+    [args, settings]
+  end
+end

data/lib/rfacter/core/aggregate.rb

@@ -0,0 +1,228 @@
+require 'forwardable'
+
+require 'rfacter'
+require_relative '../config'
+
+# Aggregates provide a mechanism for facts to be resolved in multiple steps.
+#
+# Aggregates are evaluated in two parts: generating individual chunks and then
+# aggregating all chunks together. Each chunk is a block of code that generates
+# a value, and may depend on other chunks when it runs. After all chunks have
+# been evaluated they are passed to the aggregate block as Hash<name, result>.
+# The aggregate block converts the individual chunks into a single value that is
+# returned as the final value of the aggregate.
+#
+# @api public
+# @since 2.0.0
+class RFacter::Core::Aggregate
+  require_relative 'directed_graph'
+  require_relative 'resolvable'
+  require_relative 'suitable'
+  require_relative '../util/values'
+
+  extend Forwardable
+
+  instance_delegate([:logger] => :@config)
+
+  include RFacter::Core::Suitable
+  include RFacter::Core::Resolvable
+
+  # @!attribute [r] name
+  #   @return [Symbol] The name of the aggregate resolution
+  attr_reader :name
+
+  # @!attribute [r] deps
+  #   @api private
+  #   @return [Facter::Core::DirectedGraph]
+  attr_reader :deps
+
+  # @!attribute [r] confines
+  #   @return [Array<Facter::Core::Confine>] An array of confines restricting
+  #     this to a specific platform
+  #   @see Facter::Core::Suitable
+  attr_reader :confines
+
+  # @!attribute [r] fact
+  # @return [Facter::Util::Fact]
+  # @api private
+  attr_reader :fact
+
+  def initialize(name, fact, config: RFacter::Config.config, **options)
+    @name = name
+    @fact = fact
+    @config = config
+
+    @confines = []
+    @chunks = {}
+
+    @aggregate = nil
+    @deps = RFacter::Core::DirectedGraph.new
+  end
+
+  def set_options(options)
+    if options[:name]
+      @name = options.delete(:name)
+    end
+
+    if options.has_key?(:timeout)
+      @timeout = options.delete(:timeout)
+    end
+
+    if options.has_key?(:weight)
+      @weight = options.delete(:weight)
+    end
+
+    if not options.keys.empty?
+      raise ArgumentError, "Invalid aggregate options #{options.keys.inspect}"
+    end
+  end
+
+  def evaluate(&block)
+    instance_eval(&block)
+  end
+
+  # Define a new chunk for the given aggregate
+  #
+  # @api public
+  #
+  # @example Defining a chunk with no dependencies
+  #   aggregate.chunk(:mountpoints) do
+  #     # generate mountpoint information
+  #   end
+  #
+  # @example Defining an chunk to add mount options
+  #   aggregate.chunk(:mount_options, :require => [:mountpoints]) do |mountpoints|
+  #     # `mountpoints` is the result of the previous chunk
+  #     # generate mount option information based on the mountpoints
+  #   end
+  #
+  # @param name [Symbol] A name unique to this aggregate describing the chunk
+  # @param opts [Hash]
+  # @option opts [Array<Symbol>, Symbol] require One or more chunks to evaluate
+  #   and pass to this block.
+  # @yield [*Object] Zero or more chunk results
+  #
+  # @return [void]
+  def chunk(name, opts = {}, &block)
+    if not block_given?
+      raise ArgumentError, "#{self.class.name}#chunk requires a block"
+    end
+
+    deps = Array(opts.delete(:require))
+
+    if not opts.empty?
+      raise ArgumentError, "Unexpected options passed to #{self.class.name}#chunk: #{opts.keys.inspect}"
+    end
+
+    @deps[name] = deps
+    @chunks[name] = block
+  end
+
+  # Define how all chunks should be combined
+  #
+  # @api public
+  #
+  # @example Merge all chunks
+  #   aggregate.aggregate do |chunks|
+  #     final_result = {}
+  #     chunks.each_value do |chunk|
+  #       final_result.deep_merge(chunk)
+  #     end
+  #     final_result
+  #   end
+  #
+  # @example Sum all chunks
+  #   aggregate.aggregate do |chunks|
+  #     total = 0
+  #     chunks.each_value do |chunk|
+  #       total += chunk
+  #     end
+  #     total
+  #   end
+  #
+  # @yield [Hash<Symbol, Object>] A hash containing chunk names and
+  #   chunk values
+  #
+  # @return [void]
+  def aggregate(&block)
+    if block_given?
+      @aggregate = block
+    else
+      raise ArgumentError, "#{self.class.name}#aggregate requires a block"
+    end
+  end
+
+  def resolution_type
+    :aggregate
+  end
+
+  private
+
+  # Evaluate the results of this aggregate.
+  #
+  # @see Facter::Core::Resolvable#value
+  # @return [Object]
+  def resolve_value
+    chunk_results = run_chunks()
+    aggregate_results(chunk_results)
+  end
+
+  # Order all chunks based on their dependencies and evaluate each one, passing
+  # dependent chunks as needed.
+  #
+  # @return [Hash<Symbol, Object>] A hash containing the chunk that
+  #   generated value and the related value.
+  def run_chunks
+    results = {}
+    order_chunks.each do |(name, block)|
+      input = @deps[name].map { |dep_name| results[dep_name] }
+
+      output = block.call(*input)
+      results[name] = RFacter::Util::Values.deep_freeze(output)
+    end
+
+    results
+  end
+
+  # Process the results of all chunks with the aggregate block and return the
+  # results. If no aggregate block has been specified, fall back to deep
+  # merging the given data structure
+  #
+  # @param results [Hash<Symbol, Object>] A hash of chunk names and the output
+  #   of that chunk.
+  # @return [Object]
+  def aggregate_results(results)
+    if @aggregate
+      @aggregate.call(results)
+    else
+      default_aggregate(results)
+    end
+  end
+
+  def default_aggregate(results)
+    results.values.inject do |result, current|
+      RFacter::Util::Values.deep_merge(result, current)
+    end
+  rescue RFacter::Util::Values::DeepMergeError => e
+    raise ArgumentError, "Could not deep merge all chunks (Original error: " +
+      "#{e.message}), ensure that chunks return either an Array or Hash or " +
+      "override the aggregate block", e.backtrace
+  end
+
+  # Order chunks based on their dependencies
+  #
+  # @return [Array<Symbol, Proc>] A list of chunk names and blocks in evaluation order.
+  def order_chunks
+    if not @deps.acyclic?
+      raise DependencyError, "Could not order chunks; found the following dependency cycles: #{@deps.cycles.inspect}"
+    end
+
+    sorted_names = @deps.tsort
+
+    sorted_names.map do |name|
+      [name, @chunks[name]]
+    end
+  end
+
+  class DependencyError < StandardError; end
+end

data/lib/rfacter/core/directed_graph.rb

@@ -0,0 +1,48 @@
+require 'set'
+require 'tsort'
+
+require 'rfacter'
+
+module RFacter
+  module Core
+    class DirectedGraph < Hash
+      include TSort
+
+      def acyclic?
+        cycles.empty?
+      end
+
+      def cycles
+        cycles = []
+        each_strongly_connected_component do |component|
+          cycles << component if component.size > 1
+        end
+        cycles
+      end
+
+      alias tsort_each_node each_key
+
+      def tsort_each_child(node)
+        fetch(node, []).each do |child|
+          yield child
+        end
+      end
+
+      def tsort
+        missing = Set.new(self.values.flatten) - Set.new(self.keys)
+
+        if not missing.empty?
+          raise MissingVertex, "Cannot sort elements; cannot depend on missing elements #{missing.to_a}"
+        end
+
+        super
+
+      rescue TSort::Cyclic
+        raise CycleError, "Cannot sort elements; found the following cycles: #{cycles.inspect}"
+      end
+
+      class CycleError < StandardError; end
+      class MissingVertex < StandardError; end
+    end
+  end
+end

data/lib/rfacter/core/resolvable.rb

@@ -0,0 +1,97 @@
+require 'timeout'
+
+require 'rfacter'
+require_relative '../util/normalization'
+
+# The resolvable mixin defines behavior for evaluating and returning fact
+# resolutions.
+#
+# Classes including this mixin should implement at #name method describing
+# the value being resolved and a #resolve_value that actually executes the code
+# to resolve the value.
+module RFacter::Core::Resolvable
+
+  # The timeout, in seconds, for evaluating this resolution.
+  # @return [Integer]
+  # @api public
+  attr_accessor :timeout
+
+  # Return the timeout period for resolving a value.
+  # (see #timeout)
+  # @return [Numeric]
+  # @comment requiring 'timeout' stdlib class causes Object#timeout to be
+  #   defined which delegates to Timeout.timeout. This method may potentially
+  #   overwrite the #timeout attr_reader on this class, so we define #limit to
+  #   avoid conflicts.
+  def limit
+    @timeout || 0
+  end
+
+  ##
+  # on_flush accepts a block and executes the block when the resolution's value
+  # is flushed.  This makes it possible to model a single, expensive system
+  # call inside of a Ruby object and then define multiple dynamic facts which
+  # resolve by sending messages to the model instance.  If one of the dynamic
+  # facts is flushed then it can, in turn, flush the data stored in the model
+  # instance to keep all of the dynamic facts in sync without making multiple,
+  # expensive, system calls.
+  #
+  # Please see the Solaris zones fact for an example of how this feature may be
+  # used.
+  #
+  # @see Facter::Util::Fact#flush
+  # @see Facter::Util::Resolution#flush
+  #
+  # @api public
+  def on_flush(&block)
+    @on_flush_block = block
+  end
+
+  ##
+  # flush executes the block, if any, stored by the {on_flush} method
+  #
+  # @see Facter::Util::Fact#flush
+  # @see Facter::Util::Resolution#on_flush
+  #
+  # @api private
+  def flush
+    @on_flush_block.call if @on_flush_block
+  end
+
+  def value
+    result = nil
+
+    with_timing do
+      Timeout.timeout(limit) do
+        result = resolve_value
+      end
+    end
+
+    RFacter::Util::Normalization.normalize(result)
+  rescue Timeout::Error => detail
+   logger.log_exception(detail, "Timed out after #{limit} seconds while resolving #{qualified_name}")
+    return nil
+  rescue RFacter::Util::Normalization::NormalizationError => detail
+   logger.log_exception(detail, "Fact resolution #{qualified_name} resolved to an invalid value: #{detail.message}")
+    return nil
+  rescue => detail
+   logger.log_exception(detail, "Could not retrieve #{qualified_name}: #{detail.message}")
+    return nil
+  end
+
+  private
+
+  def with_timing
+    starttime = Time.now.to_f
+
+    yield
+
+    finishtime = Time.now.to_f
+    ms = (finishtime - starttime) * 1000
+    #::Facter.show_time "#{qualified_name}: #{"%.2f" % ms}ms"
+  end
+
+  def qualified_name
+    "fact='#{@fact.name.to_s}', resolution='#{@name || '<anonymous>'}'"
+  end
+end

data/lib/rfacter/core/suitable.rb

@@ -0,0 +1,114 @@
+require 'rfacter'
+
+# The Suitable mixin provides mechanisms for confining objects to run on
+# certain platforms and determining the run precedence of these objects.
+#
+# Classes that include the Suitable mixin should define a `#confines` method
+# that returns an Array of zero or more Facter::Util::Confine objects.
+module RFacter::Core::Suitable
+  require_relative '../util/confine'
+
+  attr_writer :weight
+
+  # Sets the weight of this resolution. If multiple suitable resolutions
+  # are found, the one with the highest weight will be used.  If weight
+  # is not given, the number of confines set on a resolution will be
+  # used as its weight (so that the most specific resolution is used).
+  #
+  # @param weight [Integer] the weight of this resolution
+  #
+  # @return [void]
+  #
+  # @api public
+  def has_weight(weight)
+    @weight = weight
+  end
+
+  # Sets the conditions for this resolution to be used.  This method accepts
+  # multiple forms of arguments to determine suitability.
+  #
+  # @return [void]
+  #
+  # @api public
+  #
+  # @overload confine(confines)
+  #   Confine a fact to a specific fact value or values.  This form takes a
+  #   hash of fact names and values. Every fact must match the values given for
+  #   that fact, otherwise this resolution will not be considered suitable. The
+  #   values given for a fact can be an array, in which case the value of the
+  #   fact must be in the array for it to match.
+  #   @param [Hash{String,Symbol=>String,Array<String>}] confines set of facts identified by the hash keys whose
+  #     fact value must match the argument value.
+  #   @example Confining to Linux
+  #       Facter.add(:powerstates) do
+  #         # This resolution only makes sense on linux systems
+  #         confine :kernel => "Linux"
+  #         setcode do
+  #           File.read('/sys/power/states')
+  #         end
+  #       end
+  #
+  # @overload confine(confines, &block)
+  #   Confine a fact to a block with the value of a specified fact yielded to
+  #   the block.
+  #   @param [String,Symbol] confines the fact name whose value should be
+  #     yielded to the block
+  #   @param [Proc] block determines the suitability of the fact.  If the block
+  #     evaluates to `false` or `nil` then the confined fact will not be
+  #     evaluated.
+  #   @yield [value] the value of the fact identified by {confines}
+  #   @example Confine the fact to a host with an ipaddress in a specific
+  #     subnet
+  #       confine :ipaddress do |addr|
+  #         require 'ipaddr'
+  #         IPAddr.new('192.168.0.0/16').include? addr
+  #       end
+  #
+  # @overload confine(&block)
+  #   Confine a fact to a block.  The fact will be evaluated only if the block
+  #   evaluates to something other than `false` or `nil`.
+  #   @param [Proc] block determines the suitability of the fact.  If the block
+  #     evaluates to `false` or `nil` then the confined fact will not be
+  #     evaluated.
+  #   @example Confine the fact to systems with a specific file.
+  #       confine { File.exist? '/bin/foo' }
+  def confine(confines = nil, &block)
+    case confines
+    when Hash
+      confines.each do |fact, values|
+        @confines.push RFacter::Util::Confine.new(fact, *values)
+      end
+    else
+      if block
+        if confines
+          @confines.push RFacter::Util::Confine.new(confines, &block)
+        else
+          @confines.push RFacter::Util::Confine.new(&block)
+        end
+      else
+      end
+    end
+  end
+
+  # Returns the importance of this resolution. If the weight was not
+  # given, the number of confines is used instead (so that a more
+  # specific resolution wins over a less specific one).
+  #
+  # @return [Integer] the weight of this resolution
+  #
+  # @api private
+  def weight
+    if @weight
+      @weight
+    else
+      @confines.length
+    end
+  end
+
+  # Is this resolution mechanism suitable on the system in question?
+  #
+  # @api private
+  def suitable?
+    @confines.all? { |confine| confine.true? }
+  end
+end