puppet 3.7.0-x64-mingw32

data/lib/hiera/scope.rb

@@ -0,0 +1,60 @@
+class Hiera
+  class Scope
+    CALLING_CLASS = "calling_class"
+    CALLING_MODULE = "calling_module"
+    MODULE_NAME = "module_name"
+
+    attr_reader :real
+
+    def initialize(real)
+      @real = real
+    end
+
+    def [](key)
+      if key == CALLING_CLASS
+        ans = find_hostclass(@real)
+      elsif key == CALLING_MODULE
+        ans = @real.lookupvar(MODULE_NAME)
+      else
+        ans = @real.lookupvar(key)
+      end
+
+      if ans.nil? or ans == ""
+        nil
+      else
+        ans
+      end
+    end
+
+    def include?(key)
+      if key == CALLING_CLASS or key == CALLING_MODULE
+        true
+      else
+        @real.lookupvar(key) != ""
+      end
+    end
+
+    def catalog
+      @real.catalog
+    end
+
+    def resource
+      @real.resource
+    end
+
+    def compiler
+      @real.compiler
+    end
+
+    def find_hostclass(scope)
+      if scope.source and scope.source.type == :hostclass
+        return scope.source.name.downcase
+      elsif scope.parent
+        return find_hostclass(scope.parent)
+      else
+        return nil
+      end
+    end
+    private :find_hostclass
+  end
+end

data/lib/hiera_puppet.rb

@@ -0,0 +1,87 @@
+require 'hiera'
+require 'hiera/scope'
+require 'puppet'
+
+module HieraPuppet
+  module_function
+
+  def lookup(key, default, scope, override, resolution_type)
+    scope = Hiera::Scope.new(scope)
+
+    answer = hiera.lookup(key, default, scope, override, resolution_type)
+
+    if answer.nil?
+      raise(Puppet::ParseError, "Could not find data item #{key} in any Hiera data file and no default supplied")
+    end
+
+    answer
+  end
+
+  def parse_args(args)
+    # Functions called from Puppet manifests like this:
+    #
+    #   hiera("foo", "bar")
+    #
+    # Are invoked internally after combining the positional arguments into a
+    # single array:
+    #
+    #   func = function_hiera
+    #   func(["foo", "bar"])
+    #
+    # Functions called from templates preserve the positional arguments:
+    #
+    #   scope.function_hiera("foo", "bar")
+    #
+    # Deal with Puppet's special calling mechanism here.
+    if args[0].is_a?(Array)
+      args = args[0]
+    end
+
+    if args.empty?
+      raise(Puppet::ParseError, "Please supply a parameter to perform a Hiera lookup")
+    end
+
+    key      = args[0]
+    default  = args[1]
+    override = args[2]
+
+    return [key, default, override]
+  end
+
+  private
+  module_function
+
+  def hiera
+    @hiera ||= Hiera.new(:config => hiera_config)
+  end
+
+  def hiera_config
+    config = {}
+
+    if config_file = hiera_config_file
+      config = Hiera::Config.load(config_file)
+    end
+
+    config[:logger] = 'puppet'
+    config
+  end
+
+  def hiera_config_file
+    config_file = nil
+
+    if Puppet.settings[:hiera_config].is_a?(String)
+      expanded_config_file = File.expand_path(Puppet.settings[:hiera_config])
+      if Puppet::FileSystem.exist?(expanded_config_file)
+        config_file = expanded_config_file
+      end
+    elsif Puppet.settings[:confdir].is_a?(String)
+      expanded_config_file = File.expand_path(File.join(Puppet.settings[:confdir], '/hiera.yaml'))
+      if Puppet::FileSystem.exist?(expanded_config_file)
+        config_file = expanded_config_file
+      end
+    end
+
+    config_file
+  end
+end
+

data/lib/puppet.rb

