bolt 0.19.1 → 0.20.0

data/vendored/facter/lib/facter/util/confine.rb

@@ -1,66 +0,0 @@
-# A restricting tag for fact resolution mechanisms.  The tag must be true
-# for the resolution mechanism to be suitable.
-
-require 'facter/util/values'
-
-class Facter::Util::Confine
-  attr_accessor :fact, :values
-
-  include Facter::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, &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
-    @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
-        Facter.debug "Confine raised #{error.class} #{error}"
-        return false
-      end
-    end
-
-    unless fact = Facter[@fact]
-      Facter.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
-        Facter.debug "Confine raised #{error.class} #{error}"
-        return false
-      end
-    end
-
-    return @values.any? do |v| convert(v) === value end
-  end
-end

data/vendored/facter/lib/facter/util/dhcp_servers.rb

@@ -1,58 +0,0 @@
-require 'facter/util/file_read'
-
-module Facter::Util::DHCPServers
-  def self.gateway_device
-    interface = nil
-    if routes = Facter::Util::FileRead.read('/proc/net/route')
-      routes.each_line do |line|
-        device, destination = line.split(' ')
-        if destination == '00000000'
-          interface = device
-          break
-        end
-      end
-    end
-    interface
-  end
-
-  def self.devices
-    if Facter::Core::Execution.which('nmcli')
-      Facter::Core::Execution.exec("nmcli d").split("\n").select {|d| d =~ /\sconnected/i }.collect{ |line| line.split[0] }
-    else
-      []
-    end
-  end
-
-  def self.device_dhcp_server(device)
-    if Facter::Core::Execution.which('nmcli')
-      # If the version is >= 0.9.9, use show instead of list
-      if is_newer_nmcli?
-        Facter::Core::Execution.exec("nmcli -f all d show #{device}").scan(/dhcp_server_identifier.*?(\d+\.\d+\.\d+\.\d+)$/).flatten.first
-      else
-        Facter::Core::Execution.exec("nmcli -f all d list iface #{device}").scan(/dhcp_server_identifier.*?(\d+\.\d+\.\d+\.\d+)$/).flatten.first
-      end
-    end
-  end
-
-  def self.network_manager_state
-    # If the version is >= 0.9.9, use g instead of nm
-    if is_newer_nmcli?
-      output = Facter::Core::Execution.exec('nmcli -t -f STATE g 2>/dev/null')
-    else
-      output = Facter::Core::Execution.exec('nmcli -t -f STATE nm 2>/dev/null')
-    end
-    return nil unless output
-    output.strip
-  end
-
-  def self.nmcli_version
-    if version = Facter::Core::Execution.exec("nmcli --version")
-      version.scan(/version\s(\d+)\.?(\d+)?\.?(\d+)?\.?(\d+)?/).flatten.map(&:to_i)
-    end
-  end
-
-  def self.is_newer_nmcli?
-    version = nmcli_version
-    version && (version[0] > 0 || version[1] > 9 || (version[1] == 9 && version[2] >= 9))
-  end
-end

data/vendored/facter/lib/facter/util/directory_loader.rb

@@ -1,88 +0,0 @@
-# A Facter plugin that loads external facts.
-#
-# Default Unix Directories:
-# /opt/puppetlabs/facter/facts.d, /etc/facter/facts.d, /etc/puppetlabs/facter/facts.d
-#
-# Beginning with Facter 3, only /opt/puppetlabs/facter/facts.d will be a default external fact
-# directory in Unix.
-#
-# Default Windows Direcotires:
-# C:\ProgramData\Puppetlabs\facter\facts.d (2008)
-# C:\Documents and Settings\All Users\Application Data\Puppetlabs\facter\facts.d (2003)
-#
-# Can also load from command-line specified directory
-#
-# Facts can be in the form of JSON, YAML or Text files
-# and any executable that returns key=value pairs.
-
-require 'facter'
-require 'facter/util/config'
-require 'facter/util/composite_loader'
-require 'facter/util/parser'
-require 'yaml'
-
-class Facter::Util::DirectoryLoader
-
-  class NoSuchDirectoryError < Exception
-  end
-
-  # This value makes it highly likely that external facts will take
-  # precedence over all other facts
-  EXTERNAL_FACT_WEIGHT = 10000
-
-  # Directory for fact loading
-  attr_reader :directory
-
-  def initialize(dir, weight = nil)
-    @directory = dir
-    @weight = weight || EXTERNAL_FACT_WEIGHT
-  end
-
-  def self.loader_for(dir)
-    if File.directory?(dir)
-      Facter::Util::DirectoryLoader.new(dir)
-    else
-      raise NoSuchDirectoryError
-    end
-  end
-
-  def self.default_loader
-    loaders = Facter::Util::Config.external_facts_dirs.collect do |dir|
-      Facter::Util::DirectoryLoader.new(dir)
-    end
-    Facter::Util::CompositeLoader.new(loaders)
-  end
-
-  # Load facts from files in fact directory using the relevant parser classes to
-  # parse them.
-  def load(collection)
-    weight = @weight
-    entries.each do |file|
-      parser = Facter::Util::Parser.parser_for(file)
-      if parser == nil
-        next
-      end
-
-      data = parser.results
-      if data == false
-        Facter.warn "Could not interpret fact file #{file}"
-      elsif data == {} or data == nil
-        Facter.warn "Fact file #{file} was parsed but returned an empty data set"
-      else
-        data.each { |p,v| collection.add(p, :value => v) { has_weight(weight) } }
-      end
-    end
-  end
-
-private
-
-  def entries
-    Dir.entries(directory).find_all { |f| should_parse?(f) }.sort.map { |f| File.join(directory, f) }
-  rescue Errno::ENOENT => detail
-    []
-  end
-
-  def should_parse?(file)
-    not file =~ /^\./
-  end
-end

