bolt 0.0.1 → 0.5.0

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

@@ -0,0 +1,40 @@
+module Facter::NetMask
+  def self.get_netmask
+    netmask = nil;
+    ipregex = %r{(\d{1,3}\.){3}\d{1,3}}
+
+    ops = nil
+    case Facter.value(:kernel)
+    when 'Linux'
+      ops = {
+        :ifconfig_opts => ['2>/dev/null'],
+        :regex => %r{#{Facter.value(:ipaddress)}.*?(?:Mask:|netmask)\s*(#{ipregex})}x,
+        :munge => nil,
+      }
+    when 'SunOS'
+      ops = {
+        :ifconfig_opts => ['-a'],
+        :regex => %r{\s+ inet \s #{Facter.value(:ipaddress)} \s netmask \s (\w{8})}x,
+        :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
+      }
+    when 'FreeBSD','NetBSD','OpenBSD', 'Darwin', 'GNU/kFreeBSD', 'DragonFly', 'AIX'
+      ops = {
+        :ifconfig_opts => ['-a'],
+        :regex => %r{\s+ inet \s #{Facter.value(:ipaddress)} \s netmask \s 0x(\w{8})}x,
+        :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
+      }
+    end
+
+    String(Facter::Util::IP.exec_ifconfig(ops[:ifconfig_opts])).split(/\n/).collect do |line|
+      matches = line.match(ops[:regex])
+      if !matches.nil?
+        if ops[:munge].nil?
+          netmask = matches[1]
+        else
+          netmask = ops[:munge].call(matches[1])
+        end
+      end
+    end
+    netmask
+  end
+end

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

@@ -0,0 +1,94 @@
+module Facter
+  module Util
+    module Normalization
+      class NormalizationError < StandardError; end
+
+      VALID_TYPES = [Integer, Float, TrueClass, FalseClass, NilClass, String, Array, Hash]
+
+      module_function
+
+      # Recursively normalize the given data structure
+      #
+      # @api public
+      # @raise [NormalizationError] If the data structure contained an invalid element.
+      # @return [void]
+      def normalize(value)
+        case value
+        when Integer, Float, TrueClass, FalseClass, NilClass
+          value
+        when String
+          normalize_string(value)
+        when Array
+          normalize_array(value)
+        when Hash
+          normalize_hash(value)
+        else
+          raise NormalizationError, "Expected #{value} to be one of #{VALID_TYPES.inspect}, but was #{value.class}"
+        end
+      end
+
+      # @!method normalize_string(value)
+      #
+      # Attempt to normalize and validate the given string.
+      #
+      # On Ruby 1.8 the string is checked by stripping out all non UTF-8
+      # characters and comparing the converted string to the original. If they
+      # do not match then the string is considered invalid.
+      #
+      # On Ruby 1.9+, the string is validate by checking that the string encoding
+      # is UTF-8 and that the string content matches the encoding. If the string
+      # is not an expected encoding then it is converted to UTF-8.
+      #
+      # @api public
+      # @raise [NormalizationError] If the string used an unsupported encoding or did not match its encoding
+      # @param value [String]
+      # @return [void]
+
+      if RUBY_VERSION =~ /^1\.8/
+        require 'iconv'
+
+        def normalize_string(value)
+          converted = Iconv.conv('UTF-8//IGNORE', 'UTF-8', value)
+          if converted != value
+            raise NormalizationError, "String #{value.inspect} is not valid UTF-8"
+          end
+          value
+        end
+      else
+        def normalize_string(value)
+          value = value.encode(Encoding::UTF_8)
+
+          unless value.valid_encoding?
+            raise NormalizationError, "String #{value.inspect} doesn't match the reported encoding #{value.encoding}"
+          end
+
+          value
+        rescue EncodingError
+          raise NormalizationError, "String encoding #{value.encoding} is not UTF-8 and could not be converted to UTF-8"
+        end
+      end
+
+      # Validate all elements of the array.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the elements failed validation
+      # @param value [Array]
+      # @return [void]
+      def normalize_array(value)
+        value.collect do |elem|
+          normalize(elem)
+        end
+      end
+
+      # Validate all keys and values of the hash.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the keys or values failed normalization
+      # @param value [Hash]
+      # @return [void]
+      def normalize_hash(value)
+        Hash[value.collect { |k, v| [ normalize(k), normalize(v) ] } ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Facter
+  module Util
+
+    # An external fact loader that doesn't load anything
+    # This makes it possible to disable loading
+    # of external facts
+    class NothingLoader
+      def load(collection)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Facter
+  module Util
+    module Operatingsystem
+
+      # @see http://www.freedesktop.org/software/systemd/man/os-release.html
+      def self.os_release(file = '/etc/os-release')
+        values = {}
+
+        if File.readable?(file)
+          File.readlines(file).each do |line|
+            if (match = line.match(/^(\w+)=["']?(.+?)["']?$/))
+              values[match[1]] = match[2]
+            end
+          end
+        end
+
+        values
+      end
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+# This class acts as the factory and parent class for parsed
+# facts such as scripts, text, json and yaml files.
+#
+# Parsers must subclass this class and provide their own #results method.
+require 'facter'
+require 'yaml'
+
+module Facter::Util::Parser
+  @parsers = []
+
+  # For support mutliple extensions you can pass an array of extensions as
+  # +ext+.
+  def self.extension_matches?(filename, ext)
+    extension = case ext
+    when String
+      ext.downcase
+    when Enumerable
+      ext.collect {|x| x.downcase }
+    end
+    [extension].flatten.to_a.include?(file_extension(filename).downcase)
+  end
+
+  def self.file_extension(filename)
+    File.extname(filename).sub(".", '')
+  end
+
+  def self.register(klass, &suitable)
+    @parsers << [klass, suitable]
+  end
+
+  def self.parser_for(filename)
+    registration = @parsers.detect { |k| k[1].call(filename) }
+
+    if registration.nil?
+      NothingParser.new
+    else
+      registration[0].new(filename)
+    end
+  end
+
+  class Base
+    attr_reader :filename
+
+    def initialize(filename, content = nil)
+      @filename = filename
+      @content  = content
+    end
+
+    def content
+      @content ||= File.read(filename)
+    end
+
+    # results on the base class is really meant to be just an exception handler
+    # wrapper.
+    def results
+      parse_results
+    rescue Exception => detail
+      Facter.log_exception(detail, "Failed to handle #{filename} as #{self.class} facts: #{detail.message}")
+      nil
+    end
+
+    def parse_results
+      raise ArgumentError, "Subclasses must respond to parse_results"
+    end
+  end
+
+  module KeyValuePairOutputFormat
+    def self.parse(output)
+      return {} if output.nil?
+
+      result = {}
+      re = /^(.+?)=(.+)$/
+      output.each_line do |line|
+        if match_data = re.match(line.chomp)
+          result[match_data[1]] = match_data[2]
+        end
+      end
+      result
+    end
+  end
+
+  class YamlParser < Base
+    def parse_results
+      YAML.load(content)
+    end
+  end
+
+  register(YamlParser) do |filename|
+    extension_matches?(filename, "yaml")
+  end
+
+  class TextParser < Base
+    def parse_results
+      KeyValuePairOutputFormat.parse content
+    end
+  end
+
+  register(TextParser) do |filename|
+    extension_matches?(filename, "txt")
+  end
+
+  class JsonParser < Base
+    def parse_results
+      if Facter.json?
+        JSON.load(content)
+      else
+        Facter.warnonce "Cannot parse JSON data file #{filename} without the json library."
+        Facter.warnonce "Suggested next step is `gem install json` to install the json library."
+        nil
+      end
+    end
+  end
+
+  register(JsonParser) do |filename|
+    extension_matches?(filename, "json")
+  end
+
+  class ScriptParser < Base
+    def parse_results
+      KeyValuePairOutputFormat.parse Facter::Core::Execution.exec(quote(filename))
+    end
+
+    private
+
+    def quote(filename)
+      filename.index(' ') ? "\"#{filename}\"" : filename
+    end
+  end
+
+  register(ScriptParser) do |filename|
+    if Facter::Util::Config.is_windows?
+      extension_matches?(filename, %w{bat cmd com exe}) && File.file?(filename)
+    else
+      File.executable?(filename) && File.file?(filename) && ! extension_matches?(filename, %w{bat cmd com exe})
+    end
+  end
+
+  # Executes and parses the key value output of Powershell scripts
+  class PowershellParser < Base
+    # Returns a hash of facts from powershell output
+    def parse_results
+      powershell =
+        if File.exists?("#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe")
+          "#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe"
+        elsif File.exists?("#{ENV['SYSTEMROOT']}\\system32\\WindowsPowershell\\v1.0\\powershell.exe")
+          "#{ENV['SYSTEMROOT']}\\system32\\WindowsPowershell\\v1.0\\powershell.exe"
+        else
+          'powershell.exe'
+        end
+
+      shell_command = "\"#{powershell}\" -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -File \"#{filename}\""
+      output = Facter::Core::Execution.exec(shell_command)
+      KeyValuePairOutputFormat.parse(output)
+    end
+  end
+
+  register(PowershellParser) do |filename|
+    Facter::Util::Config.is_windows? && extension_matches?(filename, "ps1") && File.file?(filename)
+  end
+
+  # A parser that is used when there is no other parser that can handle the file
+  # The return from results indicates to the caller the file was not parsed correctly.
+  class NothingParser
+    def results
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'facter/util/partitions/linux'
+require 'facter/util/partitions/openbsd'
+
+module Facter::Util::Partitions
+  IMPLEMENTATIONS = {
+    'Linux'   => Linux,
+    'OpenBSD' => OpenBSD,
+  }
+
+  module NoImplementation
+    def self.list
+      []
+    end
+  end
+
+  def self.implementation
+    IMPLEMENTATIONS[Facter.fact(:kernel).value] || NoImplementation
+  end
+
+  def self.list
+    implementation.list
+  end
+
+  def self.uuid(partition)
+    implementation.uuid(partition)
+  end
+
+  def self.size(partition)
+    implementation.size(partition)
+  end
+
+  def self.mount(partition)
+    implementation.mount(partition)
+  end
+
+  def self.filesystem(partition)
+    implementation.filesystem(partition)
+  end
+
+  def self.label(partition)
+    implementation.label(partition)
+  end
+
+  def self.available?
+    !self.list.empty?
+  end
+end

data/vendored/facter/lib/facter/util/partitions/linux.rb

@@ -0,0 +1,71 @@
+module Facter::Util::Partitions
+  module Linux
+    # Only Linux 2.6+ kernels support sysfs which is required to easily get device details
+    SYSFS_BLOCK_DIRECTORY     = '/sys/block/'
+    DEVDISK_BY_UUID_DIRECTORY = '/dev/disk/by-uuid/'
+
+    def self.list
+      if File.exist?(SYSFS_BLOCK_DIRECTORY)
+        devices = Dir.entries(SYSFS_BLOCK_DIRECTORY).select { |d| File.exist?( SYSFS_BLOCK_DIRECTORY + d + "/device" ) }
+  
+        if devices.empty?
+          []
+        else
+          devices.collect do |device|
+            Dir.glob( SYSFS_BLOCK_DIRECTORY + device + "/#{device}*" ).collect do |d|
+              File.basename(d)
+            end
+          end.flatten
+        end
+      else
+        []
+      end
+    end
+
+    def self.uuid(partition)
+      uuid = nil
+      if File.exist?(DEVDISK_BY_UUID_DIRECTORY)
+        Dir.entries(DEVDISK_BY_UUID_DIRECTORY).each do |file|
+          qualified_file = File.join(DEVDISK_BY_UUID_DIRECTORY, file)
+
+          #A uuid is 16 octets long (RFC4122) which is 32hex chars + 4 '-'s
+          next unless file.length == 36
+          next unless File.symlink?(qualified_file)
+          next unless File.readlink(qualified_file).match(%r[(?:\.\./\.\./|/dev/)#{partition}$])
+
+          uuid = file
+        end
+      end
+      uuid
+    end
+
+    def self.size(partition)
+      read_size(partition)
+    end
+
+    def self.mount(partition)
+      if Facter::Core::Execution.which('mount')
+        Facter::Core::Execution.exec('mount').scan(/\/dev\/#{partition}\son\s(\S+)/).flatten.first
+      end
+    end
+
+    def self.filesystem(partition)
+      if Facter::Core::Execution.which('blkid')
+        Facter::Core::Execution.exec("blkid #{File.join('/dev', partition)}").scan(/TYPE="([^"]*)"/).flatten.first
+      end
+    end
+    
+    def self.label(partition)
+      if Facter::Core::Execution.which('blkid')
+        Facter::Core::Execution.exec("blkid #{File.join('/dev', partition)}").scan(/LABEL="([^"]*)"/).flatten.first
+      end
+    end
+    
+    private
+    def self.read_size(partition)
+      if device = partition.match(/(\D+)/)[1] and File.readable?(File.join(SYSFS_BLOCK_DIRECTORY, device, partition, 'size'))
+        File.read(File.join(SYSFS_BLOCK_DIRECTORY, device, partition, 'size')).chomp
+      end
+    end
+  end
+end