rfacter 0.0.1

data/lib/rfacter/util/logger.rb

@@ -0,0 +1,42 @@
+require 'logger'
+
+require 'rfacter'
+
+# RFacter Logger class
+#
+# This class provides all the methods of a standard Ruby Logger plus the
+# following methods used by the Facter API:
+#
+#   - `warnonce`
+#   - `debugonce`
+#   - `log_exception`
+#
+# @since 0.1.0
+class RFacter::Util::Logger < ::Logger
+  @@warn_messages = Hash.new
+  @@debug_messages = Hash.new
+
+  def warnonce(msg)
+    if @@warn_messages[msg].nil?
+      self.warn(msg)
+      @@warn_messages[msg] = true
+    end
+  end
+
+  def debugonce(msg)
+    if @@debug_messages[msg].nil?
+      self.debug(msg)
+      @@debug_messages[msg] = true
+    end
+  end
+
+  def log_exception(exception, message = nil)
+    message = exception.message if message.nil?
+
+    output = []
+    output << message
+    output.concat(exception.backtrace)
+
+    self.warn(output.flatten.join("\n"))
+  end
+end

data/lib/rfacter/util/non_nullable.rb

@@ -0,0 +1,46 @@
+require 'concurrent'
+
+require 'rfacter'
+
+# Non-nullable thread local variable
+#
+# A Subclass of Concurrent::ThreadLocalVar that raises a NameError
+# if de-referenced to `nil`. This allows the creation of variables
+# that must always be bound to a specific value before use.
+#
+# @since 0.1.0
+class RFacter::Util::NonNullable < Concurrent::ThreadLocalVar
+  # @param err_message [String] The error message to raise if
+  #   the instance is de-referenced to a `nil` value.
+  def initialize(default = nil, err_message:, &default_block)
+    @err_message = err_message
+    super(default, &default_block)
+  end
+
+  # Private reference to the superclass `value` method that won't
+  # raise an error. Allows the `bind` method to re-set the variable
+  # to nil at the end of an operation.
+  alias_method :nillable_value, :value
+  private :nillable_value
+
+  def bind(value, &block)
+    if block_given?
+      old_value = nillable_value
+      begin
+        self.value = value
+        yield
+      ensure
+        self.value = old_value
+      end
+    end
+  end
+
+  # @raise [NameError] when de-referenced to `nil`.
+  def value
+    result = super
+
+    raise(NameError, @err_message) if result.nil?
+
+    result
+  end
+end

data/lib/rfacter/util/normalization.rb

@@ -0,0 +1,96 @@
+require 'rfacter'
+
+module RFacter
+  module Util
+    module Normalization
+      class NormalizationError < StandardError; end
+
+      VALID_TYPES = [Integer, Float, TrueClass, FalseClass, NilClass, String, Array, Hash]
+
+      module_function
+
+      # Recursively normalize the given data structure
+      #
+      # @api public
+      # @raise [NormalizationError] If the data structure contained an invalid element.
+      # @return [void]
+      def normalize(value)
+        case value
+        when Integer, Float, TrueClass, FalseClass, NilClass
+          value
+        when String
+          normalize_string(value)
+        when Array
+          normalize_array(value)
+        when Hash
+          normalize_hash(value)
+        else
+          raise NormalizationError, "Expected #{value} to be one of #{VALID_TYPES.inspect}, but was #{value.class}"
+        end
+      end
+
+      # @!method normalize_string(value)
+      #
+      # Attempt to normalize and validate the given string.
+      #
+      # On Ruby 1.8 the string is checked by stripping out all non UTF-8
+      # characters and comparing the converted string to the original. If they
+      # do not match then the string is considered invalid.
+      #
+      # On Ruby 1.9+, the string is validate by checking that the string encoding
+      # is UTF-8 and that the string content matches the encoding. If the string
+      # is not an expected encoding then it is converted to UTF-8.
+      #
+      # @api public
+      # @raise [NormalizationError] If the string used an unsupported encoding or did not match its encoding
+      # @param value [String]
+      # @return [void]
+
+      if RUBY_VERSION =~ /^1\.8/
+        require 'iconv'
+
+        def normalize_string(value)
+          converted = Iconv.conv('UTF-8//IGNORE', 'UTF-8', value)
+          if converted != value
+            raise NormalizationError, "String #{value.inspect} is not valid UTF-8"
+          end
+          value
+        end
+      else
+        def normalize_string(value)
+          value = value.encode(Encoding::UTF_8)
+
+          unless value.valid_encoding?
+            raise NormalizationError, "String #{value.inspect} doesn't match the reported encoding #{value.encoding}"
+          end
+
+          value
+        rescue EncodingError
+          raise NormalizationError, "String encoding #{value.encoding} is not UTF-8 and could not be converted to UTF-8"
+        end
+      end
+
+      # Validate all elements of the array.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the elements failed validation
+      # @param value [Array]
+      # @return [void]
+      def normalize_array(value)
+        value.collect do |elem|
+          normalize(elem)
+        end
+      end
+
+      # Validate all keys and values of the hash.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the keys or values failed normalization
+      # @param value [Hash]
+      # @return [void]
+      def normalize_hash(value)
+        Hash[value.collect { |k, v| [ normalize(k), normalize(v) ] } ]
+      end
+    end
+  end
+end

