bolt 0.20.0 → 0.20.2

data/vendored/facter/lib/facter/util/windows/user.rb

@@ -0,0 +1,186 @@
+require 'facter/util/windows'
+require 'ffi'
+
+module Facter::Util::Windows::User
+  extend FFI::Library
+
+  def admin?
+    elevated_supported = Facter::Util::Windows::Process.supports_elevated_security?
+
+    # if Vista or later, check for unrestricted process token
+    return Facter::Util::Windows::Process.elevated_security? if elevated_supported
+
+    # otherwise 2003 or less
+    check_token_membership
+  end
+  module_function :admin?
+
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/ee207397(v=vs.85).aspx
+  SECURITY_MAX_SID_SIZE = 68
+
+  def check_token_membership
+    is_admin = false
+    FFI::MemoryPointer.new(:byte, SECURITY_MAX_SID_SIZE) do |sid_pointer|
+      FFI::MemoryPointer.new(:dword, 1) do |size_pointer|
+        size_pointer.write_uint32(SECURITY_MAX_SID_SIZE)
+
+        if CreateWellKnownSid(:WinBuiltinAdministratorsSid, FFI::Pointer::NULL, sid_pointer, size_pointer) == Facter::Util::Windows::FFI::WIN32_FALSE
+          raise Facter::Util::Windows::Error.new("Failed to create administrators SID")
+        end
+      end
+
+      if IsValidSid(sid_pointer) == Facter::Util::Windows::FFI::WIN32_FALSE
+        raise RuntimeError,"Invalid SID"
+      end
+
+      FFI::MemoryPointer.new(:win32_bool, 1) do |ismember_pointer|
+        if CheckTokenMembership(Facter::Util::Windows::FFI::NULL_HANDLE, sid_pointer, ismember_pointer) == Facter::Util::Windows::FFI::WIN32_FALSE
+          raise Facter::Util::Windows::Error.new("Failed to check membership")
+        end
+
+        # Is administrators SID enabled in calling thread's access token?
+        is_admin = Facter::Util::Windows::FFI.read_win32_bool(ismember_pointer)
+      end
+    end
+
+    is_admin
+  end
+  module_function :check_token_membership
+
+  private
+
+  ffi_convention :stdcall
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa376389(v=vs.85).aspx
+  # BOOL WINAPI CheckTokenMembership(
+  #   _In_opt_  HANDLE TokenHandle,
+  #   _In_      PSID SidToCheck,
+  #   _Out_     PBOOL IsMember
+  # );
+  ffi_lib :advapi32
+  attach_function :CheckTokenMembership,
+                  [:handle, :pointer, :pbool], :win32_bool
+
+  public
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379650(v=vs.85).aspx
+  WELL_KNOWN_SID_TYPE = enum(
+      :WinNullSid                                   , 0,
+      :WinWorldSid                                  , 1,
+      :WinLocalSid                                  , 2,
+      :WinCreatorOwnerSid                           , 3,
+      :WinCreatorGroupSid                           , 4,
+      :WinCreatorOwnerServerSid                     , 5,
+      :WinCreatorGroupServerSid                     , 6,
+      :WinNtAuthoritySid                            , 7,
+      :WinDialupSid                                 , 8,
+      :WinNetworkSid                                , 9,
+      :WinBatchSid                                  , 10,
+      :WinInteractiveSid                            , 11,
+      :WinServiceSid                                , 12,
+      :WinAnonymousSid                              , 13,
+      :WinProxySid                                  , 14,
+      :WinEnterpriseControllersSid                  , 15,
+      :WinSelfSid                                   , 16,
+      :WinAuthenticatedUserSid                      , 17,
+      :WinRestrictedCodeSid                         , 18,
+      :WinTerminalServerSid                         , 19,
+      :WinRemoteLogonIdSid                          , 20,
+      :WinLogonIdsSid                               , 21,
+      :WinLocalSystemSid                            , 22,
+      :WinLocalServiceSid                           , 23,
+      :WinNetworkServiceSid                         , 24,
+      :WinBuiltinDomainSid                          , 25,
+      :WinBuiltinAdministratorsSid                  , 26,
+      :WinBuiltinUsersSid                           , 27,
+      :WinBuiltinGuestsSid                          , 28,
+      :WinBuiltinPowerUsersSid                      , 29,
+      :WinBuiltinAccountOperatorsSid                , 30,
+      :WinBuiltinSystemOperatorsSid                 , 31,
+      :WinBuiltinPrintOperatorsSid                  , 32,
+      :WinBuiltinBackupOperatorsSid                 , 33,
+      :WinBuiltinReplicatorSid                      , 34,
+      :WinBuiltinPreWindows2000CompatibleAccessSid  , 35,
+      :WinBuiltinRemoteDesktopUsersSid              , 36,
+      :WinBuiltinNetworkConfigurationOperatorsSid   , 37,
+      :WinAccountAdministratorSid                   , 38,
+      :WinAccountGuestSid                           , 39,
+      :WinAccountKrbtgtSid                          , 40,
+      :WinAccountDomainAdminsSid                    , 41,
+      :WinAccountDomainUsersSid                     , 42,
+      :WinAccountDomainGuestsSid                    , 43,
+      :WinAccountComputersSid                       , 44,
+      :WinAccountControllersSid                     , 45,
+      :WinAccountCertAdminsSid                      , 46,
+      :WinAccountSchemaAdminsSid                    , 47,
+      :WinAccountEnterpriseAdminsSid                , 48,
+      :WinAccountPolicyAdminsSid                    , 49,
+      :WinAccountRasAndIasServersSid                , 50,
+      :WinNTLMAuthenticationSid                     , 51,
+      :WinDigestAuthenticationSid                   , 52,
+      :WinSChannelAuthenticationSid                 , 53,
+      :WinThisOrganizationSid                       , 54,
+      :WinOtherOrganizationSid                      , 55,
+      :WinBuiltinIncomingForestTrustBuildersSid     , 56,
+      :WinBuiltinPerfMonitoringUsersSid             , 57,
+      :WinBuiltinPerfLoggingUsersSid                , 58,
+      :WinBuiltinAuthorizationAccessSid             , 59,
+      :WinBuiltinTerminalServerLicenseServersSid    , 60,
+      :WinBuiltinDCOMUsersSid                       , 61,
+      :WinBuiltinIUsersSid                          , 62,
+      :WinIUserSid                                  , 63,
+      :WinBuiltinCryptoOperatorsSid                 , 64,
+      :WinUntrustedLabelSid                         , 65,
+      :WinLowLabelSid                               , 66,
+      :WinMediumLabelSid                            , 67,
+      :WinHighLabelSid                              , 68,
+      :WinSystemLabelSid                            , 69,
+      :WinWriteRestrictedCodeSid                    , 70,
+      :WinCreatorOwnerRightsSid                     , 71,
+      :WinCacheablePrincipalsGroupSid               , 72,
+      :WinNonCacheablePrincipalsGroupSid            , 73,
+      :WinEnterpriseReadonlyControllersSid          , 74,
+      :WinAccountReadonlyControllersSid             , 75,
+      :WinBuiltinEventLogReadersGroup               , 76,
+      :WinNewEnterpriseReadonlyControllersSid       , 77,
+      :WinBuiltinCertSvcDComAccessGroup             , 78,
+      :WinMediumPlusLabelSid                        , 79,
+      :WinLocalLogonSid                             , 80,
+      :WinConsoleLogonSid                           , 81,
+      :WinThisOrganizationCertificateSid            , 82,
+      :WinApplicationPackageAuthoritySid            , 83,
+      :WinBuiltinAnyPackageSid                      , 84,
+      :WinCapabilityInternetClientSid               , 85,
+      :WinCapabilityInternetClientServerSid         , 86,
+      :WinCapabilityPrivateNetworkClientServerSid   , 87,
+      :WinCapabilityPicturesLibrarySid              , 88,
+      :WinCapabilityVideosLibrarySid                , 89,
+      :WinCapabilityMusicLibrarySid                 , 90,
+      :WinCapabilityDocumentsLibrarySid             , 91,
+      :WinCapabilitySharedUserCertificatesSid       , 92,
+      :WinCapabilityEnterpriseAuthenticationSid     , 93,
+      :WinCapabilityRemovableStorageSid             , 94
+  )
+
+  private
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa446585(v=vs.85).aspx
+  # BOOL WINAPI CreateWellKnownSid(
+  #   _In_       WELL_KNOWN_SID_TYPE WellKnownSidType,
+  #   _In_opt_   PSID DomainSid,
+  #   _Out_opt_  PSID pSid,
+  #   _Inout_    DWORD *cbSid
+  # );
+  ffi_lib :advapi32
+  attach_function :CreateWellKnownSid,
+                  [WELL_KNOWN_SID_TYPE, :pointer, :pointer, :lpdword], :win32_bool
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379151(v=vs.85).aspx
+  # BOOL WINAPI IsValidSid(
+  #   _In_  PSID pSid
+  # );
+  ffi_lib :advapi32
+  attach_function :IsValidSid,
+                  [:pointer], :win32_bool
+end

