facter 2.0.1.rc1-x86-mingw32

data/lib/facter/memory.rb

@@ -0,0 +1,162 @@
+# Fact: memory
+#
+# Purpose: Return information about memory and swap usage.
+#
+# Resolution:
+#   On Linuxes, uses Facter::Memory.meminfo_number from
+#   'facter/util/memory.rb'
+#   On AIX, parses "swap -l" for swap values only.
+#   On OpenBSD, it parses "swapctl -l" for swap values, vmstat via a module for
+#   free memory, and "sysctl hw.physmem" for maximum memory.
+#   On FreeBSD, it parses "swapinfo -k" for swap values, and parses sysctl for
+#   maximum memory.
+#   On Solaris, use "swap -l" for swap values, and parsing prtconf for maximum
+#   memory, and again, the vmstat module for free memory.
+#
+# Caveats:
+#   Some BSD platforms aren't covered at all. AIX is missing memory values.
+#
+
+# memory.rb
+# Additional Facts for memory/swap usage
+#
+# Copyright (C) 2006 Mooter Media Ltd
+# Author: Matthew Palmer <matt@solutionsfirst.com.au>
+#
+#
+
+require 'facter/util/memory'
+
+[  "memorysize",
+   "memoryfree",
+   "swapsize",
+   "swapfree"
+].each do |fact|
+  Facter.add(fact) do
+    setcode do
+      name = Facter.fact(fact + "_mb").value
+      Facter::Memory.scale_number(name.to_f, "MB") if name
+    end
+  end
+end
+
+Facter.add("swapsize_mb") do
+  setcode do
+    swaptotal = Facter::Memory.swap_size
+    "%.2f" % [swaptotal] if swaptotal
+  end
+end
+
+Facter.add("swapfree_mb") do
+  setcode do
+    swapfree = Facter::Memory.swap_free
+    "%.2f" % [swapfree] if swapfree
+  end
+end
+
+Facter.add("memorysize_mb") do
+  setcode do
+    memtotal = Facter::Memory.mem_size
+    "%.2f" % [memtotal] if memtotal
+  end
+end
+
+Facter.add("memoryfree_mb") do
+  setcode do
+    memfree = Facter::Memory.mem_free
+    "%.2f" % [memfree] if memfree
+  end
+end
+
+{   :memorysize_mb => "MemTotal",
+    :memoryfree_mb => "MemFree",
+    :swapsize_mb   => "SwapTotal",
+    :swapfree_mb   => "SwapFree"
+}.each do |fact, name|
+  Facter.add(fact) do
+    confine :kernel => [ :linux, :"gnu/kfreebsd" ]
+    setcode do
+      meminfo = Facter::Memory.meminfo_number(name)
+      "%.2f" % [meminfo]
+    end
+  end
+end
+
+if Facter.value(:kernel) == "Darwin"
+  Facter.add("SwapEncrypted") do
+    confine :kernel => :Darwin
+    setcode do
+      swap = Facter::Core::Execution.exec('sysctl vm.swapusage')
+      encrypted = false
+      if swap =~ /\(encrypted\)/ then encrypted = true; end
+      encrypted
+    end
+  end
+end
+
+if Facter.value(:kernel) == "SunOS"
+
+  Facter.add("memorysize_mb") do
+    confine :kernel => :sunos
+    # Total memory size available from prtconf
+    pconf = Facter::Core::Execution.exec('/usr/sbin/prtconf 2>/dev/null')
+    phymem = ""
+    pconf.each_line do |line|
+      if line =~ /^Memory size:\s+(\d+) Megabytes/
+        phymem = $1
+      end
+    end
+    setcode do
+      "%.2f" % [phymem.to_f]
+    end
+  end
+end
+
+if Facter.value(:kernel) == "windows"
+  require 'facter/util/wmi'
+
+  Facter.add("memorysize_mb") do
+    confine :kernel => :windows
+    setcode do
+      mem = 0
+      Facter::Util::WMI.execquery("select TotalPhysicalMemory from Win32_ComputerSystem").each do |comp|
+        mem = comp.TotalPhysicalMemory
+        break
+      end
+      "%.2f" % [(mem.to_f / 1024.0) / 1024.0]
+    end
+  end
+
+  Facter.add("memoryfree_mb") do
+    confine :kernel => :windows
+    setcode do
+      mem = 0
+      Facter::Util::WMI.execquery("select FreePhysicalMemory from Win32_OperatingSystem").each do |os|
+        mem = os.FreePhysicalMemory
+        break
+      end
+      "%.2f" % [mem.to_f / 1024.0]
+    end
+  end
+end
+
+Facter.add("swapsize_mb") do
+  confine :kernel => :dragonfly
+  setcode do
+    page_size = Facter::Core::Execution.exec("/sbin/sysctl -n hw.pagesize").to_f
+    swaptotal = Facter::Core::Execution.exec("/sbin/sysctl -n vm.swap_size").to_f * page_size
+    "%.2f" % [(swaptotal.to_f / 1024.0) / 1024.0]
+  end
+end
+
+Facter.add("swapfree_mb") do
+  confine :kernel => :dragonfly
+  setcode do
+    page_size = Facter::Core::Execution.exec("/sbin/sysctl -n hw.pagesize").to_f
+    swaptotal = Facter::Core::Execution.exec("/sbin/sysctl -n vm.swap_size").to_f * page_size
+    swap_anon_use = Facter::Core::Execution.exec("/sbin/sysctl -n vm.swap_anon_use").to_f * page_size
+    swap_cache_use = Facter::Core::Execution.exec("/sbin/sysctl -n vm.swap_cache_use").to_f * page_size
+    swapfree = swaptotal - swap_anon_use - swap_cache_use
+    "%.2f" % [(swapfree.to_f / 1024.0) / 1024.0]
+  end
+end

