diff --git a/lib/puppet.rb b/lib/puppet.rb
index 2a52e9887..c0f2ba9d0 100644
--- a/lib/puppet.rb
+++ b/lib/puppet.rb
@@ -1,277 +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),
+      :environments => Puppet::Environments::Cached.new(Puppet::Environments::Combined.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'
diff --git a/lib/puppet/environments.rb b/lib/puppet/environments.rb
index ccdad6149..392f4b755 100644
--- a/lib/puppet/environments.rb
+++ b/lib/puppet/environments.rb
@@ -1,438 +1,430 @@
 # @api private
 module Puppet::Environments
 
   class EnvironmentNotFound < Puppet::Error
     def initialize(environment_name, original = nil)
       environmentpath = Puppet[:environmentpath]
       super("Could not find a directory environment named '#{environment_name}' anywhere in the path: #{environmentpath}. Does the directory exist?", original)
     end
   end
 
   # @api private
   module EnvironmentCreator
     # Create an anonymous environment.
     #
     # @param module_path [String] A list of module directories separated by the
     #   PATH_SEPARATOR
     # @param manifest [String] The path to the manifest
     # @return A new environment with the `name` `:anonymous`
     #
     # @api private
     def for(module_path, manifest)
       Puppet::Node::Environment.create(:anonymous,
                                        module_path.split(File::PATH_SEPARATOR),
                                        manifest)
     end
   end
 
+  # Provide any common methods that loaders should have. It requires that any
+  # classes that include this module implement get
+  # @api private
+  module EnvironmentLoader
+    # @!macro loader_get_or_fail
+    def get!(name)
+      environment = get(name)
+      if environment
+        environment
+      else
+        raise EnvironmentNotFound, name
+      end
+    end
+  end
+
   # @!macro [new] loader_search_paths
   #   A list of indicators of where the loader is getting its environments from.
   #   @return [Array<String>] The URIs of the load locations
   #
   # @!macro [new] loader_list
   #   @return [Array<Puppet::Node::Environment>] All of the environments known
   #     to the loader
   #
   # @!macro [new] loader_get
   #   Find a named environment
   #
   #   @param name [String,Symbol] The name of environment to find
   #   @return [Puppet::Node::Environment, nil] the requested environment or nil
   #     if it wasn't found
   #
   # @!macro [new] loader_get_conf
   #   Attempt to obtain the initial configuration for the environment.  Not all
   #   loaders can provide this.
   #
   #   @param name [String,Symbol] The name of the environment whose configuration
   #     we are looking up
   #   @return [Puppet::Setting::EnvironmentConf, nil] the configuration for the
   #     requested environment, or nil if not found or no configuration is available
   #
   # @!macro [new] loader_get_or_fail
   #   Find a named environment or raise
   #   Puppet::Environments::EnvironmentNotFound when the named environment is
   #   does not exist.
   #
   #   @param name [String,Symbol] The name of environment to find
   #   @return [Puppet::Node::Environment] the requested environment
 
   # A source of pre-defined environments.
   #
   # @api private
   class Static
     include EnvironmentCreator
+    include EnvironmentLoader
 
     def initialize(*environments)
       @environments = environments
     end
 
     # @!macro loader_search_paths
     def search_paths
       ["data:text/plain,internal"]
     end
 
     # @!macro loader_list
     def list
       @environments
     end
 
     # @!macro loader_get
     def get(name)
       @environments.find do |env|
         env.name == name.intern
       end
     end
 
-    # @!macro loader_get_or_fail
-    def get!(name)
-      environment = get(name)
-      if environment
-        environment
-      else
-        raise EnvironmentNotFound, name
-      end
-    end
-
     # Returns a basic environment configuration object tied to the environment's
     # implementation values.  Will not interpolate.
     #
     # @!macro loader_get_conf
     def get_conf(name)
       env = get(name)
       if env
         Puppet::Settings::EnvironmentConf.static_for(env)
       else
         nil
       end
     end
   end
 
   # A source of unlisted pre-defined environments.
   #
   # Used only for internal bootstrapping environments which are not relevant
   # to an end user (such as the fall back 'configured' environment).
   #
   # @api private
   class StaticPrivate < Static
 
     # Unlisted
     #
     # @!macro loader_list
     def list
       []
     end
   end
 
   # Old-style environments that come either from explicit stanzas in
   # puppet.conf or from dynamic environments created from use of `$environment`
   # in puppet.conf.
   #
   # @example Explicit Stanza
   #   [environment_name]
   #   modulepath=/var/my_env/modules
   #
   # @example Dynamic Environments
   #   [master]
   #   modulepath=/var/$environment/modules
   #
   # @api private
   class Legacy
     include EnvironmentCreator
 
     # @!macro loader_search_paths
     def search_paths
       ["file://#{Puppet[:config]}"]
     end
 
     # @note The list of environments for the Legacy environments is always
     #   empty.
     #
     # @!macro loader_list
     def list
       []
     end
 
     # @note Because the Legacy system cannot list out all of its environments,
     #   get is able to return environments that are not returned by a call to
     #   {#list}.
     #
     # @!macro loader_get
     def get(name)
       Puppet::Node::Environment.new(name)
     end
 
     # @note Because the Legacy system cannot list out all of its environments,
     #   this method will never fail and is only calling get directly.
     #
     # @!macro loader_get_or_fail
     def get!(name)
       get(name)
     end
 
     # @note we could return something here, but since legacy environments
     #   are deprecated, there is no point.
     #
     # @!macro loader_get_conf
     def get_conf(name)
       nil
     end
   end
 
   # Reads environments from a directory on disk. Each environment is
   # represented as a sub-directory. The environment's manifest setting is the
   # `manifest` directory of the environment directory. The environment's
   # modulepath setting is the global modulepath (from the `[master]` section
   # for the master) prepended with the `modules` directory of the environment
   # directory.
   #
   # @api private
   class Directories
+    include EnvironmentLoader
+
     def initialize(environment_dir, global_module_path)
       @environment_dir = environment_dir
       @global_module_path = global_module_path
     end
 
     # Generate an array of directory loaders from a path string.
     # @param path [String] path to environment directories
     # @param global_module_path [Array<String>] the global modulepath setting
     # @return [Array<Puppet::Environments::Directories>] An array
     #   of configured directory loaders.
     def self.from_path(path, global_module_path)
       environments = path.split(File::PATH_SEPARATOR)
       environments.map do |dir|
         Puppet::Environments::Directories.new(dir, global_module_path)
       end
     end
 
     # @!macro loader_search_paths
     def search_paths
       ["file://#{@environment_dir}"]
     end
 
     # @!macro loader_list
     def list
       valid_directories.collect do |envdir|
         name = Puppet::FileSystem.basename_string(envdir).intern
 
         setting_values = Puppet.settings.values(name, Puppet.settings.preferred_run_mode)
         env = Puppet::Node::Environment.create(
           name,
           Puppet::Node::Environment.split_path(setting_values.interpolate(:modulepath)),
           setting_values.interpolate(:manifest),
           setting_values.interpolate(:config_version)
         )
         env.watching = false
         env
       end
     end
 
     # @!macro loader_get
     def get(name)
       list.find { |env| env.name == name.intern }
     end
 
-    # @!macro loader_get_or_fail
-    def get!(name)
-      environment = get(name)
-      if environment
-        environment
-      else
-        raise EnvironmentNotFound, name
-      end
-    end
-
     # @!macro loader_get_conf
     def get_conf(name)
       valid_directories.each do |envdir|
         envname = Puppet::FileSystem.basename_string(envdir)
         if envname == name.to_s
           return Puppet::Settings::EnvironmentConf.load_from(envdir, @global_module_path)
         end
       end
       nil
     end
 
     private
 
     def valid_directories
       if Puppet::FileSystem.directory?(@environment_dir)
         Puppet::FileSystem.children(@environment_dir).select do |child|
           name = Puppet::FileSystem.basename_string(child)
           Puppet::FileSystem.directory?(child) &&
              Puppet::Node::Environment.valid_name?(name)
         end
       else
         []
       end
     end
   end
 
   # Combine together multiple loaders to act as one.
   # @api private
   class Combined
+    include EnvironmentLoader
+
     def initialize(*loaders)
       @loaders = loaders
     end
 
     # @!macro loader_search_paths
     def search_paths
       @loaders.collect(&:search_paths).flatten
     end
 
     # @!macro loader_list
     def list
       @loaders.collect(&:list).flatten
     end
 
     # @!macro loader_get
     def get(name)
       @loaders.each do |loader|
         if env = loader.get(name)
           return env
         end
       end
       nil
     end
 
-    # @!macro loader_get_or_fail
-    def get!(name)
-      environment = get(name)
-      if environment
-        environment
-      else
-        raise EnvironmentNotFound, name
-      end
-    end
-
     # @!macro loader_get_conf
     def get_conf(name)
       @loaders.each do |loader|
         if conf = loader.get_conf(name)
           return conf
         end
       end
       nil
     end
 
   end
 
-  class Cached < Combined
+  class Cached
+    include EnvironmentLoader
+
     INFINITY = 1.0 / 0.0
 
     class DefaultCacheExpirationService
       def created(env)
       end
 
       def expired?(env_name)
         false
       end
 
       def evicted(env_name)
       end
     end
 
     def self.cache_expiration_service=(service)
       @cache_expiration_service = service
     end
 
     def self.cache_expiration_service
       @cache_expiration_service || DefaultCacheExpirationService.new
     end
 
-    def initialize(*loaders)
-      super
+    def initialize(loader)
+      @loader = loader
       @cache = {}
       @cache_expiration_service = Puppet::Environments::Cached.cache_expiration_service
     end
 
     def get(name)
       evict_if_expired(name)
       if result = @cache[name]
         return result.value
-      elsif (result = super(name))
+      elsif (result = @loader.get(name))
         @cache[name] = entry(result)
         result
       end
     end
 
     # Clears the cache of the environment with the given name.
     # (The intention is that this could be used from a MANUAL cache eviction command (TBD)
     def clear(name)
       @cache.delete(name)
     end
 
     # Clears all cached environments.
     # (The intention is that this could be used from a MANUAL cache eviction command (TBD)
     def clear_all()
       @cache = {}
     end
 
     # This implementation evicts the cache, and always gets the current configuration of the environment
     # TODO: While this is wasteful since it needs to go on a search for the conf, it is too disruptive to optimize
     # this.
     #
     def get_conf(name)
       evict_if_expired(name)
-      super name
+      @loader.get_conf(name)
     end
 
     # Creates a suitable cache entry given the time to live for one environment
     #
     def entry(env)
       @cache_expiration_service.created(env)
       ttl = (conf = get_conf(env.name)) ? conf.environment_timeout : Puppet.settings.value(:environment_timeout)
       case ttl
       when 0
         NotCachedEntry.new(env)     # Entry that is always expired (avoids syscall to get time)
       when INFINITY
         Entry.new(env)              # Entry that never expires (avoids syscall to get time)
       else
         TTLEntry.new(env, ttl)
       end
     end
 
     # Evicts the entry if it has expired
     # Also clears caches in Settings that may prevent the entry from being updated
     def evict_if_expired(name)
       if (result = @cache[name]) && (result.expired? || @cache_expiration_service.expired?(name))
         @cache.delete(name)
         @cache_expiration_service.evicted(name)
 
         Puppet.settings.clear_environment_settings(name)
       end
     end
 
     # Never evicting entry
     class Entry
       attr_reader :value
 
       def initialize(value)
         @value = value
       end
 
       def expired?
         false
       end
     end
 
     # Always evicting entry
     class NotCachedEntry < Entry
       def expired?
         true
       end
     end
 
     # Time to Live eviction policy entry
     class TTLEntry < Entry
       def initialize(value, ttl_seconds)
         super value
         @ttl = Time.now + ttl_seconds
       end
 
       def expired?
         Time.now > @ttl
       end
     end
   end
 end