facter 2.1.0-x64-mingw32

data/lib/facter/util/virtual.rb

@@ -0,0 +1,180 @@
+require 'facter/util/posix'
+require 'facter/util/file_read'
+require 'pathname'
+
+module Facter::Util::Virtual
+  ##
+  # virt_what is a delegating helper method intended to make it easier to stub
+  # the system call without affecting other calls to
+  # Facter::Core::Execution.exec
+  #
+  # Per https://bugzilla.redhat.com/show_bug.cgi?id=719611 when run as a
+  # non-root user the virt-what command may emit an error message on stdout,
+  # and later versions of virt-what may emit this message on stderr. This
+  # method ensures stderr is redirected and that error messages are stripped
+  # from stdout.
+  def self.virt_what(command = "virt-what")
+    command = Facter::Core::Execution.which(command)
+    return unless command
+
+    if Facter.value(:kernel) == 'windows'
+      redirected_cmd = "#{command} 2>NUL"
+    else
+      redirected_cmd = "#{command} 2>/dev/null"
+    end
+    output = Facter::Core::Execution.exec redirected_cmd
+    output.gsub(/^virt-what: .*$/, '') if output
+  end
+
+  ##
+  # lspci is a delegating helper method intended to make it easier to stub the
+  # system call without affecting other calls to Facter::Core::Execution.exec
+  def self.lspci(command = "lspci 2>/dev/null")
+    Facter::Core::Execution.exec command
+  end
+
+  def self.openvz?
+    FileTest.directory?("/proc/vz") and not self.openvz_cloudlinux?
+  end
+
+  # So one can either have #6728 work on OpenVZ or Cloudlinux. Whoo.
+  def self.openvz_type
+    return false unless self.openvz?
+    return false unless FileTest.exists?( '/proc/self/status' )
+
+    envid = Facter::Core::Execution.exec( 'grep "envID" /proc/self/status' )
+    if envid =~ /^envID:\s+0$/i
+    return 'openvzhn'
+    elsif envid =~ /^envID:\s+(\d+)$/i
+    return 'openvzve'
+    end
+  end
+
+  # Cloudlinux uses OpenVZ to a degree, but always has an empty /proc/vz/ and
+  # has /proc/lve/list present
+  def self.openvz_cloudlinux?
+    FileTest.file?("/proc/lve/list") or Dir.glob('/proc/vz/*').empty?
+  end
+
+  def self.zone?
+    return true if FileTest.directory?("/.SUNWnative")
+    z = Facter::Core::Execution.exec("/sbin/zonename")
+    return false unless z
+    return z.chomp != 'global'
+  end
+
+  def self.vserver?
+    return false unless FileTest.exists?("/proc/self/status")
+    txt = File.open("/proc/self/status", "rb").read
+    if txt.respond_to?(:encode!)
+      txt.encode!('UTF-16', 'UTF-8', :invalid => :replace)
+      txt.encode!('UTF-8', 'UTF-16')
+    end
+    return true if txt =~ /^(s_context|VxID):[[:blank:]]*[0-9]/
+    return false
+  end
+
+  def self.vserver_type
+    if self.vserver?
+      if FileTest.exists?("/proc/virtual")
+        "vserver_host"
+      else
+        "vserver"
+      end
+    end
+  end
+
+  def self.xen?
+    ["/proc/sys/xen", "/sys/bus/xen", "/proc/xen" ].detect do |f|
+      FileTest.exists?(f)
+    end
+  end
+
+  def self.kvm?
+     txt = if FileTest.exists?("/proc/cpuinfo")
+       File.read("/proc/cpuinfo")
+     elsif ["FreeBSD", "OpenBSD"].include? Facter.value(:kernel)
+       Facter::Util::POSIX.sysctl("hw.model")
+     end
+     (txt =~ /QEMU Virtual CPU/) ? true : false
+  end
+
+  def self.virtualbox?
+    File.read("/sys/devices/virtual/dmi/id/product_name") =~ /VirtualBox/ rescue false
+  end
+
+  def self.kvm_type
+    # TODO Tell the difference between kvm and qemu
+    # Can't work out a way to do this at the moment that doesn't
+    # require a special binary
+    if self.kvm?
+      "kvm"
+    end
+  end
+
+  def self.rhev?
+    File.read("/sys/devices/virtual/dmi/id/product_name") =~ /RHEV Hypervisor/ rescue false
+  end
+
+  def self.ovirt?
+    File.read("/sys/devices/virtual/dmi/id/product_name") =~ /oVirt Node/ rescue false
+  end
+
+  def self.gce?
+    File.read("/sys/devices/virtual/dmi/id/product_name") =~ /Google/ rescue false
+  end
+
+  def self.jail?
+    path = case Facter.value(:kernel)
+      when "FreeBSD" then "/sbin"
+      when "GNU/kFreeBSD" then "/bin"
+    end
+    Facter::Core::Execution.exec("#{path}/sysctl -n security.jail.jailed") == "1"
+  end
+
+  def self.hpvm?
+    Facter::Core::Execution.exec("/usr/bin/getconf MACHINE_MODEL").chomp =~ /Virtual Machine/
+  end
+
+  ##
+  # lxc? returns true if the process is running inside of a linux container.
+  # Implementation derived from
+  # http://stackoverflow.com/questions/20010199/determining-if-a-process-runs-inside-lxc-docker
+  def self.lxc?
+    path = Pathname.new('/proc/1/cgroup')
+    return false unless path.readable?
+    in_lxc = path.readlines.any? {|l| l.split(":")[2].to_s.start_with? '/lxc/' }
+    return true if in_lxc
+    return false
+  end
+
+  ##
+  # docker? returns true if the process is running inside of a docker container.
+  # Implementation derived from observation of a boot2docker system
+  def self.docker?
+    path = Pathname.new('/proc/1/cgroup')
+    return false unless path.readable?
+    in_docker = path.readlines.any? {|l| l.split(":")[2].to_s.start_with? '/docker/' }
+    return true if in_docker
+    return false
+  end
+
+  def self.zlinux?
+    "zlinux"
+  end
+
+  ##
+  # read_sysfs Reads the raw data as per the documentation at [Detecting if You
+  # Are Running in Google Compute
+  # Engine](https://developers.google.com/compute/docs/instances#dmi)  This
+  # method is intended to provide an easy seam to mock.
+  #
+  # @api public
+  #
+  # @return [String] or nil if the path does not exist or is unreadable
+  def self.read_sysfs_dmi_entries(path="/sys/firmware/dmi/entries/1-0/raw")
+    if File.readable?(path)
+      Facter::Util::FileRead.read_binary(path)
+    end
+  end
+end

