rfacter 0.0.1

data/lib/rfacter/node.rb

@@ -0,0 +1,137 @@
+require 'uri'
+require 'cgi'
+require 'forwardable'
+
+require 'rfacter'
+require_relative 'config'
+
+require 'train'
+require 'concurrent'
+
+# Interface to a local or remote host
+#
+# @note This class should be refacter to provide an abstracted interface to
+#   different transport backends like Train, Vagrant, Chloride, etc.
+#
+# @since 0.1.0
+class RFacter::Node
+  extend Forwardable
+
+  instance_delegate([:logger] => :@config)
+
+  # @return [URI]
+  attr_reader :uri
+
+  # @return [String]
+  attr_reader :hostname
+  # @return [String]
+  attr_reader :scheme
+  # @return [Integer, nil]
+  attr_reader :port
+  # @return [String, nil]
+  attr_reader :user
+  # @return [String, nil]
+  attr_reader :password
+  # @return [Hash]
+  attr_reader :options
+
+  attr_reader :transport
+
+  def initialize(uri, config: RFacter::Config.config, **opts)
+    @config = config
+
+    @uri = unless uri.is_a?(URI)
+      URI.parse(uri.to_s)
+    else
+      uri
+    end
+
+    @hostname = @uri.hostname || @uri.path
+    @scheme = if @uri.scheme.nil? && (@hostname == 'localhost')
+      'local'
+    elsif @uri.scheme.nil?
+      'ssh'
+    else
+      @uri.scheme
+    end
+
+    case @scheme
+    when 'ssh'
+      @port = @uri.port || 22
+      @user = @uri.user || 'root'
+    when 'winrm'
+      @user = @uri.user || 'Administrator'
+    end
+
+    @password = CGI.unescape(@uri.password) unless @uri.password.nil?
+    @options = @uri.query.nil? ? Hash.new : CGI.parse(@uri.query)
+    @options.update(opts)
+
+    # TODO: This should be abstracted.
+    @transport = Train.create(@scheme,
+      host: @hostname,
+      user: @user,
+      password: @password,
+      port: @port,
+      logger: logger, **@options)
+  end
+
+  # FIXME: For some reason, Train's connection re-use logic isn't working, so a
+  # new connection is being negotiated for each command. File a bug.
+  #
+  # TODO: Ensure connection use is thread-safe.
+  def connection
+    @connection ||= @transport.connection
+  end
+
+  # Execute a command on the node asynchronously
+  #
+  # This method initiates the execution of a command line and returns an
+  # object representing the result.
+  #
+  # @param command [String] The command string to execute.
+  #
+  # @return [Train::Extras::CommandResult] The result of the command including
+  #   stdout, stderr and exit code.
+  #
+  # @todo Add support for setting user accounts and environment variables.
+  def execute(command)
+    connection.run_command(command)
+  end
+
+  # Determine if an executable exists and return the path
+  #
+  # @param executable [String] The executable to locate.
+  #
+  # @return [String] The path to the executable if it exists.
+  #
+  # @return [nil] Returned when no matching executable can be located.
+  #
+  # @todo Add support for setting user accounts and environment variables.
+  def which(executable)
+    # TODO: Abstract away from the Train "os" implementation.
+    result = if connection.os.windows?
+      connection.run_command("(Get-Command -TotalCount 1 #{executable}).Path")
+    else
+      connection.run_command("which #{executable}")
+    end
+
+    if (result.exit_status != 0) || (result.stdout.chomp.empty?)
+      nil
+    else
+      result.stdout.chomp
+    end
+  end
+
+  # Interact with remote files in a read-only manner
+  #
+  # This method returns an object that can povide read only access to the stats
+  # and content of a particular file path.
+  #
+  # @param path [String] The file path to interact with.
+  #
+  # @return [Train::Extras::FileCommon] An object representing the remote file.
+  def file(path)
+    connection.file(path)
+  end
+end

data/lib/rfacter/util/collection.rb