data/lib/facter/netmask.rb

@@ -0,0 +1,42 @@
+# Fact: netmask
+#
+# Purpose: Returns the netmask for the main interfaces.
+#
+# 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>
+# Copyright (C) 2007 Mark 'phips' Phillips
+#
+# idea and originial source by Mark 'phips' Phillips
+#
+require 'facter/util/netmask'
+
+Facter.add("netmask") do
+  confine :kernel => [ :sunos, :linux, :freebsd, :openbsd, :netbsd, :darwin, :"gnu/kfreebsd", :dragonfly ]
+  setcode do
+    Facter::NetMask.get_netmask
+  end
+end
+
+Facter.add(:netmask) do
+  confine :kernel => :windows
+  setcode do
+    require 'facter/util/ip/windows'
+
+    mask = nil
+
+    adapters = Facter::Util::IP::Windows.get_preferred_ipv4_adapters
+    adapters.find do |nic|
+      nic.IPSubnet.any? do |subnet|
+        mask = subnet if Facter::Util::IP::Windows.valid_ipv4_address?(subnet)
+        mask
+      end
+    end
+
+    mask
+  end
+end

data/lib/facter/network.rb

@@ -0,0 +1,20 @@
+# Fact: network
+#
+# Purpose:
+# Get IP, network and netmask information for available network
+# interfacs.
+#
+# Resolution:
+#  Uses 'facter/util/ip' to enumerate interfaces and return their information.
+#
+# Caveats:
+#
+require 'facter/util/ip'
+
+Facter::Util::IP.get_interfaces.each do |interface|
+  Facter.add("network_" + Facter::Util::IP.alphafy(interface)) do
+    setcode do
+      Facter::Util::IP.get_network_value(interface)
+    end
+  end
+end

data/lib/facter/operatingsystem.rb

@@ -0,0 +1,121 @@
+# Fact: operatingsystem
+#
+# Purpose: Return the name of the operating system.
+#
+# Resolution:
+#   If the kernel is a Linux kernel, check for the existence of a selection of
+#   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.
+#
+# Caveats:
+#
+
+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
+  confine :kernel => :linux
+  setcode do
+    if Facter.value(:lsbdistid) == "Ubuntu"
+       "Ubuntu"
+    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/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
+  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
+end

data/lib/facter/operatingsystemmajrelease.rb

@@ -0,0 +1,33 @@
+# Fact: operatingsystemmajrelease
+#
+# Purpose: Returns the major release of the operating system.
+#
+# Resolution: splits down the operatingsystemrelease fact at decimal point for
+#  osfamily RedHat derivatives and Debian.
+#
+# This should be the same as lsbmajdistrelease, but on minimal systems there
+# are too many dependencies to use LSB
+#
+# List of operatingsystems at time of writing:
+#"Alpine" "Amazon" "Archlinux" "Ascendos" "Bluewhite64" "CentOS" "CloudLinux" 
+#"Debian" "Fedora" "Gentoo" "Mandrake" "Mandriva" "MeeGo" "OEL" "OpenSuSE" 
+#"OracleLinux" "OVS" "PSBM" "RedHat" "Scientific" "Slackware" "Slamd64" "SLC"
+#"SLED" "SLES" "SuSE" "Ubuntu" "VMWareESX"
+Facter.add(:operatingsystemmajrelease) do
+  confine :operatingsystem => [
+    :Amazon,
+    :CentOS,
+    :CloudLinux,
+    :Debian,
+    :Fedora,
+    :OEL,
+    :OracleLinux,
+    :OVS,
+    :RedHat,
+    :Scientific,
+    :SLC
+  ]
+  setcode do
+    Facter.value('operatingsystemrelease').split('.').first
+  end
+end

