facter 2.5.7-x64-mingw32 → 3.9.6.cfacter.20180412-x64-mingw32

data/lib/facter/util/netmask.rb

@@ -1,40 +0,0 @@
-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/lib/facter/util/normalization.rb

@@ -1,94 +0,0 @@
-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/lib/facter/util/nothing_loader.rb

@@ -1,12 +0,0 @@
-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/lib/facter/util/operatingsystem.rb

@@ -1,21 +0,0 @@
-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/lib/facter/util/parser.rb

@@ -1,168 +0,0 @@
-# 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/lib/facter/util/partitions.rb

@@ -1,47 +0,0 @@
-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/lib/facter/util/partitions/linux.rb

@@ -1,71 +0,0 @@
-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