facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/custom_facts/my_custom_fact.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Facter.add(:my_custom_fact) do
+  has_weight(10_000)
+  setcode do
+    # 'my_custom_fact'
+    Facter.value('os')
+  end
+end

data/custom_facts/my_custom_os_fact.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Facter.add(:oss) do
+  has_weight(10_000)
+  setcode do
+    'my_custom_os'
+  end
+end

data/external_facts/my_external_fact.txt

@@ -0,0 +1 @@
+my_external_fact=123

data/facter.conf

@@ -0,0 +1,21 @@
+facts : {
+  blocklist : [ "file system", "EC2", "os.name" ],
+  ttls : [
+    { "timezone" : 30 days },
+  ]
+}
+global : {
+  external-dir     : [ "./external_facts"],
+  custom-dir       : [ "./custom-facts", "./custom-facts2" ],
+  no-external-facts : false,
+  no-custom-facts  : false,
+  no-ruby          : false
+  show-legacy      : false
+}
+
+cli : {
+  debug     : false,
+  trace     : true,
+  verbose   : false,
+  log-level : "warn"
+}

data/facter.gemspec

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require_relative 'config/config'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'facter'
+  spec.version       = FACTER_VERSION
+  spec.authors       = ['Puppet']
+  spec.email         = ['team-nw@puppet.com']
+
+  spec.summary       = 'New version of Facter'
+  spec.description   = 'New version of Facter'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  # On our internal Jenkins, there is no git. As it is a clean machine, we don't need to worry about anything else.
+  spec.files = if system('git --help > /dev/null')
+                 `git ls-files -z`.split("\x0")
+               else
+                 Dir.glob('**/*')
+               end
+
+  spec.required_ruby_version = '~> 2.3'
+  spec.files.reject! do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.files.reject! do |f|
+    f == 'bin/facter-ng'
+  end
+
+  spec.bindir = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'coveralls', '~> 0.8.23'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.74.0'
+  spec.add_development_dependency 'rubycritic', '~> 4.1.0'
+  spec.add_development_dependency 'sys-filesystem', '~> 1.3'
+
+  spec.add_runtime_dependency 'hocon', '~> 1.3'
+  spec.add_runtime_dependency 'thor', ['>= 1.0.1', '< 2.0']
+end

data/lib/custom_facts/core/aggregate.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+# 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
+module LegacyFacter
+  module Core
+    class Aggregate
+      include LegacyFacter::Core::Suitable
+      include LegacyFacter::Core::Resolvable
+
+      # @!attribute [r] name
+      #   @return [Symbol] The name of the aggregate resolution
+      attr_reader :name
+
+      # @!attribute [r] deps
+      #   @api private
+      #   @return [LegacyFacter::Core::DirectedGraph]
+      attr_reader :deps
+
+      # @!attribute [r] confines
+      #   @return [Array<LegacyFacter::Core::Confine>] An array of confines restricting
+      #     this to a specific platform
+      #   @see Facter::Core::Suitable
+      attr_reader :confines
+
+      # @!attribute [r] fact
+      # @return [LegacyFacter::Util::Fact]
+      # @api private
+      attr_reader :fact
+
+      def initialize(name, fact)
+        @name = name
+        @fact = fact
+
+        @confines = []
+        @chunks = {}
+
+        @aggregate = nil
+        @deps = LegacyFacter::Core::DirectedGraph.new
+      end
+
+      def options(options)
+        @name = options.delete(:name) if options[:name]
+
+        @timeout = options.delete(:timeout) if options.key?(:timeout)
+
+        @weight = options.delete(:has_weight) if options.key?(:has_weight)
+
+        raise ArgumentError, "Invalid aggregate options #{options.keys.inspect}" unless options.keys.empty?
+      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]
+      # @options 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)
+        raise ArgumentError, "#{self.class.name}#chunk requires a block" unless block_given?
+
+        deps = Array(opts.delete(:require))
+
+        unless 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)
+        raise ArgumentError, "#{self.class.name}#aggregate requires a block" unless block_given?
+
+        @aggregate = block
+      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] = LegacyFacter::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|
+          LegacyFacter::Util::Values.deep_merge(result, current)
+        end
+      rescue LegacyFacter::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
+        unless @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
+  end
+end