data/lib/facter/operatingsystemrelease.rb

@@ -0,0 +1,226 @@
+# Fact: operatingsystemrelease
+#
+# Purpose: Returns the release of the operating system.
+#
+# Resolution:
+#   On RedHat derivatives, returns their '/etc/<variant>-release' file.
+#   On Debian, returns '/etc/debian_version'.
+#   On Ubuntu, parses '/etc/lsb-release' for the release version.
+#   On Suse, derivatives, parses '/etc/SuSE-release' for a selection of version
+#   information.
+#   On Slackware, parses '/etc/slackware-version'.
+#   On Amazon Linux, returns the 'lsbdistrelease' value.
+#   On Mageia, parses '/etc/mageia-release' for the release version.
+#
+#   On all remaining systems, returns the 'kernelrelease' value.
+#
+# Caveats:
+#
+
+require 'facter/util/file_read'
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %w{CentOS Fedora oel ovs OracleLinux RedHat MeeGo Scientific SLC Ascendos CloudLinux PSBM}
+  setcode do
+    case Facter.value(: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
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %w{Debian}
+  setcode do
+    if release = Facter::Util::FileRead.read('/etc/debian_version')
+      release.sub!(/\s*$/, '')
+      release
+    end
+  end
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %w{Ubuntu}
+  setcode do
+    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
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %w{SLES SLED OpenSuSE}
+  setcode do
+    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
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %w{OpenWrt}
+  setcode do
+    if release = Facter::Util::FileRead.read('/etc/openwrt_version')
+      if match = /^(\d+\.\d+.*)/.match(release)
+        match[1]
+      end
+    end
+  end
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %w{Slackware}
+  setcode do
+    if release = Facter::Util::FileRead.read('/etc/slackware-version')
+      if match = /Slackware ([0-9.]+)/.match(release)
+        match[1]
+      end
+    end
+  end
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %w{Mageia}
+  setcode do
+    if release = Facter::Util::FileRead.read('/etc/mageia-release')
+      if match = /Mageia release ([0-9.]+)/.match(release)
+        match[1]
+      end
+    end
+  end
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %w{Bluewhite64}
+  setcode do
+    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
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %w{VMwareESX}
+  setcode do
+    release = Facter::Core::Execution.exec('vmware -v')
+    if match = /VMware ESX .*?(\d.*)/.match(release)
+      match[1]
+    end
+  end
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %w{Slamd64}
+  setcode do
+    if release = Facter::Util::FileRead.read('/etc/slamd64-version')
+      if match = /^\s*\w+\s+(\d+)\.(\d+)/.match(release)
+        match[1] + "." + match[2]
+      else
+        "unknown"
+      end
+    end
+  end
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => :Alpine
+  setcode do
+    if release = Facter::Util::FileRead.read('/etc/alpine-release')
+      release.sub!(/\s*$/, '')
+      release
+    end
+  end
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => %W{Amazon}
+  setcode do Facter[:lsbdistrelease].value end
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :osfamily => :solaris
+  setcode do
+    if release = Facter::Util::FileRead.read('/etc/release')
+      line = release.split("\n").first.chomp
+      if match = /\s+s(\d+)[sx]?(_u\d+)?.*(?:SPARC|X86)/.match(line)
+        match.captures.join('')
+      end
+    end
+  end
+end
+
+Facter.add(:operatingsystemrelease) do
+  confine :operatingsystem => :windows
+  setcode do
+    require 'facter/util/wmi'
+    result = nil
+    Facter::Util::WMI.execquery("SELECT version, producttype FROM Win32_OperatingSystem").each do |os|
+      result =
+        case os.version
+        when /^6\.2/
+          os.producttype == 1 ? "8" : "2012"
+        when /^6\.1/
+          os.producttype == 1 ? "7" : "2008 R2"
+        when /^6\.0/
+          os.producttype == 1 ? "Vista" : "2008"
+        when /^5\.2/
+          if os.producttype == 1
+            "XP"
+          else
+            begin
+              os.othertypedescription == "R2" ? "2003 R2" : "2003"
+            rescue NoMethodError
+              "2003"
+            end
+          end
+        else
+          Facter[:kernelrelease].value
+        end
+      break
+    end
+    result
+  end
+end
+
+Facter.add(:operatingsystemrelease) do
+  setcode do Facter[:kernelrelease].value end
+end