data/vendored/facter/lib/facter/util/ec2.rb

@@ -1,106 +0,0 @@
-require 'timeout'
-require 'open-uri'
-
-# Provide a set of utility static methods that help with resolving the EC2
-# fact.
-module Facter::Util::EC2
-  class << self
-    # Test if we can connect to the EC2 api. Return true if able to connect.
-    # On failure this function fails silently and returns false.
-    #
-    # The +wait_sec+ parameter provides you with an adjustable timeout.
-    #
-    def can_connect?(wait_sec=2)
-      Facter.warnonce("#{self}.#{__method__} is deprecated; see the Facter::EC2 classes instead")
-      url = "http://169.254.169.254:80/"
-      Timeout::timeout(wait_sec) {open(url, :proxy => nil)}
-      return true
-    rescue Timeout::Error
-      return false
-    rescue
-      return false
-    end
-
-    # Test if this host has a mac address used by Eucalyptus clouds, which
-    # normally is +d0:0d+.
-    def has_euca_mac?
-      Facter.warnonce("#{self}.#{__method__} is deprecated; see the Facter::EC2 classes instead")
-      !!(Facter.value(:macaddress) =~ %r{^[dD]0:0[dD]:})
-    end
-
-    # Test if this host has a mac address used by OpenStack, which
-    # normally starts with FA:16:3E (older versions of OpenStack
-    # may generate mac addresses starting with 02:16:3E)
-    def has_openstack_mac?
-      Facter.warnonce("#{self}.#{__method__} is deprecated; see the Facter::EC2 classes instead")
-      !!(Facter.value(:macaddress) =~ %r{^(02|[fF][aA]):16:3[eE]})
-    end
-
-    # Test if the host has an arp entry in its cache that matches the EC2 arp,
-    # which is normally +fe:ff:ff:ff:ff:ff+.
-    def has_ec2_arp?
-      Facter.warnonce("#{self}.#{__method__} is deprecated; see the Facter::EC2 classes instead")
-      kernel = Facter.value(:kernel)
-
-      mac_address_re = case kernel
-                       when /Windows/i
-                         /fe-ff-ff-ff-ff-ff/i
-                       else
-                         /fe:ff:ff:ff:ff:ff/i
-                       end
-
-      arp_command = case kernel
-                    when /Windows/i, /SunOS/i
-                      "arp -a"
-                    else
-                      "arp -an"
-                    end
-
-      if arp_table = Facter::Core::Execution.exec(arp_command)
-        return true if arp_table.match(mac_address_re)
-      end
-      return false
-    end
-  end
-
-  ##
-  # userdata returns a single string containing the body of the response of the
-  # GET request for the URI http://169.254.169.254/latest/user-data/  If the
-  # metadata server responds with a 404 Not Found error code then this method
-  # retuns `nil`.
-  #
-  # @param version [String] containing the API version for the request.
-  # Defaults to "latest" and other examples are documented at
-  # http://aws.amazon.com/archives/Amazon%20EC2
-  #
-  # @api public
-  #
-  # @return [String] containing the response body or `nil`
-  def self.userdata(version="latest")
-    Facter.warnonce("#{self}.#{__method__} is deprecated; see the Facter::EC2 classes instead")
-    uri = "http://169.254.169.254/#{version}/user-data/"
-    begin
-      read_uri(uri)
-    rescue OpenURI::HTTPError => detail
-      case detail.message
-      when /404 Not Found/i
-        Facter.debug "No user-data present at #{uri}: server responded with #{detail.message}"
-        return nil
-      else
-        raise detail
-      end
-    end
-  end
-
-  ##
-  # read_uri provides a seam method to easily test the HTTP client
-  # functionality of a HTTP based metadata server.
-  #
-  # @api private
-  #
-  # @return [String] containing the body of the response
-  def self.read_uri(uri)
-    open(uri, :proxy => nil).read
-  end
-  private_class_method :read_uri
-end

data/vendored/facter/lib/facter/util/fact.rb

@@ -1,204 +0,0 @@
-require 'facter'
-require 'facter/util/resolution'
-require 'facter/core/aggregate'
-
-# This class represents a fact. Each fact has a name and multiple
-# {Facter::Util::Resolution resolutions}.
-#
-# Create facts using {Facter.add}
-#
-# @api public
-class Facter::Util::Fact
-  # 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, options = {})
-    @name = name.to_s.downcase.intern
-
-    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
-    Facter.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?
-      Facter.debug "No resolves for %s" % @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]
-      Facter.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?
-      Facter.debug "Found no suitable resolves of %s for %s" % [@resolves.length, @name]
-    end
-  end
-
-  def announce_when_no_value_found(value)
-    if value.nil?
-      Facter.debug("value for %s is still nil" % @name)
-    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 = Facter::Util::Resolution.new(resolution_name, self)
-      when :aggregate
-        resolve = Facter::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