puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/hiera/backend/puppet_backend.rb

@@ -0,0 +1,103 @@
+require 'hiera/backend'
+
+class Hiera
+  module Backend
+    class Puppet_backend
+      def initialize
+        Hiera.debug("Hiera Puppet backend starting")
+      end
+
+      def hierarchy(scope, override)
+        begin
+          data_class = Config[:puppet][:datasource] || "data"
+        rescue
+          data_class = "data"
+        end
+
+        calling_class = scope.resource.name.to_s.downcase
+        calling_module = calling_class.split("::").first
+
+        hierarchy = Config[:hierarchy] || [calling_class, calling_module]
+
+        hierarchy = [hierarchy].flatten.map do |klass|
+          klass = Backend.parse_string(klass, scope,
+            {
+              "calling_class"  => calling_class,
+              "calling_module" => calling_module
+            }
+          )
+
+          next if klass == ""
+
+          [data_class, klass].join("::")
+        end.compact
+
+        hierarchy << [calling_class, data_class].join("::")
+
+        unless calling_module == calling_class
+          hierarchy << [calling_module, data_class].join("::")
+        end
+
+        hierarchy.insert(0, [data_class, override].join("::")) if override
+
+        hierarchy
+      end
+
+      def lookup(key, scope, order_override, resolution_type)
+        answer = nil
+
+        Hiera.debug("Looking up #{key} in Puppet backend")
+
+        Puppet::Parser::Functions.function(:include)
+        loaded_classes = scope.catalog.classes
+
+        hierarchy(scope, order_override).each do |klass|
+          Hiera.debug("Looking for data in #{klass}")
+
+          varname = [klass, key].join("::")
+          temp_answer = nil
+
+          unless loaded_classes.include?(klass)
+            begin
+              if scope.respond_to?(:function_include)
+                scope.function_include([klass])
+              else
+                scope.real.function_include([klass])
+              end
+
+              temp_answer = scope[varname]
+              Hiera.debug("Found data in class #{klass}")
+            rescue
+            end
+          else
+            temp_answer = scope[varname]
+          end
+
+          # Note that temp_answer might be define but false.
+          if temp_answer.nil?
+            next
+          else
+            # For array resolution we just append to the array whatever we
+            # find, we then go onto the next file and keep adding to the array.
+            #
+            # For priority searches we break after the first found data item.
+            case resolution_type
+            when :array
+              answer ||= []
+              answer << Backend.parse_answer(temp_answer, scope)
+            when :hash
+              answer ||= {}
+              answer = Backend.parse_answer(temp_answer, scope).merge answer
+            else
+              answer = Backend.parse_answer(temp_answer, scope)
+              break
+            end
+          end
+        end
+
+        answer
+      end
+    end
+  end
+end
+

data/vendor/gems/puppet-3.7.3/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/vendor/gems/puppet-3.7.3/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/vendor/gems/puppet-3.7.3/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'