facter 2.1.0-x64-mingw32 → 2.2.0-x64-mingw32

data/lib/facter/netmask.rb

@@ -2,10 +2,11 @@
 #
 # Purpose: Returns the netmask for the main interfaces.
 #
-# Resolution: Uses the facter/util/netmask library routines.
+# Resolution: Uses the `facter/util/netmask` library routines.
 #
 # Caveats:
 #
+
 # netmask.rb
 # Find the netmask of the primary ipaddress
 # Copyright (C) 2007 David Schmitt <david@schmitt.edv-bus.at>

data/lib/facter/network.rb

@@ -1,11 +1,11 @@
 # Fact: network
 #
 # Purpose:
-# Get IP, network and netmask information for available network
-# interfacs.
+#   Get IP, network, and netmask information for available network
+#   interfaces.
 #
 # Resolution:
-#  Uses 'facter/util/ip' to enumerate interfaces and return their information.
+#   Uses `facter/util/ip` to enumerate interfaces and return their information.
 #
 # Caveats:
 #

data/lib/facter/operatingsystem.rb

@@ -3,139 +3,22 @@
 # Purpose: Return the name of the operating system.
 #
 # Resolution:
+#   Uses the name key of the os structured fact, which itself
+#   operates on the following conditions:
+#
+#
 #   If the kernel is a Linux kernel, check for the existence of a selection of
-#   files in /etc/ to find the specific flavour.
+#   files in `/etc/` to find the specific flavour.
 #   On SunOS based kernels, attempt to determine the flavour, otherwise return Solaris.
-#   On systems other than Linux, use the kernel value.
+#   On systems other than Linux, use the kernel fact's value.
 #
 # Caveats:
 #
 
-require 'facter/util/operatingsystem'
-
-Facter.add(:operatingsystem) do
-  confine :kernel => :sunos
-  setcode do
-    # Use uname -v because /etc/release can change in zones under SmartOS.
-    # It's apparently not trustworthy enough to rely on for this fact.
-    output = Facter::Core::Execution.exec('uname -v')
-    if output =~ /^joyent_/
-      "SmartOS"
-    elsif output =~ /^oi_/
-      "OpenIndiana"
-    elsif output =~ /^omnios-/
-      "OmniOS"
-    elsif FileTest.exists?("/etc/debian_version")
-      "Nexenta"
-    else
-      "Solaris"
-    end
-  end
-end
-
-Facter.add(:operatingsystem) do
-  # Cumulus Linux is a variant of Debian so this resolution needs to come
-  # before the Debian resolution.
-  has_weight(10)
-  confine :kernel => :linux
-
-  setcode do
-    release_info = Facter::Util::Operatingsystem.os_release
-    if release_info['NAME'] == "Cumulus Linux"
-      'CumulusLinux'
-    end
-  end
-end
-
 Facter.add(:operatingsystem) do