data/lib/rfacter/util/resolution.rb

@@ -0,0 +1,163 @@
+require 'forwardable'
+
+require 'rfacter'
+require_relative '../config'
+
+# This represents a fact resolution. A resolution is a concrete
+# implementation of a fact. A single fact can have many resolutions and
+# the correct resolution will be chosen at runtime. Each time
+# {Facter.add} is called, a new resolution is created and added to the
+# set of resolutions for the fact named in the call.  Each resolution
+# has a {#has_weight weight}, which defines its priority over other
+# resolutions, and a set of {#confine _confinements_}, which defines the
+# conditions under which it will be chosen. All confinements must be
+# satisfied for a fact to be considered _suitable_.
+#
+# @api public
+class RFacter::Util::Resolution
+  require_relative '../dsl'
+  require_relative '../core/resolvable'
+  require_relative '../core/suitable'
+  extend Forwardable
+
+  instance_delegate([:logger] => :@config)
+
+  # @api private
+  attr_accessor :code
+  attr_writer :value
+
+  include RFacter::Core::Resolvable
+  include RFacter::Core::Suitable
+
+  # @!attribute [rw] name
+  # The name of this resolution. The resolution name should be unique with
+  # respect to the given fact.
+  # @return [String]
+  # @api public
+  attr_accessor :name
+
+  # @!attribute [r] fact
+  # @return [Facter::Util::Fact]
+  # @api private
+  attr_reader :fact
+
+  def which(command)
+    ::RFacter::DSL::Facter::Core::Execution.which(command)
+  end
+
+  def exec(command)
+    ::RFacter::DSL::Facter::Core::Execution.exec(command)
+  end
+
+  # Create a new resolution mechanism.
+  #
+  # @param name [String] The name of the resolution.
+  # @return [void]
+  #
+  # @api private
+  def initialize(name, fact, config: RFacter::Config.config, **options)
+    @name = name
+    @fact = fact
+    @config = config
+    @confines = []
+    @value = nil
+    @timeout = 0
+    @weight = nil
+  end
+
+  def resolution_type
+    :simple
+  end
+
+  # Evaluate the given block in the context of this resolution. If a block has
+  # already been evaluated emit a warning to that effect.
+  #
+  # @return [void]
+  def evaluate(&block)
+    if @last_evaluated
+      msg = "Already evaluated #{@name}"
+      msg << " at #{@last_evaluated}" if msg.is_a? String
+      msg << ", reevaluating anyways"
+      logger.warn msg
+    end
+
+    instance_eval(&block)
+
+    # Ruby 1.9+ provides the source location of procs which can provide useful
+    # debugging information if a resolution is being evaluated twice. Since 1.8
+    # doesn't support this we opportunistically provide this information.
+    if block.respond_to? :source_location
+      @last_evaluated = block.source_location.join(':')
+    else
+      @last_evaluated = true
+    end
+  end
+
+  def set_options(options)
+    if options[:name]
+      @name = options.delete(:name)
+    end
+
+    if options.has_key?(:value)
+      @value = options.delete(:value)
+    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 resolution options #{options.keys.inspect}"
+    end
+  end
+
+  # Sets the code block or external program that will be evaluated to
+  # get the value of the fact.
+  #
+  # @return [void]
+  #
+  # @overload setcode(string)
+  #   Sets an external program to call to get the value of the resolution
+  #   @param [String] string the external program to run to get the
+  #     value
+  #
+  # @overload setcode(&block)
+  #   Sets the resolution's value by evaluating a block at runtime
+  #   @param [Proc] block The block to determine the resolution's value.
+  #     This block is run when the fact is evaluated. Errors raised from
+  #     inside the block are rescued and printed to stderr.
+  #
+  # @api public
+  def setcode(string = nil, &block)
+    if string
+      @code = Proc.new do
+        output = exec(string)
+        if output.nil? or output.empty?
+          nil
+        else
+          output
+        end
+      end
+    elsif block_given?
+      @code = block
+    else
+      raise ArgumentError, "You must pass either code or a block"
+    end
+  end
+
+  private
+
+  def resolve_value
+    if @value
+      @value
+    elsif @code.nil?
+      nil
+    elsif @code
+      @code.call()
+    end
+  end
+end

data/lib/rfacter/util/values.rb