data/lib/facter/util/vlans.rb

@@ -0,0 +1,21 @@
+# A module to gather vlan facts
+#
+module Facter::Util::Vlans
+  def self.get_vlan_config
+    if File.exist?('/proc/net/vlan/config') and File.readable?('/proc/net/vlan/config')
+      File.read('/proc/net/vlan/config')
+    end
+  end
+
+  def self.get_vlans
+    if (config = self.get_vlan_config)
+      vlans = []
+      config.each_line do |line|
+        if (match = line.match(/^([0-9A-Za-z]+)\.([0-9]+) /))
+          vlans << match[2] if match[2]
+        end
+      end
+      vlans.join(',') unless vlans.empty?
+    end
+  end
+end

data/lib/facter/util/windows_root.rb

@@ -0,0 +1,7 @@
+require 'win32/security'
+
+module Facter::Util::Root
+  def self.root?
+    Win32::Security.elevated_security?
+  end
+end

data/lib/facter/util/wmi.rb

@@ -0,0 +1,16 @@
+module Facter::Util::WMI
+  class << self
+    def connect(uri = wmi_resource_uri)
+      require 'win32ole'
+      WIN32OLE.connect(uri)
+    end
+
+    def wmi_resource_uri( host = '.' )
+      "winmgmts:{impersonationLevel=impersonate}!//#{host}/root/cimv2"
+    end
+
+    def execquery(query)
+      connect().execquery(query)
+    end
+  end
+end

data/lib/facter/util/xendomains.rb

@@ -0,0 +1,10 @@
+# A module to gather running Xen Domains
+#
+module Facter::Util::Xendomains
+  def self.get_domains
+    if xm_list = Facter::Core::Execution.exec('/usr/sbin/xm list 2>/dev/null')
+      domains = xm_list.split("\n").reject { |line| line =~ /^(Name|Domain-0)/ }
+      domains.map { |line| line.split(/\s/)[0] }.join(',')
+    end
+  end
+end

data/lib/facter/version.rb