-  confine :kernel => :linux
-  setcode do
-    if Facter.value(:lsbdistid) == "Ubuntu"
-       "Ubuntu"
-    elsif Facter.value(:lsbdistid) == "LinuxMint"
-       "LinuxMint"
-    elsif FileTest.exists?("/etc/debian_version")
-      "Debian"
-    elsif FileTest.exists?("/etc/openwrt_release")
-      "OpenWrt"
-    elsif FileTest.exists?("/etc/gentoo-release")
-      "Gentoo"
-    elsif FileTest.exists?("/etc/fedora-release")
-      "Fedora"
-    elsif FileTest.exists?("/etc/mageia-release")
-      "Mageia"
-    elsif FileTest.exists?("/etc/mandriva-release")
-      "Mandriva"
-    elsif FileTest.exists?("/etc/mandrake-release")
-      "Mandrake"
-    elsif FileTest.exists?("/etc/meego-release")
-      "MeeGo"
-    elsif FileTest.exists?("/etc/arch-release")
-      "Archlinux"
-    elsif FileTest.exists?("/etc/oracle-release")
-      "OracleLinux"
-    elsif FileTest.exists?("/etc/enterprise-release")
-      if FileTest.exists?("/etc/ovs-release")
-        "OVS"
-      else
-        "OEL"
-      end
-    elsif FileTest.exists?("/etc/vmware-release")
-      "VMWareESX"
-    elsif FileTest.exists?("/etc/redhat-release")
-      txt = File.read("/etc/redhat-release")
-      if txt =~ /centos/i
-        "CentOS"
-      elsif txt =~ /CERN/
-        "SLC"
-      elsif txt =~ /scientific/i
-        "Scientific"
-      elsif txt =~ /^cloudlinux/i
-        "CloudLinux"
-      elsif txt =~ /^Parallels Server Bare Metal/i
-        "PSBM"
-      elsif txt =~ /Ascendos/i
-        "Ascendos"
-      elsif txt =~ /^XenServer/i
-        "XenServer"
-      else
-        "RedHat"
-      end
-    elsif FileTest.exists?("/etc/SuSE-release")
-      txt = File.read("/etc/SuSE-release")
-      if txt =~ /^SUSE LINUX Enterprise Server/i
-        "SLES"
-      elsif txt =~ /^SUSE LINUX Enterprise Desktop/i
-        "SLED"
-      elsif txt =~ /^openSUSE/i
-        "OpenSuSE"
-      else
-        "SuSE"
-      end
-    elsif FileTest.exists?("/etc/bluewhite64-version")
-      "Bluewhite64"
-    elsif FileTest.exists?("/etc/slamd64-version")
-      "Slamd64"
-    elsif FileTest.exists?("/etc/slackware-version")
-      "Slackware"
-    elsif FileTest.exists?("/etc/alpine-release")
-      "Alpine"
-    elsif FileTest.exists?("/etc/mageia-release")
-      "Mageia"
-    elsif FileTest.exists?("/etc/system-release")
-      "Amazon"
-    end
+  confine do
+    !Facter.value("os")["name"].nil?
   end
-end
 
-Facter.add(:operatingsystem) do
-  confine :kernel => "VMkernel"
-  setcode do
-    "ESXi"
-  end
-end
-
-Facter.add(:operatingsystem) do
-  # Default to just returning the kernel as the operating system
-  setcode do Facter[:kernel].value end
+  setcode { Facter.value("os")["name"] }
 end

data/lib/facter/operatingsystem/base.rb

@@ -0,0 +1,61 @@
+require 'facter/util/operatingsystem'
+
+module Facter
+  module Operatingsystem
+    class Base
+      def get_operatingsystem
+        @operatingsystem ||= Facter.value(:kernel)
+        @operatingsystem
+      end
+
+      def get_osfamily
+        Facter.value(:kernel)
+      end
+
+      def get_operatingsystemrelease
+        @operatingsystemrelease = Facter.value(:kernelrelease)
+        @operatingsystemrelease
+      end
+
+      def get_operatingsystemmajorrelease
+        if operatingsystemrelease = get_operatingsystemrelease
+          if (releasemajor = operatingsystemrelease.split(".")[0])
+            releasemajor
+          end
+        end
+      end
+
+      def get_operatingsystemminorrelease
+        if operatingsystemrelease = get_operatingsystemrelease
+          if (releaseminor = operatingsystemrelease.split(".")[1])
+            if releaseminor.include? "-"
+              releaseminor.split("-")[0]
+            else
+              releaseminor
+            end
+          end
+        end
+      end
+
+      def get_operatingsystemrelease_hash
+        release_hash = {}
+        if releasemajor = get_operatingsystemmajorrelease
+          release_hash["major"] = releasemajor
+        end
+
+        if releaseminor = get_operatingsystemminorrelease
+          release_hash["minor"] = releaseminor
+        end
+
+        if release = get_operatingsystemrelease
+          release_hash["full"] = release
+        end
+        release_hash
+      end
+
+      def has_lsb?
+        false
+      end
+    end
+  end
+end

data/lib/facter/operatingsystem/cumuluslinux.rb

@@ -0,0 +1,27 @@
+require 'facter/util/operatingsystem'
+require 'facter/operatingsystem/linux'
+
+module Facter
+  module Operatingsystem
+    class CumulusLinux < Linux
+      def get_operatingsystem
+        "CumulusLinux"
+      end
+
+      def get_osfamily
+        "Debian"
+      end
+
+      def get_operatingsystemrelease
+        @operatingsystemrelease ||= Facter::Util::Operatingsystem.os_release['VERSION_ID']
+        @operatingsystemrelease
+      end
+
+      def get_operatingsystemmajrelease
+        if operatingsystemrelease = get_operatingsystemrelease
+          operatingsystemrelease.split(".").first
+        end
+      end
+    end
+  end
+end