data/vendored/facter/lib/facter/util/windows_root.rb

@@ -0,0 +1,7 @@
+require 'facter/util/windows'
+
+module Facter::Util::Root
+  def self.root?
+    Facter::Util::Windows::User.admin?
+  end
+end

data/vendored/facter/lib/facter/util/wmi.rb

@@ -0,0 +1,49 @@
+module Facter::Util::WMI
+  class << self
+
+    # Impersonation Level Constants
+    # https://msdn.microsoft.com/en-us/library/windows/desktop/ms693790%28v=vs.85%29.aspx
+    RPC_C_IMP_LEVEL_DEFAULT       = 0
+    RPC_C_IMP_LEVEL_ANONYMOUS     = 1
+    RPC_C_IMP_LEVEL_IDENTIFY      = 2
+    RPC_C_IMP_LEVEL_IMPERSONATE   = 3
+    RPC_C_IMP_LEVEL_DELEGATE      = 4
+
+    # returns a COM class implementing ISWbemServicesEx
+    # prior to Facter 2.5.0, this defaulted to using a moniker
+    # but now defaults to using COM classes directly to support Nano
+    # backward compatibility is maintained in case custom facts specified a moniker
+    # but note that passing in the uri parameter can never work on Nano
+    def connect(uri = nil)
+      require 'win32ole'
+      uri.nil? ?
+        connect2() :
+        # NOTE: in the future it would be better to parse a given moniker uri / call connect2
+        WIN32OLE.connect(uri)
+    end
+
+    # @deprecated
+    def wmi_resource_uri( host = '.' )
+      "winmgmts:{impersonationLevel=impersonate}!//#{host}/root/cimv2"
+    end
+
+    def execquery(query)
+      connect().execquery(query)
+    end
+
+    private
+
+    # this mimics the previous behavior of using the COM moniker
+    # winmgmts:{impersonationLevel=impersonate}!//./root/cimv2
+    # which is not supported on Nano Server
+    def connect2( server = '.', namespace = 'root\\cimv2', impersonation_level = RPC_C_IMP_LEVEL_IMPERSONATE )
+      locator = WIN32OLE.new("WbemScripting.SWbemLocator")
+      # https://msdn.microsoft.com/en-us/library/aa393720%28v=vs.85%29.aspx
+      # ConnectServer returns an ISWbemServicesEx
+      conn = locator.ConnectServer(server, namespace)
+      conn.Security_.ImpersonationLevel = impersonation_level
+      conn
+    end
+
+  end
+end