@@ -0,0 +1,86 @@
+module Facter
+  if not defined? FACTERVERSION then
+    FACTERVERSION = '2.1.0'
+  end
+
+  # Returns the running version of Facter.
+  #
+  # @comment The intent is that software external to Facter be able to
+  #   determine the Facter version with no side-effects.  The expected
+  #   use is:
+  #
+  #     require 'facter/version'
+  #     version = Facter.version
+  #
+  #   This function has the following ordering precedence.  This precedence list
+  #   is designed to facilitate automated packaging tasks by simply writing to
+  #   the VERSION file in the same directory as this source file.
+  #
+  #    1. If a version has been explicitly assigned using the Facter.version=
+  #       method, return that version.
+  #    2. If there is a VERSION file, read the contents, trim any
+  #       trailing whitespace, and return that version string.
+  #    3. Return the value of the Facter::FACTERVERSION constant hard-coded into
+  #       the source code.
+  #
+  #   If there is no VERSION file, the method must return the version string of
+  #   the nearest parent version that is an officially released version.  That is
+  #   to say, if a branch named 3.1.x contains 25 patches on top of the most
+  #   recent official release of 3.1.1, then the version method must return the
+  #   string "3.1.1" if no "VERSION" file is present.
+  #
+  #   By design the version identifier is _not_ intended to vary during the life of
+  #   a process.  There is no guarantee provided that writing to the VERSION file
+  #   while a Puppet process is running will cause the version string to be
+  #   updated.  On the contrary, the contents of the VERSION are cached to reduce
+  #   filesystem accesses.
+  #
+  #   The VERSION file is intended to be used by package maintainers who may be
+  #   applying patches or otherwise changing the software version in a manner
+  #   that warrants a different software version identifier.  The VERSION file is
+  #   intended to be managed and owned by the release process and packaging
+  #   related tasks, and as such should not reside in version control.  The
+  #   FACTERVERSION constant is intended to be version controlled in history.
+  #
+  #   Ideally, this behavior will allow package maintainers to precisely specify
+  #   the version of the software they're packaging as in the following example:
+  #
+  #       $ git describe > lib/facter/VERSION
+  #       $ ruby -r facter -e 'puts Facter.version'
+  #       1.6.14-6-g66f2c99
+  #
+  # @api public
+  #
+  # @return [String] containing the facter version, e.g. "1.6.14"
+  def self.version
+    version_file = File.join(File.dirname(__FILE__), 'VERSION')
+    return @facter_version if @facter_version
+    if version = read_version_file(version_file)
+      @facter_version = version
+    end
+    @facter_version ||= FACTERVERSION
+  end
+
+  # Sets the Facter version
+  #
+  # @return [void]
+  #
+  # @api private
+  def self.version=(version)
+    @facter_version = version
+  end
+
+  # This reads the content of the "VERSION" file that lives in the
+  # same directory as this source code file.
+  #
+  # @api private
+  #
+  # @return [String] the version -- for example: "1.6.14-6-gea42046" or nil if the VERSION
+  #   file does not exist.
+  def self.read_version_file(path)
+    if File.exists?(path)
+      File.read(path).chomp
+    end
+  end
+  private_class_method :read_version_file
+end

data/lib/facter/virtual.rb