@@ -0,0 +1,110 @@
+require 'rfacter'
+
+module RFacter
+  module Util
+    # A util module for facter containing helper methods
+    module Values
+      module_function
+
+      class DeepFreezeError < StandardError; end
+
+      # Duplicate and deeply freeze a given data structure
+      #
+      # @param value [Object] The structure to freeze
+      # @return [void]
+      def deep_freeze(value)
+        case value
+        when Numeric, Symbol, TrueClass, FalseClass, NilClass
+          # These are immutable values, we can safely ignore them
+          value
+        when String
+          value.dup.freeze
+        when Array
+          value.map do |entry|
+            deep_freeze(entry)
+          end.freeze
+        when Hash
+          value.inject({}) do |hash, (key, value)|
+            hash[deep_freeze(key)] = deep_freeze(value)
+            hash
+          end.freeze
+        else
+          raise DeepFreezeError, "Cannot deep freeze #{value}:#{value.class}"
+        end
+      end
+
+      class DeepMergeError < StandardError; end
+
+      # Perform a deep merge of two nested data structures.
+      #
+      # @param left [Object]
+      # @param right [Object]
+      # @param path [Array<String>] The traversal path followed when merging nested hashes
+      #
+      # @return [Object] The merged data structure.
+      def deep_merge(left, right, path = [], &block)
+        ret = nil
+
+        if left.is_a? Hash and right.is_a? Hash
+          ret = left.merge(right) do |key, left_val, right_val|
+            path.push(key)
+            merged = deep_merge(left_val, right_val, path)
+            path.pop
+            merged
+          end
+        elsif left.is_a? Array and right.is_a? Array
+          ret = left.dup.concat(right)
+        elsif right.nil?
+          ret = left
+        elsif left.nil?
+          ret = right
+        elsif left.nil? and right.nil?
+          ret = nil
+        else
+          msg = "Cannot merge #{left.inspect}:#{left.class} and #{right.inspect}:#{right.class}"
+          if not path.empty?
+            msg << " at root"
+            msg << path.map { |part| "[#{part.inspect}]" }.join
+          end
+          raise DeepMergeError, msg
+        end
+
+        ret
+      end
+
+      def convert(value)
+        value = value.to_s if value.is_a?(Symbol)
+        value = value.downcase if value.is_a?(String)
+        value
+      end
+
+      # Flatten the given data structure to something that's suitable to return
+      # as flat facts.
+      #
+      # @param path [String] The fact path to be prefixed to the given value.
+      # @param structure [Object] The data structure to flatten. Nested hashes
+      #   will be recursively flattened, everything else will be returned as-is.
+      #
+      # @return [Hash] The given data structure prefixed with the given path
+      def flatten_structure(path, structure)
+        results = {}
+
+        if structure.is_a? Hash
+          structure.each_pair do |name, value|
+            new_path = "#{path}_#{name}".gsub(/\-|\//, '_')
+            results.merge! flatten_structure(new_path, value)
+          end
+        elsif structure.is_a? Array
+          structure.each_with_index do |value, index|
+            new_path = "#{path}_#{index}"
+            results.merge! flatten_structure(new_path, value)
+          end
+        else
+          results[path] = structure
+        end
+
+        results
+      end
+    end
+  end
+end

data/lib/rfacter/version.rb

@@ -0,0 +1,3 @@
+module RFacter
+  VERSION = '0.0.1'.freeze
+end

data/lib/rfacter.rb

@@ -0,0 +1,6 @@
+module RFacter;end
+module RFacter::Config;end
+module RFacter::Core;end
+module RFacter::Util;end
+
+require_relative 'rfacter/version'

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: rfacter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Charlie Sharpsteen
+- Puppet Labs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: train
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.0
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: inch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: |
+  RFacter is a library for collecting facts from remote system(s) by executing
+  commands over transports such as SSH and WinRM.
+email: source@sharpsteen.net
+executables:
+- rfacter
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/rfacter
+- lib/rfacter.rb
+- lib/rfacter/cli.rb
+- lib/rfacter/config.rb
+- lib/rfacter/config/settings.rb
+- lib/rfacter/core/aggregate.rb
+- lib/rfacter/core/directed_graph.rb
+- lib/rfacter/core/resolvable.rb
+- lib/rfacter/core/suitable.rb
+- lib/rfacter/dsl.rb
+- lib/rfacter/facts/kernel.rb
+- lib/rfacter/facts/kernelmajversion.rb
+- lib/rfacter/facts/kernelrelease.rb
+- lib/rfacter/facts/kernelversion.rb
+- lib/rfacter/facts/networking.rb
+- lib/rfacter/facts/os.rb
+- lib/rfacter/node.rb
+- lib/rfacter/util/collection.rb
+- lib/rfacter/util/confine.rb
+- lib/rfacter/util/fact.rb
+- lib/rfacter/util/loader.rb
+- lib/rfacter/util/logger.rb
+- lib/rfacter/util/non_nullable.rb
+- lib/rfacter/util/normalization.rb
+- lib/rfacter/util/resolution.rb
+- lib/rfacter/util/values.rb
+- lib/rfacter/version.rb
+homepage: https://github.com/Sharpie/rfacter
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.5
+signing_key: 
+specification_version: 4
+summary: Reduced, Remote-enabled, Ruby fork of Facter 2.x
+test_files: []