puppet 3.8.7 → 4.0.0.rc1

data/lib/puppet/network/http/api/master/v3/authorization.rb

@@ -0,0 +1,18 @@
+require 'puppet/network/authorization'
+
+class Puppet::Network::HTTP::API::Master::V3::Authorization
+  include Puppet::Network::Authorization
+
+  def wrap(&block)
+    lambda do |request, response|
+      begin
+        authconfig.check_authorization(:find, request.path, request.params)
+      rescue Puppet::Network::AuthorizationError => e
+        raise Puppet::Network::HTTP::Error::HTTPNotAuthorizedError.new(e.message, Puppet::Network::HTTP::Issues::FAILED_AUTHORIZATION)
+      end
+
+      block.call.call(request, response)
+    end
+  end
+
+end

data/lib/puppet/network/http/api/{v2 → master/v3}/environments.rb

@@ -1,6 +1,6 @@
 require 'json'
 
-class Puppet::Network::HTTP::API::V2::Environments
+class Puppet::Network::HTTP::API::Master::V3::Environments
   def initialize(env_loader)
     @env_loader = env_loader
   end
@@ -25,7 +25,7 @@ class Puppet::Network::HTTP::API::V2::Environments
 
   def timeout(env)
     ttl = @env_loader.get_conf(env.name).environment_timeout
-    if ttl == 1.0 / 0.0 # INFINITY
+    if ttl == Float::INFINITY
       "unlimited"
     else
       ttl

data/lib/puppet/network/http/compression.rb

@@ -1,6 +1,8 @@
 require 'puppet/network/http'
 
 module Puppet::Network::HTTP::Compression
+  # from https://github.com/ruby/ruby/blob/v2_1_3/lib/net/http/generic_request.rb#L40
+  ACCEPT_ENCODING = "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"
 
   # this module function allows to use the right underlying
   # methods depending on zlib presence
@@ -46,11 +48,7 @@ module Puppet::Network::HTTP::Compression
     end
 
     def add_accept_encoding(headers={})
-      if Puppet.settings[:http_compression]
-        headers['accept-encoding'] = 'gzip; q=1.0, deflate; q=1.0; identity'
-      else
-        headers['accept-encoding'] = 'identity'
-      end
+      headers['accept-encoding'] = Puppet::Network::HTTP::Compression::ACCEPT_ENCODING
       headers
     end
 

data/lib/puppet/network/http/connection.rb

@@ -2,7 +2,6 @@ require 'net/https'
 require 'puppet/ssl/host'
 require 'puppet/ssl/configuration'
 require 'puppet/ssl/validator'
-require 'puppet/network/authentication'
 require 'puppet/network/http'
 require 'uri'
 
@@ -22,7 +21,6 @@ module Puppet::Network::HTTP
   #   during a request.
   # @api public
   class Connection