@@ -0,0 +1,166 @@
+require 'forwardable'
+
+require 'rfacter'
+require_relative '../config'
+require_relative '../dsl'
+require_relative 'loader'
+require_relative 'fact'
+
+# Manage which facts exist and how we access them.  Largely just a wrapper
+# around a hash of facts.
+#
+# @api private
+class RFacter::Util::Collection
+  # Ensures unqualified namespaces like `Facter` and `Facter::Util` get
+  # re-directed to RFacter shims when the loader calls `instance_eval`
+  include RFacter::DSL
+  extend Forwardable
+
+  instance_delegate([:logger] => :@config)
+
+  def initialize(config: RFacter::Config.config, **opts)
+    @config = config
+    @facts = Hash.new
+    @internal_loader = RFacter::Util::Loader.new
+  end
+
+  # Return a fact object by name.
+  def [](name, node)
+    value(name, node)
+  end
+
+  # Define a new fact or extend an existing fact.
+  #
+  # @param name [Symbol] The name of the fact to define
+  # @param options [Hash] A hash of options to set on the fact
+  #
+  # @return [Facter::Util::Fact] The fact that was defined
+  def define_fact(name, options = {}, &block)
+    fact = create_or_return_fact(name, options)
+
+    if block_given?
+      fact.instance_eval(&block)
+    end
+
+    fact
+  rescue => e
+    logger.log_exception(e, "Unable to add fact #{name}: #{e}")
+  end
+
+  # Add a resolution mechanism for a named fact.  This does not distinguish
+  # between adding a new fact and adding a new way to resolve a fact.
+  #
+  # @param name [Symbol] The name of the fact to define
+  # @param options [Hash] A hash of options to set on the fact and resolution
+  #
+  # @return [Facter::Util::Fact] The fact that was defined
+  def add(name, options = {}, &block)
+    fact = create_or_return_fact(name, options)
+
+    fact.add(options, &block)
+
+    return fact
+  end
+
+  include Enumerable
+
+  # Iterate across all of the facts.
+  def each(node)
+    load_all
+
+    RFacter::DSL::COLLECTION.bind(self) do
+      RFacter::DSL::NODE.bind(node) do
+        @facts.each do |name, fact|
+          value = fact.value
+          unless value.nil?
+            yield name.to_s, value
+          end
+        end
+      end
+    end
+  end
+
+  # Return a fact by name.
+  def fact(name)
+    name = canonicalize(name)
+
+    # Try to load the fact if necessary
+    load(name) unless @facts[name]
+
+    # Try HARDER
+    load_all unless @facts[name]
+
+    if @facts.empty?
+      logger.warnonce("No facts loaded from #{@internal_loader.search_path.join(File::PATH_SEPARATOR)}")
+    end
+
+    @facts[name]
+  end
+
+  # Flush all cached values.
+  def flush
+    @facts.each { |name, fact| fact.flush }
+  end
+
+  # Return a list of all of the facts.
+  def list
+    load_all
+    return @facts.keys
+  end
+
+  def load(name)
+    @internal_loader.load(name, self)
+  end
+
+  # Load all known facts.
+  def load_all
+    @internal_loader.load_all(self)
+  end
+
+  # Return a hash of all of our facts.
+  def to_hash(node)
+    @facts.inject({}) do |h, ary|
+      resolved_value = RFacter::DSL::COLLECTION.bind(self) do
+        RFacter::DSL::NODE.bind(node) do
+          ary[1].value
+        end
+      end
+
+      # For backwards compatibility, convert the fact name to a string.
+      h[ary[0].to_s] = resolved_value unless resolved_value.nil?
+
+      h
+    end
+  end
+
+  def value(name, node)
+    RFacter::DSL::COLLECTION.bind(self) do
+      RFacter::DSL::NODE.bind(node) do
+        if fact = fact(name)
+          fact.value
+        end
+      end
+    end
+  end
+
+  private
+
+  def create_or_return_fact(name, options)
+    name = canonicalize(name)
+
+    fact = @facts[name]
+
+    if fact.nil?
+      fact = RFacter::Util::Fact.new(name, options)
+      @facts[name] = fact
+    else
+      fact.extract_ldapname_option!(options)
+    end
+
+    fact
+  end
+
+  def canonicalize(name)
+    name.to_s.downcase.to_sym
+  end
+end