@@ -0,0 +1,277 @@
+require 'puppet/version'
+
+# see the bottom of the file for further inclusions
+# Also see the new Vendor support - towards the end
+#
+require 'facter'
+require 'puppet/error'
+require 'puppet/util'
+require 'puppet/util/autoload'
+require 'puppet/settings'
+require 'puppet/util/feature'
+require 'puppet/util/suidmanager'
+require 'puppet/util/run_mode'
+require 'puppet/external/pson/common'
+require 'puppet/external/pson/version'
+require 'puppet/external/pson/pure'
+
+#------------------------------------------------------------
+# the top-level module
+#
+# all this really does is dictate how the whole system behaves, through
+# preferences for things like debugging
+#
+# it's also a place to find top-level commands like 'debug'
+
+# The main Puppet class. Everything is contained here.
+#
+# @api public
+module Puppet
+  require 'puppet/file_system'
+  require 'puppet/context'
+  require 'puppet/environments'
+
+  class << self
+    include Puppet::Util
+    attr_reader :features
+    attr_writer :name
+  end
+
+  # the hash that determines how our system behaves
+  @@settings = Puppet::Settings.new
+
+  # Note: It's important that these accessors (`self.settings`, `self.[]`) are
+  # defined before we try to load any "features" (which happens a few lines below),
+  # because the implementation of the features loading may examine the values of
+  # settings.
+  def self.settings
+    @@settings
+  end
+
+  # Get the value for a setting
+  #
+  # @param [Symbol] param the setting to retrieve
+  #
+  # @api public
+  def self.[](param)
+    if param == :debug
+      return Puppet::Util::Log.level == :debug
+    else
+      return @@settings[param]
+    end
+  end
+
+  # The services running in this process.
+  @services ||= []
+
+  require 'puppet/util/logging'
+
+  extend Puppet::Util::Logging
+
+  # The feature collection
+  @features = Puppet::Util::Feature.new('puppet/feature')
+
+  # Load the base features.
+  require 'puppet/feature/base'
+
+  # Store a new default value.
+  def self.define_settings(section, hash)
+    @@settings.define_settings(section, hash)
+  end
+
+  # setting access and stuff
+  def self.[]=(param,value)
+    @@settings[param] = value
+  end
+
+  def self.clear
+    @@settings.clear
+  end
+
+  def self.debug=(value)
+    if value
+      Puppet::Util::Log.level=(:debug)
+    else
+      Puppet::Util::Log.level=(:notice)
+    end
+  end
+
+  def self.run_mode
+    # This sucks (the existence of this method); there are a lot of places in our code that branch based the value of
+    # "run mode", but there used to be some really confusing code paths that made it almost impossible to determine
+    # when during the lifecycle of a puppet application run the value would be set properly.  A lot of the lifecycle
+    # stuff has been cleaned up now, but it still seems frightening that we rely so heavily on this value.
+    #
+    # I'd like to see about getting rid of the concept of "run_mode" entirely, but there are just too many places in
+    # the code that call this method at the moment... so I've settled for isolating it inside of the Settings class
+    # (rather than using a global variable, as we did previously...).  Would be good to revisit this at some point.
+    #
+    # --cprice 2012-03-16
+    Puppet::Util::RunMode[@@settings.preferred_run_mode]
+  end
+
+  # Load all of the settings.
+  require 'puppet/defaults'
+
+  def self.genmanifest
+    if Puppet[:genmanifest]
+      puts Puppet.settings.to_manifest
+      exit(0)
+    end
+  end
+
+  # Parse the config file for this process.
+  # @deprecated Use {initialize_settings}
+  def self.parse_config()
+    Puppet.deprecation_warning("Puppet.parse_config is deprecated; please use Faces API (which will handle settings and state management for you), or (less desirable) call Puppet.initialize_settings")
+    Puppet.initialize_settings
+  end
+
+  # Initialize puppet's settings. This is intended only for use by external tools that are not
+  #  built off of the Faces API or the Puppet::Util::Application class. It may also be used
+  #  to initialize state so that a Face may be used programatically, rather than as a stand-alone
+  #  command-line tool.
+  #
+  # @api public
+  # @param args [Array<String>] the command line arguments to use for initialization
+  # @return [void]
+  def self.initialize_settings(args = [])
+    do_initialize_settings_for_run_mode(:user, args)
+  end
+
+  # Initialize puppet's settings for a specified run_mode.
+  #
+  # @deprecated Use {initialize_settings}
+  def self.initialize_settings_for_run_mode(run_mode)
+    Puppet.deprecation_warning("initialize_settings_for_run_mode may be removed in a future release, as may run_mode itself")
+    do_initialize_settings_for_run_mode(run_mode, [])
+  end
+
+  # private helper method to provide the implementation details of initializing for a run mode,
+  #  but allowing us to control where the deprecation warning is issued
+  def self.do_initialize_settings_for_run_mode(run_mode, args)
+    Puppet.settings.initialize_global_settings(args)
+    run_mode = Puppet::Util::RunMode[run_mode]
+    Puppet.settings.initialize_app_defaults(Puppet::Settings.app_defaults_for_run_mode(run_mode))
+    Puppet.push_context(Puppet.base_context(Puppet.settings), "Initial context after settings initialization")
+    Puppet::Parser::Functions.reset
+    Puppet::Util::Log.level = Puppet[:log_level]
+  end
+  private_class_method :do_initialize_settings_for_run_mode
+
+  # Create a new type.  Just proxy to the Type class.  The mirroring query
+  # code was deprecated in 2008, but this is still in heavy use.  I suppose
+  # this can count as a soft deprecation for the next dev. --daniel 2011-04-12
+  def self.newtype(name, options = {}, &block)
+    Puppet::Type.newtype(name, options, &block)
+  end
+
+  # Load vendored (setup paths, and load what is needed upfront).
+  # See the Vendor class for how to add additional vendored gems/code
+  require "puppet/vendor"
+  Puppet::Vendor.load_vendored
+
+  # Set default for YAML.load to unsafe so we don't affect programs
+  # requiring puppet -- in puppet we will call safe explicitly
+  SafeYAML::OPTIONS[:default_mode] = :unsafe
+
+  # The bindings used for initialization of puppet
+  # @api private
+  def self.base_context(settings)
+    environments = settings[:environmentpath]
+    modulepath = Puppet::Node::Environment.split_path(settings[:basemodulepath])
+
+    if environments.empty?
+      loaders = [Puppet::Environments::Legacy.new]
+    else
+      loaders = Puppet::Environments::Directories.from_path(environments, modulepath)
+      # in case the configured environment (used for the default sometimes)
+      # doesn't exist
+      default_environment = Puppet[:environment].to_sym
+      if default_environment == :production
+        loaders << Puppet::Environments::StaticPrivate.new(
+          Puppet::Node::Environment.create(Puppet[:environment].to_sym,
+                                           [],
+                                           Puppet::Node::Environment::NO_MANIFEST))
+      end
+    end
+
+    {
+      :environments => Puppet::Environments::Cached.new(*loaders),
+      :http_pool => proc {
+        require 'puppet/network/http'
+        Puppet::Network::HTTP::NoCachePool.new
+      }
+    }
+  end
+
+  # A simple set of bindings that is just enough to limp along to
+  # initialization where the {base_context} bindings are put in place
+  # @api private
+  def self.bootstrap_context
+    root_environment = Puppet::Node::Environment.create(:'*root*', [], Puppet::Node::Environment::NO_MANIFEST)
+    {
+      :current_environment => root_environment,
+      :root_environment => root_environment
+    }
+  end
+
+  # @param overrides [Hash] A hash of bindings to be merged with the parent context.
+  # @param description [String] A description of the context.
+  # @api private
+  def self.push_context(overrides, description = "")
+    @context.push(overrides, description)
+  end
+
+  # Return to the previous context.
+  # @raise [StackUnderflow] if the current context is the root
+  # @api private
+  def self.pop_context
+    @context.pop
+  end
+
+  # Lookup a binding by name or return a default value provided by a passed block (if given).
+  # @api private
+  def self.lookup(name, &block)
+    @context.lookup(name, &block)
+  end
+
+  # @param bindings [Hash] A hash of bindings to be merged with the parent context.
+  # @param description [String] A description of the context.
+  # @yield [] A block executed in the context of the temporarily pushed bindings.
+  # @api private
+  def self.override(bindings, description = "", &block)
+    @context.override(bindings, description, &block)
+  end
+
+  # @api private
+  def self.mark_context(name)
+    @context.mark(name)
+  end
+
+  # @api private
+  def self.rollback_context(name)
+    @context.rollback(name)
+  end
+
+  require 'puppet/node'
+
+  # The single instance used for normal operation
+  @context = Puppet::Context.new(bootstrap_context)
+end
+
+# This feels weird to me; I would really like for us to get to a state where there is never a "require" statement
+#  anywhere besides the very top of a file.  That would not be possible at the moment without a great deal of
+#  effort, but I think we should strive for it and revisit this at some point.  --cprice 2012-03-16
+
+require 'puppet/indirector'
+require 'puppet/type'
+require 'puppet/resource'
+require 'puppet/parser'
+require 'puppet/network'
+require 'puppet/ssl'
+require 'puppet/module'
+require 'puppet/data_binding'
+require 'puppet/util/storage'
+require 'puppet/status'
+require 'puppet/file_bucket/file'