-    include Puppet::Network::Authentication
 
     OPTION_DEFAULTS = {
       :use_ssl => true,
@@ -205,12 +203,7 @@ module Puppet::Network::HTTP
     end
 
     def execute_request(connection, request)
-      response = connection.request(request)
-
-      # Check the peer certs and warn if they're nearing expiration.
-      warn_if_near_expiration(*@verify.peer_certs)
-
-      response
+      connection.request(request)
     end
 
     def with_connection(site, &block)

data/lib/puppet/network/http/factory.rb

@@ -31,9 +31,8 @@ class Puppet::Network::HTTP::Factory
 
     http = Net::HTTP.new(*args)
     http.use_ssl = site.use_ssl?
-    # Use configured timeout (#1176)
-    http.read_timeout = Puppet[:configtimeout]
-    http.open_timeout = Puppet[:configtimeout]
+    http.read_timeout = Puppet[:http_read_timeout]
+    http.open_timeout = Puppet[:http_connect_timeout]
 
     if Puppet[:http_debug]
       http.set_debug_output($stderr)

data/lib/puppet/network/http/handler.rb

@@ -2,15 +2,12 @@ module Puppet::Network::HTTP
 end
 
 require 'puppet/network/http'
-require 'puppet/network/http/api/v1'
-require 'puppet/network/authentication'
 require 'puppet/network/rights'
 require 'puppet/util/profiler'
 require 'puppet/util/profiler/aggregate'
 require 'resolv'
 
 module Puppet::Network::HTTP::Handler
-  include Puppet::Network::Authentication
   include Puppet::Network::HTTP::Issues
 
   # These shouldn't be allowed to be set by clients
@@ -59,7 +56,7 @@ module Puppet::Network::HTTP::Handler
     profiler = configure_profiler(request_headers, request_params)
 
     Puppet::Util::Profiler.profile("Processed request #{request_method} #{request_path}", [:http, request_method, request_path]) do
-      if route = @routes.find { |route| route.matches?(new_request) }
+      if route = @routes.find { |r| r.matches?(new_request) }
         route.process(new_request, new_response)
       else
         raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("No route for #{new_request.method} #{new_request.path}", HANDLER_NOT_FOUND)
@@ -69,7 +66,7 @@ module Puppet::Network::HTTP::Handler
   rescue Puppet::Network::HTTP::Error::HTTPError => e
     Puppet.info(e.message)
     new_response.respond_with(e.status, "application/json", e.to_json)
-  rescue Exception => e
+  rescue StandardError => e
     http_e = Puppet::Network::HTTP::Error::HTTPServerError.new(e)
     Puppet.err(http_e.message)
     new_response.respond_with(http_e.status, "application/json", http_e.to_json)
@@ -146,12 +143,7 @@ module Puppet::Network::HTTP::Handler
   end
 
   def parse_parameter_value(param, value)
-    case value
-    when /^---/
-      Puppet.debug("Found YAML while processing request parameter #{param} (value: <#{value}>)")
-      Puppet.deprecation_warning("YAML in network requests is deprecated and will be removed in a future version. See http://links.puppetlabs.com/deprecate_yaml_on_network")
-      YAML.load(value, :safe => true, :deserialize_symbols => true)
-    when Array
+    if value.is_a?(Array)
       value.collect { |v| parse_primitive_parameter_value(v) }
     else
       parse_primitive_parameter_value(value)

data/lib/puppet/network/http/rack/rest.rb

@@ -28,7 +28,9 @@ class Puppet::Network::HTTP::RackREST
 
   def initialize(args={})
     super()
-    register([Puppet::Network::HTTP::API::V2.routes, Puppet::Network::HTTP::API::V1.routes])
+    register([Puppet::Network::HTTP::API.master_routes,
+              Puppet::Network::HTTP::API.ca_routes,
+              Puppet::Network::HTTP::API.not_found_upgrade])
   end
 
   def set_content_type(response, format)
@@ -94,9 +96,7 @@ class Puppet::Network::HTTP::RackREST
     if cert.nil? || cert.empty?
       nil
     else
-      cert = Puppet::SSL::Certificate.from_instance(OpenSSL::X509::Certificate.new(cert))
-      warn_if_near_expiration(cert)
-      cert
+      Puppet::SSL::Certificate.from_instance(OpenSSL::X509::Certificate.new(cert))
     end
   end
 

data/lib/puppet/network/http/request.rb

@@ -26,7 +26,7 @@ Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :
       if format.nil?
         raise "Client sent a mime-type (#{header}) that doesn't correspond to a format we support"
       else
-        report_if_deprecated(format)
+        assert_supported_format(format)
         return format.name.to_s if format.suitable?
       end
     end
@@ -43,14 +43,14 @@ Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :
         raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new("No supported formats are acceptable (Accept: #{accepted_formats})", Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
       end
 
-      report_if_deprecated(formatter)
+      assert_supported_format(formatter)
 
       formatter
   end
 
-  def report_if_deprecated(format)
+  def assert_supported_format(format)
     if format.name == :yaml || format.name == :b64_zlib_yaml
-      Puppet.deprecation_warning("YAML in network requests is deprecated and will be removed in a future version. See http://links.puppetlabs.com/deprecate_yaml_on_network")
+      raise Puppet::Error, "YAML in network requests is not supported. See http://links.puppetlabs.com/deprecate_yaml_on_network"
     end
   end
 end

data/lib/puppet/network/http/webrick.rb

@@ -70,11 +70,7 @@ class Puppet::Network::HTTP::WEBrick
     # Make sure the settings are all ready for us.
     Puppet.settings.use(:main, :ssl, :application)
 
-    if Puppet.run_mode.master?
-      file = Puppet[:masterhttplog]
-    else
-      file = Puppet[:httplog]
-    end
+    file = Puppet[:masterhttplog]
 
     # open the log manually to prevent file descriptor leak
     file_io = ::File.open(file, "a+")
@@ -123,7 +119,6 @@ class Puppet::Network::HTTP::WEBrick
   def ssl_configuration
     @ssl_configuration ||= Puppet::SSL::Configuration.new(
       Puppet[:localcacert],
-      :ca_chain_file => Puppet[:ssl_server_ca_chain],
       :ca_auth_file  => Puppet[:ssl_server_ca_auth])
   end
 end

data/lib/puppet/network/http/webrick/rest.rb

@@ -1,6 +1,7 @@
 require 'puppet/network/http/handler'
 require 'resolv'
 require 'webrick'
+require 'webrick/httputils'
 require 'puppet/util/ssl'
 
 class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
@@ -13,13 +14,24 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
 
   def initialize(server)
     raise ArgumentError, "server is required" unless server
-    register([Puppet::Network::HTTP::API::V2.routes, Puppet::Network::HTTP::API::V1.routes])
+    register([Puppet::Network::HTTP::API.master_routes,
+              Puppet::Network::HTTP::API.ca_routes,
+              Puppet::Network::HTTP::API.not_found_upgrade])
     super(server)
   end
 
   # Retrieve the request parameters, including authentication information.
   def params(request)
-    params = request.query || {}
+    query = request.query || {}
+    params =
+        if request.request_method == "PUT"
+          # webrick doesn't look at the query string for PUT requests, it only
+          # looks at the body, and then only if the body has a content type that
+          # looks like url-encoded form data.  We need the query string data as well.
+          WEBrick::HTTPUtils.parse_query(request.query_string).merge(query)
+        else
+          query
+        end
 
     params = Hash[params.collect do |key, value|
       all_values = value.list
@@ -60,9 +72,7 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
 
   def client_cert(request)
     if cert = request.client_cert
-      cert = Puppet::SSL::Certificate.from_instance(cert)
-      warn_if_near_expiration(cert)
-      cert
+      Puppet::SSL::Certificate.from_instance(cert)
     else
       nil
     end
@@ -79,9 +89,6 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
       response.body = result
       response["content-length"] = result.stat.size if result.is_a?(File)
     end
-    if RUBY_VERSION[0,3] == "1.8"
-      response["connection"] = 'close'
-    end
   end
 
   # Retrieve node/cert/ip information from the request object.

data/lib/puppet/network/resolver.rb

@@ -31,8 +31,8 @@ module Puppet::Network::Resolver
       # for the specific service.
       each_srv_record(domain, :puppet, &block)
     else
-      each_priority(records) do |priority, records|
-        while next_rr = records.delete(find_weighted_server(records))
+      each_priority(records) do |priority, recs|
+        while next_rr = recs.delete(find_weighted_server(recs))
           Puppet.debug "Yielding next server of #{next_rr.target.to_s}:#{next_rr.port}"
           yield next_rr.target.to_s, next_rr.port
         end

data/lib/puppet/network/rights.rb

@@ -20,8 +20,8 @@ class Rights
                        else
                          [method]
                        end
-    authorization_failure_exceptions = methods_to_check.map do |method|
-      is_forbidden_and_why?(path, params.merge({:method => method}))
+    authorization_failure_exceptions = methods_to_check.map do |m|
+      is_forbidden_and_why?(path, params.merge({:method => m}))
     end
     if authorization_failure_exceptions.include? nil
       # One of the methods we checked is ok, therefore this request is ok.

data/lib/puppet/node.rb

@@ -16,10 +16,6 @@ class Puppet::Node
   attr_accessor :name, :classes, :source, :ipaddress, :parameters, :trusted_data, :environment_name
   attr_reader :time, :facts
 
-  ::PSON.register_document_type('Node',self)
-
-  ENVIRONMENT = 'environment'.freeze
-
   def self.from_data_hash(data)
     raise ArgumentError, "No name provided in serialized data" unless name = data['name']
 
@@ -30,11 +26,6 @@ class Puppet::Node
     node
   end
 
-  def self.from_pson(pson)
-    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
-    self.from_data_hash(pson)
-  end
-
   def to_data_hash
     result = {
       'name' => name,
@@ -45,22 +36,11 @@ class Puppet::Node
     result
   end
 
-  def to_pson_data_hash(*args)
-    {
-      'document_type' => "Node",
-      'data' =>  to_data_hash,
-    }
-  end
-
-  def to_pson(*args)
-    to_pson_data_hash.to_pson(*args)
-  end
-
   def environment
     if @environment
       @environment
     else
-      if env = parameters[ENVIRONMENT]
+      if env = parameters["environment"]
         self.environment = env
       elsif environment_name
         self.environment = environment_name
@@ -82,13 +62,6 @@ class Puppet::Node
     else
       @environment = env
     end
-
-    # Keep environment_name attribute and parameter in sync if they have been set
-    unless @environment.nil?
-      @parameters[ENVIRONMENT] = @environment.name if @parameters.include?(ENVIRONMENT)
-      self.environment_name = @environment.name if instance_variable_defined?(:@environment_name)
-    end
-    @environment
   end
 
   def has_environment_instance?
@@ -138,7 +111,7 @@ class Puppet::Node
       @parameters[name] = value unless @parameters.include?(name)
     end
 
-    @parameters[ENVIRONMENT] ||= self.environment.name.to_s
+    @parameters["environment"] ||= self.environment.name.to_s
   end
 
   # Calculate the list of names we might use for looking

data/lib/puppet/node/environment.rb

@@ -1,5 +1,4 @@
 require 'puppet/util'
-require 'puppet/util/cacher'
 require 'monitor'
 require 'puppet/parser/parser_factory'
 
@@ -22,60 +21,23 @@ end
 # logging functions. Logging functions are attached to the 'root' environment
 # when {Puppet::Parser::Functions.reset} is called.
 class Puppet::Node::Environment
-  include Puppet::Util::Cacher
 
   NO_MANIFEST = :no_manifest
 
-  # @api private
-  def self.seen
-    @seen ||= {}
-  end
-
-  # Create a new environment with the given name, or return an existing one
-  #
-  # The environment class memoizes instances so that attempts to instantiate an
-  # environment with the same name with an existing environment will return the
-  # existing environment.
+  # The create() factory method should be used instead.
   #
-  # @overload self.new(environment)
-  #   @param environment [Puppet::Node::Environment]
-  #   @return [Puppet::Node::Environment] the environment passed as the param,
-  #     this is implemented so that a calling class can use strings or
-  #     environments interchangeably.
-  #
-  # @overload self.new(string)
-  #   @param string [String, Symbol]
-  #   @return [Puppet::Node::Environment] An existing environment if it exists,
-  #     else a new environment with that name
-  #
-  # @overload self.new()
-  #   @return [Puppet::Node::Environment] The environment as set by
-  #     Puppet.settings[:environment]
-  #
-  # @api public
-  def self.new(name = nil)
-    return name if name.is_a?(self)
-    name ||= Puppet.settings.value(:environment)
-
-    raise ArgumentError, "Environment name must be specified" unless name
-
-    symbol = name.to_sym
-
-    return seen[symbol] if seen[symbol]
-
-    obj = self.create(symbol,
-             split_path(Puppet.settings.value(:modulepath, symbol)),
-             Puppet.settings.value(:manifest, symbol),
-             Puppet.settings.value(:config_version, symbol))
-    seen[symbol] = obj
+  # @api private
+  def self.new(*args)
+    create(*args)
   end
+  private_class_method :new
 
   # Create a new environment with the given name
   #
-  # @param name [Symbol] the name of the
+  # @param name [Symbol] the name of the environment
   # @param modulepath [Array<String>] the list of paths from which to load modules
   # @param manifest [String] the path to the manifest for the environment or
-  # the constant Puppet::Node::Environment::NO_MANIFEST if there is none.
+  #   the constant Puppet::Node::Environment::NO_MANIFEST if there is none.
   # @param config_version [String] path to a script whose output will be added
   #   to report logs (optional)
   # @return [Puppet::Node::Environment]
@@ -84,13 +46,17 @@ class Puppet::Node::Environment
   def self.create(name, modulepath, manifest = NO_MANIFEST, config_version = nil)
     obj = self.allocate
     obj.send(:initialize,
-             name,
+             name.intern,
              expand_dirs(extralibs() + modulepath),
              manifest == NO_MANIFEST ? manifest : File.expand_path(manifest),
              config_version)
     obj
   end
 
+  # A remote subclass to make it easier to trace instances when debugging.
+  # @api private
+  class Remote < Puppet::Node::Environment; end
+
   # A "reference" to a remote environment. The created environment instance
   # isn't expected to exist on the local system, but is instead a reference to
   # environment information on a remote system. For instance when a catalog is
@@ -103,14 +69,15 @@ class Puppet::Node::Environment
   # @param name [Symbol] The name of the remote environment
   #
   def self.remote(name)
-    create(name, [], NO_MANIFEST)
+    Remote.create(name, [], NO_MANIFEST)
   end
 
   # Instantiate a new environment
   #
-  # @note {Puppet::Node::Environment.new} is overridden to return memoized
-  #   objects, so this will not be invoked with the normal Ruby initialization
-  #   semantics.
+  # @note {Puppet::Node::Environment.new} is private for historical reasons, as
+  #   previously it had been overridden to return memoized objects and was
+  #   replaced with {Puppet::Node::Environment.create}, so this will not be
+  #   invoked with the normal Ruby initialization semantics.
   #
   # @param name [Symbol] The environment name
   def initialize(name, modulepath, manifest, config_version)
@@ -118,23 +85,6 @@ class Puppet::Node::Environment
     @modulepath = modulepath
     @manifest = manifest
     @config_version = config_version
-    # set watching to true for legacy environments - the directory based environment loaders will set this to
-    # false for directory based environments after the environment has been created.
-    @watching = true
-  end
-
-  # Returns if files are being watched or not.
-  # @api private
-  #
-  def watching?
-    @watching
-  end
-
-  # Turns watching of files on or off
-  # @param flag [TrueClass, FalseClass] if files should be watched or not
-  # @ api private
-  def watching=(flag)
-    @watching = flag
   end
 
   # Creates a new Puppet::Node::Environment instance, overriding any of the passed
@@ -150,8 +100,8 @@ class Puppet::Node::Environment
                       env_params[:config_version] || config_version)
   end
 
-  # Creates a new Puppet::Node::Environment instance, overriding manfiest
-  # modulepath, or :config_version from the passed settings if they were
+  # Creates a new Puppet::Node::Environment instance, overriding :manifest,
+  # :modulepath, or :config_version from the passed settings if they were
   # originally set from the commandline, or returns self if there is nothing to
   # override.
   #
@@ -169,8 +119,7 @@ class Puppet::Node::Environment
       overrides[:config_version] = settings.value(:config_version)
     end
 
-    if settings.set_by_cli?(:manifest) ||
-      (settings.set_by_cli?(:manifestdir) && settings.value(:manifest).start_with?(settings.value(:manifestdir)))
+    if settings.set_by_cli?(:manifest)
       overrides[:manifest] = settings.value(:manifest)
     end
 
@@ -179,19 +128,6 @@ class Puppet::Node::Environment
       self.override_with(overrides)
   end
 
-  # Retrieve the environment for the current process.
-  #
-  # @note This should only used when a catalog is being compiled.
-  #
-  # @api private
-  #
-  # @return [Puppet::Node::Environment] the currently set environment if one
-  #   has been explicitly set, else it will return the '*root*' environment
-  def self.current
-    Puppet.deprecation_warning("Puppet::Node::Environment.current has been replaced by Puppet.lookup(:current_environment), see http://links.puppetlabs.com/current-env-deprecation")
-    Puppet.lookup(:current_environment)
-  end
-
   # @param [String] name Environment name to check for valid syntax.
   # @return [Boolean] true if name is valid
   # @api public
@@ -199,13 +135,6 @@ class Puppet::Node::Environment
     !!name.match(/\A\w+\Z/)
   end
 
-  # Clear all memoized environments and the 'current' environment
-  #
-  # @api private
-  def self.clear
-    seen.clear
-  end
-
   # @!attribute [r] name
   #   @api public
   #   @return [Symbol] the human readable environment name that serves as the
@@ -250,21 +179,23 @@ class Puppet::Node::Environment
   #   Puppet[:disable_per_environment_manifest] is true, and this environment's
   #   original environment.conf had a manifest setting that is not the
   #   Puppet[:default_manifest].
-  # @api public
+  # @api private 
   def conflicting_manifest_settings?
-    return false if Puppet[:environmentpath].empty? || !Puppet[:disable_per_environment_manifest]
+    return false if !Puppet[:disable_per_environment_manifest]
     environment_conf = Puppet.lookup(:environments).get_conf(name)
     original_manifest = environment_conf.raw_setting(:manifest)
     !original_manifest.nil? && !original_manifest.empty? && original_manifest != Puppet[:default_manifest]
   end
 
-  # @api private
-  def future_parser?
-    if @future_parser.nil?
-      environment_conf = Puppet.lookup(:environments).get_conf(name)
-      @future_parser = 'future' == (environment_conf.nil? ? Puppet[:parser] : environment_conf.parser)
+  # Checks the environment and settings for any conflicts
+  # @return [Array<String>] an array of validation errors
+  # @api public
+  def validation_errors
+    errors = []
+    if conflicting_manifest_settings?
+      errors << "The 'disable_per_environment_manifest' setting is true, and the '#{name}' environment has an environment.conf manifest that conflicts with the 'default_manifest' setting."
     end
-    @future_parser
+    errors
   end
 
   # Return an environment-specific Puppet setting.
@@ -323,40 +254,42 @@ class Puppet::Node::Environment
       nil
   end
 
-  # @!attribute [r] modules
-  #   Return all modules for this environment in the order they appear in the
-  #   modulepath.
-  #   @note If multiple modules with the same name are present they will
-  #     both be added, but methods like {#module} and {#module_by_forge_name}
-  #     will return the first matching entry in this list.
-  #   @note This value is cached so that the filesystem doesn't have to be
-  #     re-enumerated every time this method is invoked, since that
-  #     enumeration could be a costly operation and this method is called
-  #     frequently. The cache expiry is determined by `Puppet[:filetimeout]`.
-  #   @see Puppet::Util::Cacher.cached_attr
-  #   @api public
-  #   @return [Array<Puppet::Module>] All modules for this environment
-  cached_attr(:modules, Puppet[:filetimeout]) do
-    module_references = []
-    seen_modules = {}
-    modulepath.each do |path|
-      Dir.entries(path).each do |name|
-        warn_about_mistaken_path(path, name)
-        next if module_references.include?(name)
-        if not seen_modules[name]
-          module_references << {:name => name, :path => File.join(path, name)}
-          seen_modules[name] = true
+  # Return all modules for this environment in the order they appear in the
+  # modulepath.
+  # @note If multiple modules with the same name are present they will
+  #   both be added, but methods like {#module} and {#module_by_forge_name}
+  #   will return the first matching entry in this list.
+  # @note This value is cached so that the filesystem doesn't have to be
+  #   re-enumerated every time this method is invoked, since that
+  #   enumeration could be a costly operation and this method is called
+  #   frequently. The cache expiry is determined by `Puppet[:filetimeout]`.
+  # @api public
+  # @return [Array<Puppet::Module>] All modules for this environment
+  def modules
+    if @modules.nil?
+      module_references = []
+      seen_modules = {}
+      modulepath.each do |path|
+        Dir.entries(path).each do |name|
+          next unless Puppet::Module.is_module_directory?(name, path)
+          warn_about_mistaken_path(path, name)
+          if not seen_modules[name]
+            module_references << {:name => name, :path => File.join(path, name)}
+            seen_modules[name] = true
+          end
         end
       end
-    end
 
-    module_references.collect do |reference|
-      begin
-        Puppet::Module.new(reference[:name], reference[:path], self)
-      rescue Puppet::Module::Error
-        nil
-      end
-    end.compact
+      @modules = module_references.collect do |reference|
+        begin
+          Puppet::Module.new(reference[:name], reference[:path], self)
+        rescue Puppet::Module::Error => e
+          Puppet.log_exception(e)
+          nil
+        end
+      end.compact
+    end
+    @modules
   end
 
   # Generate a warning if the given directory in a module path entry is named `lib`.
@@ -386,8 +319,8 @@ class Puppet::Node::Environment
     modules_by_path = {}
     modulepath.each do |path|
       Dir.chdir(path) do
-        module_names = Dir.glob('*').select do |d|
-          FileTest.directory?(d) && (File.basename(d) =~ /\A\w+(-\w+)*\Z/)
+        module_names = Dir.entries(path).select do |name|
+          Puppet::Module.is_module_directory?(name, path)
         end
         modules_by_path[path] = module_names.sort.map do |name|
           Puppet::Module.new(name, File.join(path, name), self)
@@ -448,32 +381,32 @@ class Puppet::Node::Environment
     deps
   end
 
-  # Set a periodic watcher on the file, so we can tell if it has changed.
-  # If watching has been turned off, this call has no effect.
-  # @param file[File,String] File instance or filename
-  # @api private
-  def watch_file(file)
-    if watching?
-      known_resource_types.watch_file(file.to_s)
-    end
-  end
-
   # Checks if a reparse is required (cache of files is stale).
-  # This call does nothing unless files are being watched.
   #
   def check_for_reparse
-    if (Puppet[:code] != @parsed_code) || (watching? && @known_resource_types && @known_resource_types.require_reparse?)
+    if (Puppet[:code] != @parsed_code || @known_resource_types.parse_failed?)
       @parsed_code = nil
       @known_resource_types = nil
     end
   end
 
+  # @return [String] The YAML interpretation of the object
+  # Return the name of the environment as a string interpretation of the object
+  def to_yaml
+    to_s.to_yaml
+  end
+
   # @return [String] The stringified value of the `name` instance variable
   # @api public
   def to_s
     name.to_s
   end
 
+  # @api public
+  def inspect
+    %Q{<#{self.class}:#{self.object_id} @name="#{name}" @manifest="#{manifest}" @modulepath="#{full_modulepath.join(":")}" >}
+  end
+
   # @return [Symbol] The `name` value, cast to a string, then cast to a symbol.
   #
   # @api public
@@ -485,17 +418,6 @@ class Puppet::Node::Environment
     to_s.to_sym
   end
 
-  # Return only the environment name when serializing.
-  #
-  # The only thing we care about when serializing an environment is its
-  # identity; everything else is ephemeral and should not be stored or
-  # transmitted.
-  #
-  # @api public
-  def to_zaml(z)
-    self.to_s.to_zaml(z)
-  end
-
   def self.split_path(path_string)
     path_string.split(File::PATH_SEPARATOR)
   end
@@ -533,43 +455,32 @@ class Puppet::Node::Environment
   #
   # There are two sources that can be used for the initial parse:
   #
-  #   1. The value of `Puppet.settings[:code]`: Puppet can take a string from
+  #   1. The value of `Puppet[:code]`: Puppet can take a string from
   #     its settings and parse that as a manifest. This is used by various
   #     Puppet applications to read in a manifest and pass it to the
   #     environment as a side effect. This is attempted first.
-  #   2. The contents of `Puppet.settings[:manifest]`: Puppet will try to load
-  #     the environment manifest. By default this is `$manifestdir/site.pp`
-  #
-  # @note This method will return an empty hostclass if
-  #   `Puppet.settings[:ignoreimport]` is set to true.
+  #   2. The contents of this environment's +manifest+ attribute: Puppet will
+  #     try to load the environment manifest.
   #
   # @return [Puppet::Parser::AST::Hostclass] The AST hostclass object
   #   representing the 'main' hostclass
   def perform_initial_import
-    return empty_parse_result if Puppet[:ignoreimport]
-    parser = Puppet::Parser::ParserFactory.parser(self)
+    parser = Puppet::Parser::ParserFactory.parser
     @parsed_code = Puppet[:code]
     if @parsed_code != ""
       parser.string = @parsed_code
       parser.parse
     else
       file = self.manifest
-      # if the manifest file is a reference to a directory, parse and combine all .pp files in that
-      # directory
+      # if the manifest file is a reference to a directory, parse and combine
+      # all .pp files in that directory
       if file == NO_MANIFEST
-        Puppet::Parser::AST::Hostclass.new('')
+        empty_parse_result
       elsif File.directory?(file)
-        if Puppet.future_parser?
-          parse_results = Puppet::FileSystem::PathPattern.absolute(File.join(file, '**/*.pp')).glob.sort.map do | file_to_parse |
-            parser.file = file_to_parse
-            parser.parse
-          end
-        else
-          parse_results = Dir.entries(file).find_all { |f| f =~ /\.pp$/ }.sort.map do |file_to_parse|
-            parser.file = File.join(file, file_to_parse)
-            parser.parse
+        parse_results = Puppet::FileSystem::PathPattern.absolute(File.join(file, '**/*.pp')).glob.sort.map do | file_to_parse |
+          parser.file = file_to_parse
+          parser.parse
           end
-        end
         # Use a parser type specific merger to concatenate the results
         Puppet::Parser::AST::Hostclass.new('', :code => Puppet::Parser::ParserFactory.code_merger.concatenate(parse_results))
       else
@@ -577,10 +488,6 @@ class Puppet::Node::Environment
         parser.parse
       end
     end
-  rescue Puppet::ParseErrorWithIssue => detail
-    @known_resource_types.parse_failed = true
-    detail.environment = self.name
-    raise
   rescue => detail
     @known_resource_types.parse_failed = true
 
@@ -592,17 +499,18 @@ class Puppet::Node::Environment
 
   # Return an empty toplevel hostclass to indicate that no file was loaded
   #
-  # This is used as the return value of {#perform_initial_import} when
-  # `Puppet.settings[:ignoreimport]` is true.
-  #
   # @return [Puppet::Parser::AST::Hostclass]
   def empty_parse_result
     return Puppet::Parser::AST::Hostclass.new('')
   end
 
+  # A None subclass to make it easier to trace the NONE environment when debugging.
+  # @api private
+  class None < Puppet::Node::Environment; end
+
   # A special "null" environment
   #
   # This environment should be used when there is no specific environment in
   # effect.
-  NONE = create(:none, [])
+  NONE = None.create(:none, [])
 end