data/lib/rfacter/util/confine.rb

@@ -0,0 +1,75 @@
+require 'forwardable'
+
+require 'rfacter'
+require_relative '../config'
+require_relative '../dsl'
+require_relative 'values'
+
+# A restricting tag for fact resolution mechanisms.  The tag must be true
+# for the resolution mechanism to be suitable.
+class RFacter::Util::Confine
+  extend Forwardable
+
+  instance_delegate([:logger] => :@config)
+
+  attr_accessor :fact, :values
+
+  include RFacter::Util::Values
+
+  # Add the restriction.  Requires the fact name, an operator, and the value
+  # we're comparing to.
+  #
+  # @param fact [Symbol] Name of the fact
+  # @param values [Array] One or more values to match against.
+  #   They can be any type that provides a === method.
+  # @param block [Proc] Alternatively a block can be supplied as a check.  The fact
+  #   value will be passed as the argument to the block.  If the block returns
+  #   true then the fact will be enabled, otherwise it will be disabled.
+  def initialize(fact = nil, *values, config: RFacter::Config.config, **options, &block)
+    raise ArgumentError, "The fact name must be provided" unless fact or block_given?
+    if values.empty? and not block_given?
+      raise ArgumentError, "One or more values or a block must be provided"
+    end
+    @fact = fact
+    @values = values
+    @config = config
+    @block = block
+  end
+
+  def to_s
+    return @block.to_s if @block
+    return "'%s' '%s'" % [@fact, @values.join(",")]
+  end
+
+  # Evaluate the fact, returning true or false.
+  # if we have a block paramter then we only evaluate that instead
+  def true?
+    if @block and not @fact then
+      begin
+        return !! @block.call
+      rescue StandardError => error
+        logger.debug "Confine raised #{error.class} #{error}"
+        return false
+      end
+    end
+
+    unless fact = RFacter::DSL::Facter[@fact]
+      logger.debug "No fact for %s" % @fact
+      return false
+    end
+    value = convert(fact.value)
+
+    return false if value.nil?
+
+    if @block then
+      begin
+        return !! @block.call(value)
+      rescue StandardError => error
+        logger.debug "Confine raised #{error.class} #{error}"
+        return false
+      end
+    end
+
+    return @values.any? do |v| convert(v) === value end
+  end
+end

data/lib/rfacter/util/fact.rb