data/vendored/facter/lib/facter/util/xendomains.rb

@@ -0,0 +1,28 @@
+# A module to gather running Xen Domains
+#
+module Facter::Util::Xendomains
+  XEN_COMMANDS = ['/usr/sbin/xl', '/usr/sbin/xm']
+
+  def self.xen_command
+    if File.file?('/usr/lib/xen-common/bin/xen-toolstack')
+      xen_toolstack_cmd = Facter::Util::Resolution.exec('/usr/lib/xen-common/bin/xen-toolstack')
+      if xen_toolstack_cmd
+        xen_toolstack_cmd.chomp
+      else
+        nil
+      end
+    else
+      XEN_COMMANDS.find { |cmd| Facter::Util::Resolution.which(cmd) }
+    end
+  end
+
+  def self.get_domains
+    command = self.xen_command
+    if command
+      if domains_list = Facter::Util::Resolution.exec("#{command} list 2>/dev/null")
+        domains = domains_list.split("\n").reject { |line| line =~ /^(Name|Domain-0)/ }
+        domains.map { |line| line.split(/\s/)[0] }.join(',')
+      end
+    end
+  end
+end

data/vendored/facter/lib/facter/version.rb

@@ -0,0 +1,86 @@
+module Facter
+  if not defined? FACTERVERSION then
+    FACTERVERSION = '2.5.1'
+  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/vendored/facter/lib/facter/virtual.rb

@@ -0,0 +1,330 @@
+# Fact: virtual
+#
+# Purpose: Determine if the system's hardware is real or virtualized.
+#
+# 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 you can consult directly for more detailed resolution
+#   information.
+#   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 that
+#   it's VMware.
+#
+# Caveats:
+#   Many checks rely purely on existence of files.
+#
+
+# Fact: is_virtual
+#
+# Purpose: Return `true` or `false` depending on whether a machine is virtualized 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:
+#
+
+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 = 20
+
+  setcode do
+    next "zone" if Facter::Util::Virtual.zone?
+
+    output = Facter::Core::Execution.exec('prtdiag 2>/dev/null')
+    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 => 'SunOS'
+  confine :hardwareisa => 'sparc'
+  confine :ldom_domainrole_control => 'false'
+  has_weight 20 # Weight this before the default solaris implementation
+  setcode do
+    Facter.value(:ldom_domainrole_impl)
+  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/ }
+      next "kvm"        if lines.any? {|l| l =~ /KVM/ }
+    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") || FileTest.exists?("/dev/xvda1")
+    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/ }
+      next "kvm"        if lines.any? {|l| l =~ /virtio/i }
+    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/ }
+      next "bochs"      if lines.any? {|l| l =~ /Bochs/ }
+      next "kvm"        if lines.any? {|l| l =~ /Manufacturer: QEMU/ }
+    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"
+        when /OpenStack/
+          result = "openstack"
+        when /Google Compute Engine/
+          result = "gce"
+        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
+
+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