data/lib/puppet/agent.rb

@@ -0,0 +1,121 @@
+require 'puppet/application'
+
+# A general class for triggering a run of another
+# class.
+class Puppet::Agent
+  require 'puppet/agent/locker'
+  include Puppet::Agent::Locker
+
+  require 'puppet/agent/disabler'
+  include Puppet::Agent::Disabler
+
+  attr_reader :client_class, :client, :splayed, :should_fork
+
+  def initialize(client_class, should_fork=true)
+    @splayed = false
+
+    @should_fork = can_fork? && should_fork
+    @client_class = client_class
+  end
+
+  def can_fork?
+    Puppet.features.posix? && RUBY_PLATFORM != 'java'
+  end
+
+  def needing_restart?
+    Puppet::Application.restart_requested?
+  end
+
+  # Perform a run with our client.
+  def run(client_options = {})
+    if running?
+      Puppet.notice "Run of #{client_class} already in progress; skipping  (#{lockfile_path} exists)"
+      return
+    end
+    if disabled?
+      Puppet.notice "Skipping run of #{client_class}; administratively disabled (Reason: '#{disable_message}');\nUse 'puppet agent --enable' to re-enable."
+      return
+    end
+
+    result = nil
+    block_run = Puppet::Application.controlled_run do
+      splay client_options.fetch :splay, Puppet[:splay]
+      result = run_in_fork(should_fork) do
+        with_client do |client|
+          begin
+            client_args = client_options.merge(:pluginsync => Puppet[:pluginsync])
+            lock { client.run(client_args) }
+          rescue SystemExit,NoMemoryError
+            raise
+          rescue Exception => detail
+            Puppet.log_exception(detail, "Could not run #{client_class}: #{detail}")
+          end
+        end
+      end
+      true
+    end
+    Puppet.notice "Shutdown/restart in progress (#{Puppet::Application.run_status.inspect}); skipping run" unless block_run
+    result
+  end
+
+  def stopping?
+    Puppet::Application.stop_requested?
+  end
+
+  # Have we splayed already?
+  def splayed?
+    splayed
+  end
+
+  # Sleep when splay is enabled; else just return.
+  def splay(do_splay = Puppet[:splay])
+    return unless do_splay
+    return if splayed?
+
+    time = rand(Puppet[:splaylimit] + 1)
+    Puppet.info "Sleeping for #{time} seconds (splay is enabled)"
+    sleep(time)
+    @splayed = true
+  end
+
+  def run_in_fork(forking = true)
+    return yield unless forking or Puppet.features.windows?
+
+    child_pid = Kernel.fork do
+      $0 = "puppet agent: applying configuration"
+      begin
+        exit(yield)
+      rescue SystemExit
+        exit(-1)
+      rescue NoMemoryError
+        exit(-2)
+      end
+    end
+    exit_code = Process.waitpid2(child_pid)
+    case exit_code[1].exitstatus
+    when -1
+      raise SystemExit
+    when -2
+      raise NoMemoryError
+    end
+    exit_code[1].exitstatus
+  end
+
+  private
+
+  # Create and yield a client instance, keeping a reference
+  # to it during the yield.
+  def with_client
+    begin
+      @client = client_class.new
+    rescue SystemExit,NoMemoryError
+      raise
+    rescue Exception => detail
+      Puppet.log_exception(detail, "Could not create instance of #{client_class}: #{detail}")
+      return
+    end
+    yield @client
+  ensure
+    @client = nil
+  end
+end