@@ -0,0 +1,213 @@
+require 'forwardable'
+
+require 'rfacter'
+require_relative '../config'
+
+# This class represents a fact. Each fact has a name and multiple
+# {Facter::Util::Resolution resolutions}.
+#
+# Create facts using {Facter.add}
+#
+# @api public
+class RFacter::Util::Fact
+  require_relative '../core/aggregate'
+  require_relative 'resolution'
+
+  extend Forwardable
+
+  instance_delegate([:logger] => :@config)
+
+  # The name of the fact
+  # @return [String]
+  attr_accessor :name
+
+  # @return [String]
+  # @deprecated
+  attr_accessor :ldapname
+
+  # Creates a new fact, with no resolution mechanisms. See {Facter.add}
+  # for the public API for creating facts.
+  # @param name [String] the fact name
+  # @param options [Hash] optional parameters
+  # @option options [String] :ldapname set the ldapname property on the fact
+  #
+  # @api private
+  def initialize(name, config: RFacter::Config.config, **options)
+    @name = name.to_s.downcase.intern
+    @config = config
+
+    extract_ldapname_option!(options)
+
+    @ldapname ||= @name.to_s
+
+    @resolves = []
+    @searching = false
+
+    @value = nil
+  end
+
+  # Adds a new {Facter::Util::Resolution resolution}.  This requires a
+  # block, which will then be evaluated in the context of the new
+  # resolution.
+  #
+  # @param options [Hash] A hash of options to set on the resolution
+  #
+  # @return [Facter::Util::Resolution]
+  #
+  # @api private
+  def add(options = {}, &block)
+    define_resolution(nil, options, &block)
+  end
+
+  # Define a new named resolution or return an existing resolution with
+  # the given name.
+  #
+  # @param resolution_name [String] The name of the resolve to define or look up
+  # @param options [Hash] A hash of options to set on the resolution
+  # @return [Facter::Util::Resolution]
+  #
+  # @api public
+  def define_resolution(resolution_name, options = {}, &block)
+
+    resolution_type = options.delete(:type) || :simple
+
+    resolve = create_or_return_resolution(resolution_name, resolution_type)
+
+    resolve.set_options(options) unless options.empty?
+    resolve.evaluate(&block) if block
+
+    resolve
+  rescue => e
+    logger.log_exception(e, "Unable to add resolve #{resolution_name.inspect} for fact #{@name}: #{e.message}")
+  end
+
+  # Retrieve an existing resolution by name
+  #
+  # @param name [String]
+  #
+  # @return [Facter::Util::Resolution, nil] The resolution if exists, nil if
+  #   it doesn't exist or name is nil
+  def resolution(name)
+    return nil if name.nil?
+
+    @resolves.find { |resolve| resolve.name == name }
+  end
+
+  # Flushes any cached values.
+  #
+  # @return [void]
+  #
+  # @api private
+  def flush
+    @resolves.each { |r| r.flush }
+    @value = nil
+  end
+
+  # Returns the value for this fact. This searches all resolutions by
+  # suitability and weight (see {Facter::Util::Resolution}). If no
+  # suitable resolution is found, it returns nil.
+  #
+  # @api public
+  def value
+    return @value if @value
+
+    if @resolves.empty?
+      logger.debug("No resolves for #{@name}")
+      return nil
+    end
+
+    searching do
+
+      suitable_resolutions = sort_by_weight(find_suitable_resolutions(@resolves))
+      @value = find_first_real_value(suitable_resolutions)
+
+      announce_when_no_suitable_resolution(suitable_resolutions)
+      announce_when_no_value_found(@value)
+
+      @value
+    end
+  end
+
+  # @api private
+  # @deprecated
+  def extract_ldapname_option!(options)
+    if options[:ldapname]
+      logger.warnonce("ldapname is deprecated and will be removed in a future version")
+      self.ldapname = options.delete(:ldapname)
+    end
+  end
+
+  private
+
+  # Are we in the midst of a search?
+  def searching?
+    @searching
+  end
+
+  # Lock our searching process, so we never ge stuck in recursion.
+  def searching
+    raise RuntimeError, "Caught recursion on #{@name}" if searching?
+
+    # If we've gotten this far, we're not already searching, so go ahead and do so.
+    @searching = true
+    begin
+      yield
+    ensure
+      @searching = false
+    end
+  end
+
+  def find_suitable_resolutions(resolutions)
+    resolutions.find_all{ |resolve| resolve.suitable? }
+  end
+
+  def sort_by_weight(resolutions)
+    resolutions.sort { |a, b| b.weight <=> a.weight }
+  end
+
+  def find_first_real_value(resolutions)
+    resolutions.each do |resolve|
+      value = resolve.value
+      if not value.nil?
+        return value
+      end
+    end
+    nil
+  end
+
+  def announce_when_no_suitable_resolution(resolutions)
+    if resolutions.empty?
+      logger.debug("Found no suitable resolves of #{@resolves.length} for #{@name}")
+    end
+  end
+
+  def announce_when_no_value_found(value)
+    if value.nil?
+      logger.debug("value for #{name} is still nil")
+    end
+  end
+
+  def create_or_return_resolution(resolution_name, resolution_type)
+    resolve = self.resolution(resolution_name)
+
+    if resolve
+      if resolution_type != resolve.resolution_type
+        raise ArgumentError, "Cannot return resolution #{resolution_name} with type" +
+          " #{resolution_type}; already defined as #{resolve.resolution_type}"
+      end
+    else
+      case resolution_type
+      when :simple
+        resolve = RFacter::Util::Resolution.new(resolution_name, self)
+      when :aggregate
+        resolve = RFacter::Core::Aggregate.new(resolution_name, self)
+      else
+        raise ArgumentError, "Expected resolution type to be one of (:simple, :aggregate) but was #{resolution_type}"
+      end
+
+      @resolves << resolve
+    end
+
+    resolve
+  end
+end

