facter 2.0.1.rc1-x86-mingw32

data/ext/solaris/pkginfo

@@ -0,0 +1,7 @@
+PKG=CSWfacter
+NAME=facter - System Fact Gatherer
+VERSION=1.6.3rc1
+CATEGORY=application
+VENDOR=http://www.puppetlabs.com/puppet/related-projects/facter
+HOTLINE=http://puppetlabs.com/cgi-bin/facter.cgi
+EMAIL=luke@madstop.com

data/install.rb

@@ -0,0 +1,380 @@
+#! /usr/bin/env ruby
+#--
+# Copyright 2004 Austin Ziegler <ruby-install@halostatue.ca>
+#   Install utility. Based on the original installation script for rdoc by the
+#   Pragmatic Programmers.
+#
+# This program is free software. It may be redistributed and/or modified under
+# the terms of the GPL version 2 (or later) or the Ruby licence.
+#
+# Usage
+# -----
+# In most cases, if you have a typical project layout, you will need to do
+# absolutely nothing to make this work for you. This layout is:
+#
+#   bin/  # executable files -- "commands"
+#   lib/  # the source of the library
+#
+# The default behaviour:
+# 1) Build Rdoc documentation from all files in bin/ (excluding .bat and .cmd),
+#  all .rb files in lib/, ./README, ./ChangeLog, and ./Install.
+# 2) Build ri documentation from all files in bin/ (excluding .bat and .cmd),
+#  and all .rb files in lib/. This is disabled by default on Win32.
+# 3) Install commands from bin/ into the Ruby bin directory. On Windows, if a
+#  if a corresponding batch file (.bat or .cmd) exists in the bin directory,
+#  it will be copied over as well. Otherwise, a batch file (always .bat) will
+#  be created to run the specified command.
+# 4) Install all library files ending in .rb from lib/ into Ruby's
+#  site_lib/version directory.
+#
+#++
+
+require 'rbconfig'
+require 'find'
+require 'fileutils'
+require 'optparse'
+require 'ostruct'
+require 'tempfile'
+
+begin
+  require 'rdoc/rdoc'
+  $haverdoc = true
+rescue LoadError
+  puts "Missing rdoc; skipping documentation"
+  $haverdoc = false
+end
+
+begin
+  if $haverdoc
+     rst2man = %x{which rst2man.py}
+     $haveman = true
+  else
+     $haveman = false
+  end
+rescue
+  puts "Missing rst2man; skipping man page creation"
+  $haveman = false
+end
+
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'lib')))
+require 'facter'
+@operatingsystem = Facter[:operatingsystem].value
+
+PREREQS = %w{cgi}
+
+InstallOptions = OpenStruct.new
+
+def glob(list)
+  g = list.map { |i| Dir.glob(i) }
+  g.flatten!
+  g.compact!
+  g
+end
+
+def do_bins(bins, target, strip = 's?bin/')
+  bins.each do |bf|
+    obf = bf.gsub(/#{strip}/, '')
+      install_binfile(bf, obf, target)
+  end
+end
+
+def do_libs(libs, strip = 'lib/')
+  libs.each do |lf|
+    olf = File.join(InstallOptions.site_dir, lf.gsub(/^#{strip}/, ''))
+    op = File.dirname(olf)
+    FileUtils.makedirs(op, {:mode => 0755, :verbose => true})
+    FileUtils.chmod(0755, op)
+    FileUtils.install(lf, olf, {:mode => 0644, :preserve => true, :verbose => true})
+  end
+end
+
+def do_man(man, strip = 'man/')
+  if (InstallOptions.man == true)
+  man.each do |mf|
+    omf = File.join(InstallOptions.man_dir, mf.gsub(/#{strip}/, ''))
+    om = File.dirname(omf)
+    FileUtils.makedirs(om, {:mode => 0755, :verbose => true})
+    FileUtils.chmod(0755, om)
+    FileUtils.install(mf, omf, {:mode => 0644, :preserve => true, :verbose => true})
+    gzip = %x{which gzip}
+    gzip.chomp!
+    %x{#{gzip} -f #{omf}}
+  end
+  else
+  puts "Skipping Man Page Generation"
+  end
+end
+
+# Verify that all of the prereqs are installed
+def check_prereqs
+  PREREQS.each { |pre|
+    begin
+      require pre
+    rescue LoadError
+      puts "Could not load #{pre} Ruby library; cannot install"
+      exit -1
+    end
+  }
+end
+
+def is_windows?
+  @operatingsystem == 'windows'
+end
+
+##
+# Prepare the file installation.
+#
+def prepare_installation
+  # Only try to do docs if we're sure they have rdoc
+  if $haverdoc
+    InstallOptions.rdoc  = true
+    if is_windows?
+      InstallOptions.ri  = false
+    else
+      InstallOptions.ri  = true
+    end
+  else
+    InstallOptions.rdoc  = false
+    InstallOptions.ri  = false
+  end
+
+
+  if $haveman
+    InstallOptions.man = true
+    if is_windows?
+      InstallOptions.man  = false
+    end
+  else
+    InstallOptions.man = false
+  end
+
+  ARGV.options do |opts|
+    opts.banner = "Usage: #{File.basename($0)} [options]"
+    opts.separator ""
+    opts.on('--[no-]rdoc', 'Prevents the creation of RDoc output.', 'Default on.') do |onrdoc|
+      InstallOptions.rdoc = onrdoc
+    end
+    opts.on('--[no-]ri', 'Prevents the creation of RI output.', 'Default off on mswin32.') do |onri|
+      InstallOptions.ri = onri
+    end
+    opts.on('--[no-]man', 'Presents the creation of man pages.', 'Default on.') do |onman|
+    InstallOptions.man = onman
+    end
+    opts.on('--destdir[=OPTIONAL]', 'Installation prefix for all targets', 'Default essentially /') do |destdir|
+      InstallOptions.destdir = destdir
+    end
+    opts.on('--bindir[=OPTIONAL]', 'Installation directory for binaries', 'overrides RbConfig::CONFIG["bindir"]') do |bindir|
+      InstallOptions.bindir = bindir
+    end
+    opts.on('--ruby[=OPTIONAL]', 'Ruby interpreter to use with installation', 'overrides ruby used to call install.rb') do |ruby|
+      InstallOptions.ruby = ruby
+    end
+    opts.on('--sitelibdir[=OPTIONAL]', 'Installation directory for libraries', 'overrides RbConfig::CONFIG["sitelibdir"]') do |sitelibdir|
+      InstallOptions.sitelibdir = sitelibdir
+    end
+    opts.on('--mandir[=OPTIONAL]', 'Installation directory for man pages', 'overrides RbConfig::CONFIG["mandir"]') do |mandir|
+      InstallOptions.mandir = mandir
+    end
+    opts.on('--quick', 'Performs a quick installation. Only the', 'installation is done.') do |quick|
+      InstallOptions.rdoc   = false
+      InstallOptions.ri   = false
+    end
+    opts.on('--full', 'Performs a full installation. All', 'optional installation steps are run.') do |full|
+      InstallOptions.rdoc   = true
+      InstallOptions.ri   = true
+    end
+    opts.separator("")
+    opts.on_tail('--help', "Shows this help text.") do
+      $stderr.puts opts
+      exit
+    end
+
+    opts.parse!
+  end
+
+  version = [RbConfig::CONFIG["MAJOR"], RbConfig::CONFIG["MINOR"]].join(".")
+  libdir = File.join(RbConfig::CONFIG["libdir"], "ruby", version)
+
+  # Mac OS X 10.5 and higher declare bindir
+  # /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin
+  # which is not generally where people expect executables to be installed
+  # These settings are appropriate defaults for all OS X versions.
+  if RUBY_PLATFORM =~ /^universal-darwin[\d\.]+$/
+    RbConfig::CONFIG['bindir'] = "/usr/bin"
+  end
+
+  if not InstallOptions.bindir.nil?
+    bindir = InstallOptions.bindir
+  else
+    bindir = RbConfig::CONFIG['bindir']
+  end
+
+  if not InstallOptions.sitelibdir.nil?
+    sitelibdir = InstallOptions.sitelibdir
+  else
+    sitelibdir = RbConfig::CONFIG["sitelibdir"]
+    if sitelibdir.nil?
+      sitelibdir = $:.find { |x| x =~ /site_ruby/ }
+      if sitelibdir.nil?
+        sitelibdir = File.join(libdir, "site_ruby")
+      elsif sitelibdir !~ Regexp.quote(version)
+        sitelibdir = File.join(sitelibdir, version)
+      end
+    end
+  end
+
+  if not InstallOptions.mandir.nil?
+    mandir = InstallOptions.mandir
+  else
+    mandir = RbConfig::CONFIG['mandir']
+  end
+
+  if (destdir = InstallOptions.destdir)
+    bindir = join(destdir, bindir)
+    mandir = join(destdir, mandir)
+    sitelibdir = join(destdir, sitelibdir)
+
+    FileUtils.makedirs(bindir)
+    FileUtils.makedirs(mandir)
+    FileUtils.makedirs(sitelibdir)
+  end
+
+  InstallOptions.site_dir = sitelibdir
+  InstallOptions.bin_dir  = bindir
+  InstallOptions.lib_dir  = libdir
+  InstallOptions.man_dir  = mandir
+end
+
+##
+# Join two paths. On Windows, dir must be converted to a relative path,
+# by stripping the drive letter, but only if the basedir is not empty.
+#
+def join(basedir, dir)
+  return "#{basedir}#{dir[2..-1]}" if is_windows? and basedir.length > 0 and dir.length > 2
+
+  "#{basedir}#{dir}"
+end
+
+##
+# Build the rdoc documentation. Also, try to build the RI documentation.
+#
+def build_rdoc(files)
+  return unless $haverdoc
+  begin
+    r = RDoc::RDoc.new
+    r.document(["--main", "README", "--title",
+      "Puppet -- Site Configuration Management", "--line-numbers"] + files)
+  rescue RDoc::RDocError => e
+    $stderr.puts e.message
+  rescue Exception => e
+    $stderr.puts "Couldn't build RDoc documentation\n#{e.message}"
+  end
+end
+
+def build_ri(files)
+  return unless $haverdoc
+  begin
+    ri = RDoc::RDoc.new
+    #ri.document(["--ri-site", "--merge"] + files)
+    ri.document(["--ri-site"] + files)
+  rescue RDoc::RDocError => e
+    $stderr.puts e.message
+  rescue Exception => e
+    $stderr.puts "Couldn't build Ri documentation\n#{e.message}"
+    $stderr.puts "Continuing with install..."
+  end
+end
+
+def build_man(bins)
+  return unless $haveman
+  begin
+    # Locate rst2man
+    rst2man = %x{which rst2man.py}
+    rst2man.chomp!
+    bins.each do |bin|
+      b = bin.gsub( "bin/", "")
+      %x{#{bin} --help > ./#{b}.rst}
+      %x{#{rst2man} ./#{b}.rst ./man/man8/#{b}.8}
+      File.unlink("./#{b}.rst")
+    end
+  rescue SystemCallError
+    $stderr.puts "Couldn't build man pages: " + $!
+    $stderr.puts "Continuing with install..."
+  end
+end
+
+##
+# Install file(s) from ./bin to RbConfig::CONFIG['bindir']. Patch it on the way
+# to insert a #! line; on a Unix install, the command is named as expected
+# (e.g., bin/rdoc becomes rdoc); the shebang line handles running it. Under
+# windows, we add an '.rb' extension and let file associations do their stuff.
+def install_binfile(from, op_file, target)
+  tmp_file = Tempfile.new('facter-binfile')
+
+  if not InstallOptions.ruby.nil?
+    ruby = InstallOptions.ruby
+  else
+    ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+  end
+
+  File.open(from) do |ip|
+    File.open(tmp_file.path, "w") do |op|
+      op.puts "#!#{ruby}"
+      contents = ip.readlines
+      contents.shift if contents[0] =~ /^#!/
+      op.write contents.join
+    end
+  end
+
+  if is_windows?
+    installed_wrapper = false
+
+    if File.exists?("#{from}.bat")
+      FileUtils.install("#{from}.bat", File.join(target, "#{op_file}.bat"), :mode => 0755, :preserve => true, :verbose => true)
+      installed_wrapper = true
+    end
+
+    if File.exists?("#{from}.cmd")
+      FileUtils.install("#{from}.cmd", File.join(target, "#{op_file}.cmd"), :mode => 0755, :preserve => true, :verbose => true)
+      installed_wrapper = true
+    end
+
+    if not installed_wrapper
+      tmp_file2 = Tempfile.new('facter-wrapper')
+      cwv = <<-EOS
+@echo off
+setlocal
+set RUBY_BIN=%~dp0
+set RUBY_BIN=%RUBY_BIN:\\=/%
+"%RUBY_BIN%ruby.exe" -x "%RUBY_BIN%facter" %*
+EOS
+      File.open(tmp_file2.path, "w") { |cw| cw.puts cwv }
+      FileUtils.install(tmp_file2.path, File.join(target, "#{op_file}.bat"), :mode => 0755, :preserve => true, :verbose => true)
+
+      tmp_file2.unlink
+      installed_wrapper = true
+    end
+  end
+  FileUtils.install(tmp_file.path, File.join(target, op_file), :mode => 0755, :preserve => true, :verbose => true)
+  tmp_file.unlink
+end
+
+# Change directory into the facter root so we don't get the wrong files for install.
+FileUtils.cd File.dirname(__FILE__) do
+  # Set these values to what you want installed.
+  bins  = glob(%w{bin/*})
+  rdoc  = glob(%w{bin/* lib/**/*.rb README* }).reject { |e| e=~ /\.(bat|cmd)$/ }
+  ri  = glob(%w(bin/*.rb lib/**/*.rb)).reject { |e| e=~ /\.(bat|cmd)$/ }
+  man   = glob(%w{man/man8/*})
+  libs  = glob(%w{lib/**/*.rb lib/**/*.py lib/**/LICENSE})
+
+  check_prereqs
+  prepare_installation
+
+  #build_rdoc(rdoc) if InstallOptions.rdoc
+  #build_ri(ri) if InstallOptions.ri
+  #build_man(bins) if InstallOptions.man
+  do_bins(bins, InstallOptions.bin_dir)
+  do_libs(libs)
+  do_man(man)
+end

data/lib/facter.rb

@@ -0,0 +1,262 @@
+# Facter - Host Fact Detection and Reporting
+#
+# Copyright 2011 Puppet Labs Inc
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'facter/version'
+
+# Functions as a hash of 'facts' about your system system, such as MAC
+# address, IP address, architecture, etc.
+#
+# @example Retrieve a fact
+#     puts Facter['operatingsystem'].value
+#
+# @example Retrieve all facts
+#   Facter.to_hash
+#    => { "kernel"=>"Linux", "uptime_days"=>0, "ipaddress"=>"10.0.0.1" }
+#
+# @api public
+module Facter
+  # Most core functionality of facter is implemented in `Facter::Util`.
+  # @api public
+  module Util; end
+
+  require 'facter/util/fact'
+  require 'facter/util/collection'
+  require 'facter/util/monkey_patches'
+
+  include Comparable
+  include Enumerable
+
+  require 'facter/core/logging'
+  extend Facter::Core::Logging
+
+  # module methods
+
+  # Accessor for the collection object which holds all the facts
+  # @return [Facter::Util::Collection] the collection of facts
+  #
+  # @api private
+  def self.collection
+    unless defined?(@collection) and @collection
+      @collection = Facter::Util::Collection.new(
+        Facter::Util::Loader.new,
+        Facter::Util::Config.ext_fact_loader)
+    end
+    @collection
+  end
+
+  # Returns whether the JSON "feature" is available.
+  #
+  # @api private
+  def self.json?
+    begin
+      require 'json'
+      true
+    rescue LoadError
+      false
+    end
+  end
+
+  # Returns a fact object by name.  If you use this, you still have to
+  # call {Facter::Util::Fact#value `value`} on it to retrieve the actual
+  # value.
+  #
+  # @param name [String] the name of the fact
+  #
+  # @return [Facter::Util::Fact, nil] The fact object, or nil if no fact
+  #   is found.
+  #
+  # @api public
+  def self.[](name)
+    collection.fact(name)
+  end
+
+  # (see [])
+  def self.fact(name)
+    collection.fact(name)
+  end
+
+  # Flushes cached values for all facts. This does not cause code to be
+  # reloaded; it only clears the cached results.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.flush
+    collection.flush
+  end
+
+  # Lists all fact names
+  #
+  # @return [Array<String>] array of fact names
+  #
+  # @api public
+  def self.list
+    collection.list
+  end
+
+  # Gets the value for a fact. Returns `nil` if no such fact exists.
+  #
+  # @param name [String] the fact name
+  # @return [Object, nil] the value of the fact, or nil if no fact is
+  #   found
+  #
+  # @api public
+  def self.value(name)
+    collection.value(name)
+  end
+
+  # Gets a hash mapping fact names to their values
+  #
+  # @return [Hash{String => Object}] the hash of fact names and values
+  #
+  # @api public
+  def self.to_hash
+    collection.load_all
+    collection.to_hash
+  end
+
+  # Define a new fact or extend an existing fact.
+  #
+  # @param name [Symbol] The name of the fact to define
+  # @param options [Hash] A hash of options to set on the fact
+  #
+  # @return [Facter::Util::Fact] The fact that was defined
+  #
+  # @api public
+  # @see {Facter::Util::Collection#define_fact}
+  def self.define_fact(name, options = {}, &block)
+    collection.define_fact(name, options, &block)
+  end
+
+  # Adds a {Facter::Util::Resolution resolution} mechanism for a named
+  # fact. This does not distinguish between adding a new fact and adding
+  # a new way to resolve a fact.
+  #
+  # @overload add(name, options = {}, { || ... })
+  # @param name [String] the fact name
+  # @param options [Hash] optional parameters for the fact - attributes
+  #   of {Facter::Util::Fact} and {Facter::Util::Resolution} can be
+  #   supplied here
+  # @option options [Integer] :timeout set the
+  #   {Facter::Util::Resolution#timeout timeout} for this resolution
+  # @param block [Proc] a block defining a fact resolution
+  #
+  # @return [Facter::Util::Fact] the fact object, which includes any previously
+  #   defined resolutions
+  #
+  # @api public
+  def self.add(name, options = {}, &block)
+    collection.add(name, options, &block)
+  end
+
+  # Iterates over fact names and values
+  #
+  # @yieldparam [String] name the fact name
+  # @yieldparam [String] value the current value of the fact
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.each
+    # Make sure all facts are loaded.
+    collection.load_all
+
+    collection.each do |*args|
+      yield(*args)
+    end
+  end
+
+  # Clears all cached values and removes all facts from memory.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.clear
+    Facter.flush
+    Facter.reset
+  end
+
+  # Removes all facts from memory. Use this when the fact code has
+  # changed on disk and needs to be reloaded.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.reset
+    @collection = nil
+    reset_search_path!
+  end
+
+  # Loads all facts.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.loadfacts
+    collection.load_all
+  end
+
+  # Register directories to be searched for facts. The registered directories
+  # must be absolute paths or they will be ignored.
+  #
+  # @param dirs [String] directories to search
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.search(*dirs)
+    @search_path += dirs
+  end
+
+  # Returns the registered search directories.
+  #
+  # @return [Array<String>] An array of the directories searched
+  #
+  # @api public
+  def self.search_path
+    @search_path.dup
+  end
+
+  # Reset the Facter search directories.
+  #
+  # @api private
+  # @return [void]
+  def self.reset_search_path!
+    @search_path = []
+  end
+
+  reset_search_path!
+
+  # Registers directories to be searched for external facts.
+  #
+  # @param dirs [Array<String>] directories to search
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.search_external(dirs)
+    Facter::Util::Config.external_facts_dirs += dirs
+  end
+
+  # Returns the registered search directories.
+  #
+  # @return [Array<String>] An array of the directories searched
+  #
+  # @api public
+  def self.search_external_path
+    Facter::Util::Config.external_facts_dirs.dup
+  end
+end