@@ -0,0 +1,311 @@
+# Fact: virtual
+#
+# Purpose: Determine if the system's hardware is real or virtualised.
+#
+# Resolution:
+#   Assumes physical unless proven otherwise.
+#
+#   On Darwin, use the macosx util module to acquire the SPHardwareDataType and
+#   SPEthernetDataType, from which it is possible to determine if the host is a
+#   VMware, Parallels, or VirtualBox.  This previously used SPDisplaysDataType
+#   which was not reliable if running headless, and also caused lagging issues
+#   on actual Macs.
+#
+#   On Linux, BSD, Solaris and HPUX:
+#   Much of the logic here is obscured behind util/virtual.rb, which rather
+#   than document here, which would encourage drift, just refer to it.
+#   The Xen tests in here rely on /sys and /proc, and check for the presence and
+#   contents of files in there.
+#   If after all the other tests, it's still seen as physical, then it tries to
+#   parse the output of the "lspci", "dmidecode" and "prtdiag" and parses them
+#   for obvious signs of being under VMware, Parallels or VirtualBox.
+#   Finally it checks for the existence of vmware-vmx, which would hint it's
+#   VMware.
+#
+# Caveats:
+#   Many checks rely purely on existence of files.
+#
+
+require 'facter/util/virtual'
+
+Facter.add("virtual") do
+  confine :kernel => "Darwin"
+
+  setcode do
+    require 'facter/util/macosx'
+    result = "physical"
+    # use SPHardwareDataType for VMware and VirtualBox, since it is the most
+    # reliable source.
+    output = Facter::Util::Macosx.profiler_data("SPHardwareDataType")
+    if output.is_a?(Hash)
+      result = "vmware" if output["machine_model"] =~ /VMware/
+      result = "virtualbox" if output["boot_rom_version"] =~ /VirtualBox/
+    end
+    # Parallels passes through almost all of the host's hardware info to the
+    # virtual machine, so use a different field.
+    output = Facter::Util::Macosx.profiler_data("SPEthernetDataType")
+    if output.is_a?(Hash)
+      result = "parallels" if output["spethernet_subsystem-vendor-id"] =~ /0x1ab8/
+    end
+    result
+  end
+end
+
+Facter.add("virtual") do
+  confine :kernel => ["FreeBSD", "GNU/kFreeBSD"]
+  has_weight 10
+  setcode do
+    "jail" if Facter::Util::Virtual.jail?
+  end
+end
+
+Facter.add("virtual") do
+  confine :kernel => 'SunOS'
+  has_weight 10
+  self.timeout = 6
+
+  setcode do
+    next "zone" if Facter::Util::Virtual.zone?
+
+    output = Facter::Core::Execution.exec('prtdiag')
+    if output
+      lines = output.split("\n")
+      next "parallels"  if lines.any? {|l| l =~ /Parallels/ }
+      next "vmware"     if lines.any? {|l| l =~ /VM[wW]are/ }
+      next "virtualbox" if lines.any? {|l| l =~ /VirtualBox/ }
+      next "xenhvm"     if lines.any? {|l| l =~ /HVM domU/ }
+    end
+  end
+end
+
+Facter.add("virtual") do
+  confine :kernel => 'HP-UX'
+  has_weight 10
+  setcode do
+    "hpvm" if Facter::Util::Virtual.hpvm?
+  end
+end
+
+Facter.add("virtual") do
+  confine :architecture => 's390x'
+  has_weight 10
+  setcode do
+    "zlinux" if Facter::Util::Virtual.zlinux?
+  end
+end
+
+Facter.add("virtual") do
+  confine :kernel => 'OpenBSD'
+  has_weight 10
+  setcode do
+    output = Facter::Util::POSIX.sysctl("hw.product")
+    if output
+      lines = output.split("\n")
+      next "parallels"  if lines.any? {|l| l =~ /Parallels/ }
+      next "vmware"     if lines.any? {|l| l =~ /VMware/ }
+      next "virtualbox" if lines.any? {|l| l =~ /VirtualBox/ }
+      next "xenhvm"     if lines.any? {|l| l =~ /HVM domU/ }
+      next "ovirt"      if lines.any? {|l| l =~ /oVirt Node/ }
+    end
+  end
+end
+
+Facter.add("virtual") do
+  confine :kernel => %w{Linux FreeBSD OpenBSD SunOS HP-UX GNU/kFreeBSD}
+
+  setcode do
+    next Facter::Util::Virtual.openvz_type if Facter::Util::Virtual.openvz?
+    next Facter::Util::Virtual.vserver_type if Facter::Util::Virtual.vserver?
+
+    if Facter::Util::Virtual.xen?
+      next "xen0" if FileTest.exists?("/dev/xen/evtchn")
+      next "xenu" if FileTest.exists?("/proc/xen")
+    end
+
+    next "virtualbox" if Facter::Util::Virtual.virtualbox?
+    next Facter::Util::Virtual.kvm_type if Facter::Util::Virtual.kvm?
+    next "rhev" if Facter::Util::Virtual.rhev?
+    next "ovirt" if Facter::Util::Virtual.ovirt?
+
+    # Parse lspci
+    output = Facter::Util::Virtual.lspci
+    if output
+      lines = output.split("\n")
+      next "vmware"     if lines.any? {|l| l =~ /VM[wW]are/ }
+      next "virtualbox" if lines.any? {|l| l =~ /VirtualBox/ }
+      next "parallels"  if lines.any? {|l| l =~ /1ab8:|[Pp]arallels/ }
+      next "xenhvm"     if lines.any? {|l| l =~ /XenSource/ }
+      next "hyperv"     if lines.any? {|l| l =~ /Microsoft Corporation Hyper-V/ }
+      next "gce"        if lines.any? {|l| l =~ /Class 8007: Google, Inc/ }
+    end
+
+    # Parse dmidecode
+    output = Facter::Core::Execution.exec('dmidecode 2> /dev/null')
+    if output
+      lines = output.split("\n")
+      next "parallels"  if lines.any? {|l| l =~ /Parallels/ }
+      next "vmware"     if lines.any? {|l| l =~ /VMware/ }
+      next "virtualbox" if lines.any? {|l| l =~ /VirtualBox/ }
+      next "xenhvm"     if lines.any? {|l| l =~ /HVM domU/ }
+      next "hyperv"     if lines.any? {|l| l =~ /Product Name: Virtual Machine/ }
+      next "rhev"       if lines.any? {|l| l =~ /Product Name: RHEV Hypervisor/ }
+      next "ovirt"      if lines.any? {|l| l =~ /Product Name: oVirt Node/ }
+    end
+
+    # Default to 'physical'
+    next 'physical'
+  end
+end
+
+Facter.add("virtual") do
+  confine do
+    Facter::Core::Execution.which('vmware')
+  end
+
+  setcode do
+    # Sample output of vmware -v `VMware Server 1.0.5 build-80187`
+    output = Facter::Core::Execution.exec("vmware -v")
+    if output
+      mdata = output.match /(\S+)\s+(\S+)/
+      next "#{mdata[1]}_#{mdata[2]}".downcase if mdata
+    end
+  end
+end
+
+Facter.add("virtual") do
+  confine :kernel => "windows"
+  setcode do
+      require 'facter/util/wmi'
+      result = nil
+      Facter::Util::WMI.execquery("SELECT manufacturer, model FROM Win32_ComputerSystem").each do |computersystem|
+        case computersystem.model
+        when /VirtualBox/
+          result = "virtualbox"
+        when /Virtual Machine/
+          result = "hyperv" if computersystem.manufacturer =~ /Microsoft/
+        when /VMware/
+          result = "vmware"
+        when /KVM/
+          result = "kvm"
+        when /Bochs/
+          result = "bochs"
+        end
+
+        if result.nil? and computersystem.manufacturer =~ /Xen/
+          result = "xen"
+        end
+
+        break
+      end
+      result ||= "physical"
+
+      result
+  end
+end
+
+##
+# virtual fact based on virt-what command.
+#
+# The output is mapped onto existing known values for the virtual fact in an
+# effort to preserve consistency.  This fact has a high weight becuase the
+# virt-what tool is expected to be maintained upstream.
+#
+# If the virt-what command is not available, this fact will not resolve to a
+# value and lower-weight virtual facts will be attempted.
+#
+# Only the last line of the virt-what command is returned
+Facter.add("virtual") do
+  has_weight 500
+
+  setcode do
+    if output = Facter::Util::Virtual.virt_what
+      case output
+      when 'linux_vserver'
+        Facter::Util::Virtual.vserver_type
+      when /xen-hvm/i
+        'xenhvm'
+      when /xen-dom0/i
+        'xen0'
+      when /xen-domU/i
+        'xenu'
+      when /ibm_systemz/i
+        'zlinux'
+      else
+        output.to_s.split("\n").last
+      end
+    end
+  end
+end
+
+##
+# virtual fact specific to Google Compute Engine's Linux sysfs entry.
+Facter.add("virtual") do
+  has_weight 600
+  confine :kernel => "Linux"
+
+  setcode do
+    if dmi_data = Facter::Util::Virtual.read_sysfs_dmi_entries
+      case dmi_data
+      when /Google/
+        "gce"
+      end
+    end
+  end
+end
+
+##
+# virtual fact specific to linux containers.  This also works for Docker
+# containers running in lxc.
+Facter.add("virtual") do
+  has_weight 700
+  confine :kernel => "Linux"
+
+  setcode do
+    "lxc" if Facter::Util::Virtual.lxc?
+  end
+end
+
+##
+# virtual fact specific to docker containers.
+Facter.add("virtual") do
+  has_weight 750
+  confine :kernel => "Linux"
+
+  setcode do
+    "docker" if Facter::Util::Virtual.docker?
+  end
+end
+
+Facter.add("virtual") do
+  has_weight 600
+  confine :kernel => "Linux"
+
+  setcode do
+    "gce" if Facter::Util::Virtual.gce?
+  end
+end
+
+# Fact: is_virtual
+#
+# Purpose: returning true or false for if a machine is virtualised or not.
+#
+# Resolution: Hypervisors and the like may be detected as a virtual type, but
+# are not actual virtual machines, or should not be treated as such. This
+# determines if the host is actually virtualized.
+#
+# Caveats:
+#
+
+Facter.add("is_virtual") do
+  confine :kernel => %w{Linux FreeBSD OpenBSD SunOS HP-UX Darwin GNU/kFreeBSD windows}
+
+  setcode do
+    physical_types = %w{physical xen0 vmware_server vmware_workstation openvzhn vserver_host}
+
+    if physical_types.include? Facter.value(:virtual)
+      "false"
+    else
+      "true"
+    end
+  end
+end