Custom facts

Facter.add(:rubypath) do
  setcode 'which ruby'
end

Facter.add(:rubypath) do
  setcode 'which ruby'
end

Facter.add(:rubypath) do
  confine :osfamily => "Windows"
  # Windows uses 'where' instead of 'which'
  setcode 'where ruby'
end

Facter.add(:jruby_installed) do
  confine :kernel do |value|
    value == "Linux"
  end

  setcode do
    # If jruby is present, return true. Otherwise, return false.
    Facter::Core::Execution.which('jruby') != nil
  end
end

1. A call to Facter.add(:fact_name):

   • This introduces a new fact or a new resolution for an existing fact with the same name.

   • The name can be either a symbol or a string.

   • The rest of the fact is wrapped in the add call’s do ... end block.

2. Zero or more confine statements:

   • Determine whether the resolution is suitable (and therefore is evaluated).

   • Can either match against the value of another fact or evaluate a Ruby block.

   • If given a symbol or string representing a fact name, a block is required and the block receives the fact’s value as an argument.

   • If given a hash, the keys are expected to be fact names. The values of the hash are either the expected fact values or an array of values to compare against.

   • If given a block, the confine is suitable if the block returns a value other than nil or false.

3. An optional has_weight statement:

   • When multiple resolutions are available for a fact, resolutions are evaluated from highest weight value to lowest.

   • Must be an integer greater than 0.

   • Defaults to the number of confine statements for the resolution.

4. A setcode statement that determines the value of the fact:

   • Can take either a string or a block.

   • If given a string, Facter executes it as a shell command. If the command succeeds, the output of the command is the value of the fact. If the command fails, the next suitable resolution is evaluated.

   • If given a block, the block’s return value is the value of the fact unless the block returns nil. If nil is returned, the next suitable resolution is evalutated.

   • Can execute shell commands within a setcode block, using the Facter::Core::Execution.exec function.

   • If multiple setcode statements are evaluated for a single resolution, only the last setcode block is used.

   Note: Set all code inside the sections outlined above ⁠— there should not be any code outside setcodeand confine blocks other than an optional has_weight statement in a custom fact.

Facter.add(:interfaces_array) do
  setcode do
   interfaces = Facter.value(:interfaces)
   # the 'interfaces' fact returns a single comma-delimited string, such as "lo0,eth0,eth1"
   # this splits the value into an array of interface names
   interfaces.split(',')
  end
end

Facter.add(:interfaces_hash) do
  setcode do
    interfaces_hash = {}

    Facter.value(:interfaces_array).each do |interface|
      ipaddress = Facter.value("ipaddress_#{interface}")
      if ipaddress
        interfaces_hash[interface] = ipaddress
      end
    end

    interfaces_hash
  end
end

1. A call to Facter.add(:fact_name, :type => :aggregate):

   • Introduces a new fact or a new resolution for an existing fact with the same name.

   • The name can be either a symbol or a string.

   • The :type => :aggregate parameter is required for aggregate resolutions.

   • The rest of the fact is wrapped in the add call’s do ... end block.

2. Zero or more confine statements:

   • Determine whether the resolution is suitable and (therefore is evaluated).

   • They can either match against the value of another fact or evaluate a Ruby block.

   • If given a symbol or string representing a fact name, a block is required and the block receives the fact’s value as an argument.

   • If given a hash, the keys are expected to be fact names. The values of the hash are either the expected fact values or an array of values to compare against.

   • If given a block, the confine is suitable if the block returns a value other than nil or false.

3. An optional has_weight statement:

   • Evaluates multiple resolutions for a fact from highest weight value to lowest.

   • Must be an integer greater than 0.

   • Defaults to the number of confine statements for the resolution.

4. One or more calls to chunk, each containing:

   • A name (as the argument to chunk).

   • A block of code, which is responsible for resolving the chunk to a value. The block’s return value is the value of the chunk; it can be any type, but is typically a hash or array.

5. An optional aggregate block:

   • If absent, Facter automatically merges hashes with hashes or arrays with arrays.

   • To merge the chunks in any other way, you need to make a call to aggregate, which takes a block of code.

   • The block is passed one argument (chunks, in the example), which is a hash of chunk name to chunk value for all the chunks in the resolution.

require 'digest'
require 'base64'

Facter.add(:networking_primary_sha, :type => :aggregate) do

  chunk(:sha256) do
    interfaces = {}

    Facter.value(:networking)['interfaces'].each do |interface, values|
      if values['mac']
        hash = Digest::SHA256.digest(values['mac'])
        encoded = Base64.encode64(hash)
        interfaces[interface] = {:mac_sha256 => encoded.strip}
      end
    end

    interfaces
  end

  chunk(:primary?) do
    interfaces = {}

    Facter.value(:networking)['interfaces'].each do |interface, values|
      interfaces[interface] = {:primary? => (interface == Facter.value(:networking)['primary'])}
    end

    interfaces
  end
  # Facter merges the return values for the two chunks
  # automatically, so there's no aggregate statement.
end

{
  bridge0 => {
    mac_sha256 => "bfgEFV7m1V04HYU6UqzoNoVmnPIEKWRSUOU650j0Wkk=",
    primary?   => false
  },
  en0 => {
    mac_sha256 => "6Fd3Ws2z+aIl8vNmClCbzxiO2TddyFBChMlIU+QB28c=",
    primary?   => true
  },
  ...
}

Facter.add(:total_free_memory_mb, :type => :aggregate) do
  chunk(:physical_memory) do
    Facter.value(:memoryfree_mb)
  end

  chunk(:virtual_memory) do
    Facter.value(:swapfree_mb)
  end

  aggregate do |chunks|
    # The return value for this block determines the value of the fact.
    sum = 0
    chunks.each_value do |i|
      sum += i
    end

    sum
  end
end