data/lib/facter/operatingsystem/implementation.rb

@@ -0,0 +1,30 @@
+require 'facter/operatingsystem/base'
+require 'facter/operatingsystem/cumuluslinux'
+require 'facter/operatingsystem/linux'
+require 'facter/operatingsystem/sunos'
+require 'facter/operatingsystem/vmkernel'
+require 'facter/operatingsystem/windows'
+
+module Facter
+  module Operatingsystem
+    def self.implementation(kernel = Facter.value(:kernel))
+      case kernel
+      when "Linux", "GNU/kFreeBSD"
+        release_info = Facter::Util::Operatingsystem.os_release
+        if release_info['NAME'] == "Cumulus Linux"
+          Facter::Operatingsystem::CumulusLinux.new
+        else
+          Facter::Operatingsystem::Linux.new
+        end
+      when "SunOS"
+        Facter::Operatingsystem::SunOS.new
+      when "VMkernel"
+        Facter::Operatingsystem::VMkernel.new
+      when "windows"
+        Facter::Operatingsystem::Windows.new
+      else
+        Facter::Operatingsystem::Base.new
+      end
+    end
+  end
+end

data/lib/facter/operatingsystem/linux.rb

@@ -0,0 +1,467 @@
+require 'facter/util/file_read'
+require 'facter/util/operatingsystem'
+require 'facter/operatingsystem/base'
+
+module Facter
+  module Operatingsystem
+    class Linux < Base
+      def get_operatingsystem
+        if Facter.value(:kernel) == "GNU/kFreeBSD"
+          "GNU/kFreeBSD"
+        elsif lsbdistid = get_lsbdistid
+          if lsbdistid == "Ubuntu"
+            @operatingsystem ||= "Ubuntu"
+          elsif lsbdistid == "LinuxMint"
+            @operatingsystem ||= "LinuxMint"
+          else
+            @operatingsystem ||= get_operatingsystem_with_release_files
+          end
+        else
+          @operatingsystem ||= get_operatingsystem_with_release_files
+        end
+      end
+
+      def get_osfamily
+        case get_operatingsystem
+        when "RedHat", "Fedora", "CentOS", "Scientific", "SLC", "Ascendos", "CloudLinux", "PSBM", "OracleLinux", "OVS", "OEL", "Amazon", "XenServer"
+          "RedHat"
+        when "LinuxMint", "Ubuntu", "Debian"
+          "Debian"
+        when "SLES", "SLED", "OpenSuSE", "SuSE"
+          "Suse"
+        when "Gentoo"
+          "Gentoo"
+        when "Archlinux"
+          "Archlinux"
+        when "Mageia", "Mandriva", "Mandrake"
+          "Mandrake"
+        else
+          Facter.value("kernel")
+        end
+      end
+
+      def get_operatingsystemrelease
+        case get_operatingsystem
+        when "Alpine"
+          get_alpine_release_with_release_file
+        when "Amazon"
+          get_amazon_release_with_lsb
+        when "BlueWhite64"
+          get_bluewhite_release_with_release_file
+        when "CentOS", "RedHat", "Scientific", "SLC", "Ascendos", "CloudLinux", "PSBM",
+             "XenServer", "Fedora", "MeeGo", "OracleLinux", "OEL", "oel", "OVS", "ovs"
+          get_redhatish_release_with_release_file
+        when "Debian"
+          get_debian_release_with_release_file
+        when "LinuxMint"
+          get_linux_mint_release_with_release_file
+        when "Mageia"
+          get_mageia_release_with_release_file
+        when "OpenWrt"
+          get_openwrt_release_with_release_file
+        when "Slackware"
+          get_slackware_release_with_release_file
+        when "Slamd64"
+          get_slamd64_release_with_release_file
+       when "SLES", "SLED", "OpenSuSE"
+          get_suse_release_with_release_file
+        when "Ubuntu"
+          get_ubuntu_release_with_release_file
+        when "VMwareESX"
+          get_vmwareESX_release_with_release_file
+        else
+          Facter.value(:kernelrelease)
+        end
+      end
+
+      def get_operatingsystemmajorrelease
+        if operatingsystemrelease = get_operatingsystemrelease
+          if get_operatingsystem == "Ubuntu"
+            if (releasemajor = operatingsystemrelease.split("."))
+              if releasemajor.length >= 2
+                "#{releasemajor[0]}.#{releasemajor[1]}"
+              else
+                releasemajor[0]
+              end
+            end
+          else
+            if (releasemajor = operatingsystemrelease.split(".")[0])
+              releasemajor
+            end
+          end
+        end
+      end
+
+      def get_operatingsystemminorrelease
+        if operatingsystemrelease = get_operatingsystemrelease
+          if get_operatingsystem == "Ubuntu"
+            if (releaseminor = operatingsystemrelease.split(".")[2])
+              releaseminor
+            end
+          else
+            if (releaseminor = operatingsystemrelease.split(".")[1])
+              if releaseminor.include? "-"
+                releaseminor.split("-")[0]
+              else
+                releaseminor
+              end
+            end
+          end
+        end
+      end
+
+      def has_lsb?
+        true
+      end
+
+      def get_lsbdistcodename
+        if (lsb_data = collect_lsb_information)
+          lsb_data["Codename"]
+        end
+      end
+
+      def get_lsbdistid
+        if (lsb_data = collect_lsb_information)
+          lsb_data["Distributor ID"]
+        end
+      end
+
+      def get_lsbdistdescription
+        if (lsb_data = collect_lsb_information)
+          lsb_data["Description"].sub(/^"(.*)"$/,'\1')
+        end
+      end
+
+      def get_lsbrelease
+        if (lsb_data = collect_lsb_information)
+          lsb_data["LSB Version"]
+        end
+      end
+
+      def get_lsbdistrelease
+        if (lsb_data = collect_lsb_information)
+          lsb_data["Release"]
+        end
+      end
+
+      def get_lsbmajdistrelease
+        lsbdistrelease = get_lsbdistrelease
+        if get_operatingsystem == "Ubuntu"
+          if (lsbreleasemajor = lsbdistrelease.split("."))
+            if lsbreleasemajor.length >= 2
+              result = "#{lsbreleasemajor[0]}.#{lsbreleasemajor[1]}"
+            else
+              result = lsbreleasemajor
+            end
+          end
+        else
+          if /(\d*)\./i =~ lsbdistrelease
+            result = $1
+          else
+            result = lsbdistrelease
+          end
+        end
+        result
+      end
+
+      def get_lsbminordistrelease
+        lsbdistrelease = get_lsbdistrelease
+        if get_operatingsystem == "Ubuntu"
+          mdata = /(\d+).(\d+).(\d+)/i.match(lsbdistrelease)
+          if mdata == nil
+            result = nil
+          else
+            result = mdata[3]
+          end
+        else
+          mdata = /(\d+).(\d+)/i.match(lsbdistrelease)
+          if mdata == nil
+            result = nil
+          else
+            result = mdata[2]
+          end
+        end
+        result
+      end
+
+      def get_lsb_facts_hash
+        lsb_hash = {}
+        if lsbdistcodename = get_lsbdistcodename
+          lsb_hash["distcodename"] = lsbdistcodename
+        end
+
+        if lsbdistid = get_lsbdistid
+          lsb_hash["distid"] = lsbdistid
+        end
+
+        if lsbdistdescription = get_lsbdistdescription
+          lsb_hash["distdescription"] = lsbdistdescription
+        end
+
+        if lsbrelease = get_lsbrelease
+          lsb_hash["release"] = lsbrelease
+        end
+
+        if lsbdistrelease = get_lsbdistrelease
+          lsb_hash["distrelease"] = lsbdistrelease
+        end
+
+        if lsbmajdistrelease = get_lsbmajdistrelease
+          lsb_hash["majdistrelease"]  = lsbmajdistrelease
+        end
+
+        if lsbminordistrelease = get_lsbminordistrelease
+          lsb_hash["minordistrelease"]  = lsbminordistrelease
+        end
+        lsb_hash
+      end
+
+      def collect_lsb_information
+        @lsb_data ||= Facter::Core::Execution.exec("lsb_release -cidvr 2>/dev/null")
+        @data_hash = {}
+
+        if @lsb_data && @data_hash.empty?
+          @lsb_data.split("\n").each do |element|
+            lsbvar, value = element.split("\t")
+            lsbvar.gsub!(":", "")
+            @data_hash["#{lsbvar}"] = value
+          end
+        end
+
+        @data_hash unless @data_hash.empty?
+      end
+
+      private
+
+      # Sequentially searches the filesystem for the existence of a release file
+      #
+      # @return [String, NilClass]
+      def get_operatingsystem_with_release_files
+        operatingsystem = nil
+        release_files = {
+          "Debian"      => "/etc/debian_version",
+          "Gentoo"      => "/etc/gentoo-release",
+          "Fedora"      => "/etc/fedora-release",
+          "Mageia"      => "/etc/mageia-release",
+          "Mandriva"    => "/etc/mandriva-release",
+          "Mandrake"    => "/etc/mandrake-release",
+          "MeeGo"       => "/etc/meego-release",
+          "Archlinux"   => "/etc/arch-release",
+          "OracleLinux" => "/etc/oracle-release",
+          "OpenWrt"     => "/etc/openwrt_release",
+          "Alpine"      => "/etc/alpine-release",
+          "VMWareESX"   => "/etc/vmware-release",
+          "Bluewhite64" => "/etc/bluewhite64-version",
+          "Slamd64"     => "/etc/slamd64-version",
+          "Slackware"   => "/etc/slackware-version"
+        }
+
+        release_files.each do |os, releasefile|
+          if FileTest.exists?(releasefile)
+            operatingsystem = os
+          end
+        end
+
+        unless operatingsystem
+          if FileTest.exists?("/etc/enterprise-release")
+            if FileTest.exists?("/etc/ovs-release")
+              operatingsystem = "OVS"
+            else
+              operatingsystem = "OEL"
+            end
+          elsif FileTest.exists?("/etc/redhat-release")
+            operatingsystem = get_redhat_operatingsystem_name
+          elsif FileTest.exists?("/etc/SuSE-release")
+            operatingsystem = get_suse_operatingsystem_name
+          elsif FileTest.exists?("/etc/system-release")
+            operatingsystem = "Amazon"
+          end
+        end
+
+        operatingsystem
+      end
+
+      # Uses a regex search on /etc/redhat-release to determine OS
+      #
+      # @return [String]
+      def get_redhat_operatingsystem_name
+        txt = File.read("/etc/redhat-release")
+        matches = {
+          "CentOS"     => "centos",
+          "Scientific" => "Scientific",
+          "CloudLinux" => "^cloudlinux",
+          "PSBM"       => "^Parallels Server Bare Metal",
+          "Ascendos"   => "Ascendos",
+          "XenServer"  => "^XenServer",
+          "XCP"        => "XCP"
+        }
+
+        if txt =~ /CERN/
+          "SLC"
+        else
+          match = regex_search_release_file_for_operatingsystem(matches, txt)
+          match = "RedHat" if match == nil
+
+          match
+        end
+      end
+
+      # Uses a regex search on /etc/SuSE-release to determine OS
+      #
+      # @return [String]
+      def get_suse_operatingsystem_name
+        txt = File.read("/etc/SuSE-release")
+        matches = {
+          "SLES"     => "^SUSE LINUX Enterprise Server",
+          "SLED"     => "^SUSE LINUX Enterprise Desktop",
+          "OpenSuSE" => "^openSUSE"
+        }
+        match = regex_search_release_file_for_operatingsystem(matches, txt)
+        match = "SuSE" if match == nil
+
+        match
+      end
+
+      # Iterates over potential matches from a hash argument and returns
+      # result of search
+      #
+      # @return [String, NilClass]
+      def regex_search_release_file_for_operatingsystem(regex_os_hash, filecontent)
+        match = nil
+        regex_os_hash.each do |os, regex|
+          match = os if filecontent =~ /#{regex}/i
+        end
+
+        match
+      end
+
+      # Read release files to determine operatingsystemrelease
+      #
+      # @return [String]
+      def get_alpine_release_with_release_file
+        if release = Facter::Util::FileRead.read('/etc/alpine-release')
+          release.sub!(/\s*$/, '')
+          release
+        end
+      end
+
+      def get_amazon_release_with_lsb
+        if lsbdistrelease = get_lsbdistrelease
+          lsbdistrelease
+        else
+          if release = Facter::Util::FileRead.read('/etc/system-release')
+            if match = /\d+\.\d+/.match(release)
+              match[0]
+            end
+          end
+        end
+      end
+
+      def get_bluewhite_release_with_release_file
+        if release = Facter::Util::FileRead.read('/etc/bluewhite64-version')
+          if match = /^\s*\w+\s+(\d+)\.(\d+)/.match(release)
+            match[1] + "." + match[2]
+          else
+            "unknown"
+          end
+        end
+      end
+
+      def get_redhatish_release_with_release_file
+        case get_operatingsystem
+        when "CentOS", "RedHat", "Scientific", "SLC", "Ascendos", "CloudLinux", "PSBM", "XenServer"
+          releasefile = "/etc/redhat-release"
+        when "Fedora"
+          releasefile = "/etc/fedora-release"
+        when "MeeGo"
+          releasefile = "/etc/meego-release"
+        when "OracleLinux"
+          releasefile = "/etc/oracle-release"
+        when "OEL", "oel"
+          releasefile = "/etc/enterprise-release"
+        when "OVS", "ovs"
+          releasefile = "/etc/ovs-release"
+        end
+
+        if release = Facter::Util::FileRead.read(releasefile)
+          line = release.split("\n").first.chomp
+          if match = /\(Rawhide\)$/.match(line)
+            "Rawhide"
+          elsif match = /release (\d[\d.]*)/.match(line)
+            match[1]
+          end
+        end
+      end
+
+      def get_debian_release_with_release_file
+        if release = Facter::Util::FileRead.read('/etc/debian_version')
+          release.sub!(/\s*$/, '')
+          release
+        end
+      end
+
+      def get_linux_mint_release_with_release_file
+        regex_search_releasefile_for_release(/RELEASE\=(\d+)/, "/etc/linuxmint/info")
+      end
+
+      def get_mageia_release_with_release_file
+        regex_search_releasefile_for_release(/Mageia release ([0-9.]+)/, "/etc/mageia-release")
+      end
+
+      def get_openwrt_release_with_release_file
+        regex_search_releasefile_for_release(/^(\d+\.\d+.*)/, "/etc/openwrt_version")
+      end
+
+      def get_slackware_release_with_release_file
+        regex_search_releasefile_for_release(/Slackware ([0-9.]+)/, "/etc/slackware-version")
+      end
+
+      def get_slamd64_release_with_release_file
+        regex_search_releasefile_for_release(/^\s*\w+\s+(\d+)\.(\d+)/, "/etc/slamd64-version")
+      end
+
+      def get_ubuntu_release_with_release_file
+        if release = Facter::Util::FileRead.read('/etc/lsb-release')
+          if match = release.match(/DISTRIB_RELEASE=((\d+.\d+)(\.(\d+))?)/)
+            # Return only the major and minor version numbers.  This behavior must
+            # be preserved for compatibility reasons.
+            match[2]
+          end
+        end
+      end
+
+      def get_vmwareESX_release_with_release_file
+        release = Facter::Core::Execution.exec('vmware -v')
+        if match = /VMware ESX .*?(\d.*)/.match(release)
+          match[1]
+        end
+      end
+
+      def get_suse_release_with_release_file
+        if release = Facter::Util::FileRead.read('/etc/SuSE-release')
+          if match = /^VERSION\s*=\s*(\d+)/.match(release)
+            releasemajor = match[1]
+            if match = /^PATCHLEVEL\s*=\s*(\d+)/.match(release)
+              releaseminor = match[1]
+            elsif match = /^VERSION\s=.*.(\d+)/.match(release)
+              releaseminor = match[1]
+            else
+              releaseminor = "0"
+            end
+            releasemajor + "." + releaseminor
+          else
+            "unknown"
+          end
+        end
+      end
+
+      def regex_search_releasefile_for_release(regex, releasefile)
+        if release = Facter::Util::FileRead.read(releasefile)
+          if match = release.match(regex)
+            match[1]
+          end
+        end
+      end
+    end
+  end
+end