class Facter::Core::Aggregate

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

Attributes

confines[R]

@!attribute [r] confines

@return [Array<Facter::Core::Confine>] An array of confines restricting
  this to a specific platform
@see Facter::Core::Suitable
deps[R]

@!attribute [r] deps

@api private
@return [Facter::Core::DirectedGraph]
fact[R]

@!attribute [r] fact @return [Facter::Util::Fact] @api private

name[R]

@!attribute [r] name

@return [Symbol] The name of the aggregate resolution

Public Class Methods

new(name, fact) click to toggle source
# File lib/facter/core/aggregate.rb, line 43
def initialize(name, fact)
  @name = name
  @fact = fact

  @confines = []
  @chunks = {}

  @aggregate = nil
  @deps = Facter::Core::DirectedGraph.new
end

Public Instance Methods

aggregate(&block) click to toggle source

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]

# File lib/facter/core/aggregate.rb, line 139
def aggregate(&block)
  if block_given?
    @aggregate = block
  else
    raise ArgumentError, "#{self.class.name}#aggregate requires a block"
  end
end
chunk(name, opts = {}, &block) click to toggle source

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]

# File lib/facter/core/aggregate.rb, line 98
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
evaluate(&block) click to toggle source
# File lib/facter/core/aggregate.rb, line 72
def evaluate(&block)
  instance_eval(&block)
end
resolution_type() click to toggle source
# File lib/facter/core/aggregate.rb, line 147
def resolution_type
  :aggregate
end
set_options(options) click to toggle source
# File lib/facter/core/aggregate.rb, line 54
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