bolt 0.24.0 → 0.25.0

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

@@ -1,27 +0,0 @@
-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/vendored/facter/lib/facter/operatingsystem/implementation.rb

@@ -1,33 +0,0 @@
-require 'facter/operatingsystem/base'
-require 'facter/operatingsystem/osreleaselinux'
-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
-        elsif release_info['NAME'] == "CoreOS"
-          Facter::Operatingsystem::OsReleaseLinux.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/vendored/facter/lib/facter/operatingsystem/linux.rb

@@ -1,484 +0,0 @@
-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", "VirtuozzoLinux"
-          "RedHat"
-        when "LinuxMint", "Ubuntu", "Debian"
-          "Debian"
-        when "SLES", "SLED", "OpenSuSE", "SuSE"
-          "Suse"
-        when "Gentoo"
-          "Gentoo"
-        when "Archlinux", "Manjarolinux"
-          "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 "AristaEOS"
-          get_arista_release_with_release_file
-        when "BlueWhite64"
-          get_bluewhite_release_with_release_file
-        when "CentOS", "RedHat", "Scientific", "SLC", "Ascendos", "CloudLinux", "PSBM",
-             "XenServer", "Fedora", "MeeGo", "OracleLinux", "OEL", "oel", "OVS", "ovs",
-             "VirtuozzoLinux"
-          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 = {
-          "AristaEOS"   => "/etc/Eos-release",
-          "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",
-          "Manjarolinux"=> "/etc/manjaro-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",
-          "VirtuozzoLinux" => "^VirtuozzoLinux"
-        }
-
-        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_arista_release_with_release_file
-        if release = Facter::Util::FileRead.read('/etc/Eos-release')
-          if match = /\d+\.\d+(:?\.\d+)?[A-M]?$/.match(release)
-            match[0]
-          end
-        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", "VirtuozzoLinux"
-          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