data/lib/rfacter/util/loader.rb

@@ -0,0 +1,115 @@
+require 'pathname'
+require 'forwardable'
+
+require 'rfacter'
+require_relative '../config'
+require_relative '../dsl'
+
+# Load facts on demand.
+#
+# @api private
+class RFacter::Util::Loader
+  extend Forwardable
+
+  instance_delegate([:logger] => :@config)
+
+  def initialize(config: RFacter::Config.config, **opts)
+    @config = config
+    @loaded = []
+  end
+
+  # Load all resolutions for a single fact.
+  #
+  # @api public
+  # @param fact [Symbol]
+  def load(fact, collection)
+    # Now load from the search path
+    shortname = fact.to_s.downcase
+
+    filename = shortname + ".rb"
+
+    paths = search_path
+    unless paths.nil?
+      paths.each do |dir|
+        # Load individual files
+        file = File.join(dir, filename)
+
+        load_file(file, collection) if File.file?(file)
+      end
+    end
+  end
+
+  # Load all facts from all directories.
+  #
+  # @api public
+  def load_all(collection)
+    return if defined?(@loaded_all)
+
+    paths = search_path
+    unless paths.nil?
+      paths.each do |dir|
+        # dir is already an absolute path
+        Dir.glob(File.join(dir, '*.rb')).each do |path|
+          # exclude dirs that end with .rb
+          load_file(path, collection) if File.file?(path)
+        end
+      end
+    end
+
+    @loaded_all = true
+  end
+
+  # List directories to search for fact files.
+  #
+  # Search paths are gathered from the following sources:
+  #
+  # 1. A core set of facts from the rfacter/facts directory
+  # 2. ENV['RFACTERLIB'] is split and used verbatim
+  #
+  # A warning will be generated for paths that are not
+  # absolute directories.
+  #
+  # @api public
+  # @return [Array<String>]
+  def search_path
+    search_paths = [File.expand_path('../../facts', __FILE__)]
+
+    if ENV.include?("RFACTERLIB")
+      search_paths += ENV["RFACTERLIB"].split(File::PATH_SEPARATOR)
+    end
+
+    search_paths.delete_if { |path| ! valid_search_path?(path) }
+
+    search_paths.uniq
+  end
+
+  # Validate that the given path is valid, ie it is an absolute path.
+  #
+  # @param path [String]
+  # @return [Boolean]
+  def valid_search_path?(path)
+    Pathname.new(path).absolute? && File.directory?(path)
+  end
+
+  # Load a file and record is paths to prevent duplicate loads.
+  #
+  # @param file [String] The *absolute path* to the file to load
+  def load_file(file, collection)
+    return if @loaded.include? file
+
+    # We have to specify Kernel.load, because we have a load method.
+    begin
+      # Store the file path so we don't try to reload it
+      @loaded << file
+
+      RFacter::DSL::COLLECTION.bind(collection) do
+        collection.instance_eval(File.read(file), file)
+      end
+    rescue Exception => detail
+      # Don't store the path if the file can't be loaded
+      # in case it's loadable later on.
+      @loaded.delete(file)
+      logger.log_exception(detail, "Error loading fact #{file}: #{detail.message}")
+    end
+  end
+end