data/lib/custom_facts/core/directed_graph.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'tsort'
+
+module LegacyFacter
+  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(values.flatten) - Set.new(keys)
+
+        unless 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/custom_facts/core/execution.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module LegacyFacter
+  module Core
+    module Execution
+      # require_relative 'execution/base'
+      # require_relative 'execution/windows'
+      # require_relative 'execution/posix'
+
+      @@impl = if LegacyFacter::Util::Config.windows?
+                 LegacyFacter::Core::Execution::Windows.new
+               else
+                 LegacyFacter::Core::Execution::Posix.new
+               end
+
+      def self.impl
+        @@impl
+      end
+
+      module_function
+
+      # Returns the locations to be searched when looking for a binary. This
+      # is currently determined by the +PATH+ environment variable plus
+      # `/sbin` and `/usr/sbin` when run on unix
+      #
+      # @return [Array<String>] the paths to be searched for binaries
+      # @api private
+      def search_paths
+        @@impl.search_paths
+      end
+
+      # Determines the full path to a binary. If the supplied filename does not
+      # already describe an absolute path then different locations (determined
+      # by {search_paths}) will be searched for a match.
+      #
+      # Returns nil if no matching executable can be found otherwise returns
+      # the expanded pathname.
+      #
+      # @param bin [String] the executable to locate
+      # @return [String,nil] the full path to the executable or nil if not
+      #   found
+      #
+      # @api public
+      def which(bin)
+        @@impl.which(bin)
+      end
+
+      # Determine in a platform-specific way whether a path is absolute. This
+      # defaults to the local platform if none is specified.
+      #
+      # @param path [String] the path to check
+      # @param platform [:posix,:windows,nil] the platform logic to use
+      def absolute_path?(path, platform = nil)
+        @@impl.absolute_path?(path, platform)
+      end
+
+      # Given a command line, this returns the command line with the
+      # executable written as an absolute path. If the executable contains
+      # spaces, it has be put in double quotes to be properly recognized.
+      #
+      # @param command [String] the command line
+      #
+      # @return [String, nil] the command line with the executable's path
+      # expanded, or nil if the executable cannot be found.
+      def expand_command(command)
+        @@impl.expand_command(command)
+      end
+
+      # Overrides environment variables within a block of code.  The
+      # specified values will be set for the duration of the block, after
+      # which the original values (if any) will be restored.
+      #
+      # @overload with_env(values, { || ... })
+      #
+      # @param values [Hash<String=>String>] A hash of the environment
+      #   variables to override
+      #
+      # @return [void]
+      #
+      # @api public
+      def with_env(values, &block)
+        @@impl.with_env(values, &block)
+      end
+
+      # Try to execute a command and return the output.
+      #
+      # @param code [String] the program to run
+      #
+      # @return [String] the output of the program, or nil if the command does
+      #   not exist or could not be executed.
+      #
+      # @deprecated Use #{execute} instead
+      # @api public
+      def exec(command)
+        @@impl.execute(command, on_fail: nil)
+      end
+
+      # Execute a command and return the output of that program.
+      #
+      # @param code [String] the program to run
+      # @param options [Hash]
+      #
+      # @option options [Object] :on_fail How to behave when the command could
+      #   not be run. Specifying :raise will raise an error, anything else will
+      #   return that object on failure. Default is :raise.
+      #
+      # @raise [Facter::Core::Execution::ExecutionFailure] If the command does
+      #   not exist or could not be executed.
+      #
+      # @return [String] the output of the program, or the value of :on_fail if
+      #   command execution failed and :on_fail was specified.
+      #
+      # @api public
+      # @since 2.0.1
+      def execute(command, options = {})
+        @@impl.execute(command, options)
+      end
+
+      class ExecutionFailure < StandardError; end
+    end
+  end
+end