puppet 3.4.3 → 3.5.0.rc1

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

@@ -0,0 +1,9 @@
+module Puppet::Network::HTTP::Issues
+  NO_INDIRECTION_REMOTE_REQUESTS = :NO_INDIRECTION_REMOTE_REQUESTS
+  HANDLER_NOT_FOUND = :HANDLER_NOT_FOUND
+  RESOURCE_NOT_FOUND = :RESOURCE_NOT_FOUND
+  RUNTIME_ERROR = :RUNTIME_ERROR
+  MISSING_HEADER_FIELD = :MISSING_HEADER_FIELD
+  UNSUPPORTED_FORMAT = :UNSUPPORTED_FORMAT
+  UNSUPPORTED_METHOD = :UNSUPPORTED_METHOD
+end

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

@@ -0,0 +1,13 @@
+class Puppet::Network::HTTP::MemoryResponse
+  attr_reader :code, :type, :body
+
+  def initialize
+    @body = ""
+  end
+
+  def respond_with(code, type, body)
+    @code = code
+    @type = type
+    @body += body
+  end
+end

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

@@ -1,14 +1,11 @@
 require 'openssl'
 require 'cgi'
 require 'puppet/network/http/handler'
-require 'puppet/network/http/rack/httphandler'
 require 'puppet/util/ssl'
 
-class Puppet::Network::HTTP::RackREST < Puppet::Network::HTTP::RackHttpHandler
-
+class Puppet::Network::HTTP::RackREST
   include Puppet::Network::HTTP::Handler
 
-  HEADER_ACCEPT = 'HTTP_ACCEPT'.freeze
   ContentType = 'Content-Type'.freeze
 
   CHUNK_SIZE = 8192
@@ -31,7 +28,7 @@ class Puppet::Network::HTTP::RackREST < Puppet::Network::HTTP::RackHttpHandler
 
   def initialize(args={})
     super()
-    initialize_for_puppet(args)
+    register([Puppet::Network::HTTP::API::V2.routes, Puppet::Network::HTTP::API::V1.routes])
   end
 
   def set_content_type(response, format)
@@ -51,20 +48,12 @@ class Puppet::Network::HTTP::RackREST < Puppet::Network::HTTP::RackHttpHandler
 
   # Retrieve all headers from the http request, as a map.
   def headers(request)
-    request.env.select {|k,v| k.start_with? 'HTTP_'}.inject({}) do |m, (k,v)|
+    headers = request.env.select {|k,v| k.start_with? 'HTTP_'}.inject({}) do |m, (k,v)|
       m[k.sub(/^HTTP_/, '').gsub('_','-').downcase] = v
       m
     end
-  end
-
-  # Retrieve the accept header from the http request.
-  def accept_header(request)
-    request.env[HEADER_ACCEPT]
-  end
-
-  # Retrieve the accept header from the http request.
-  def content_type_header(request)
-    request.content_type
+    headers['content-type'] = request.content_type
+    headers
   end
 
   # Return which HTTP verb was used in this request.
@@ -102,8 +91,11 @@ class Puppet::Network::HTTP::RackREST < Puppet::Network::HTTP::RackHttpHandler
     cert = request.env['SSL_CLIENT_CERT']
     # NOTE: The SSL_CLIENT_CERT environment variable will be the empty string
     # when Puppet agent nodes have not yet obtained a signed certificate.
-    return nil if cert.nil? or cert.empty?
-    OpenSSL::X509::Certificate.new(cert)
+    if cert.nil? || cert.empty?
+      nil
+    else
+      Puppet::SSL::Certificate.from_instance(OpenSSL::X509::Certificate.new(cert))
+    end
   end
 
   # Passenger freaks out if we finish handling the request without reading any

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

@@ -0,0 +1,56 @@
+Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :routing_path, :client_cert, :body) do
+  def self.from_hash(hash)
+    symbol_members = members.collect(&:intern)
+    unknown = hash.keys - symbol_members
+    if unknown.empty?
+      new(hash[:headers] || {},
+          hash[:params] || {},
+          hash[:method] || "GET",
+          hash[:path],
+          hash[:routing_path] || hash[:path],
+          hash[:client_cert],
+          hash[:body])
+    else
+      raise ArgumentError, "Unknown arguments: #{unknown.collect(&:inspect).join(', ')}"
+    end
+  end
+
+  def route_into(prefix)
+    self.class.new(headers, params, method, path, routing_path.sub(prefix, ''), client_cert, body)
+  end
+
+  def format
+    if header = headers['content-type']
+      header.gsub!(/\s*;.*$/,'') # strip any charset
+      format = Puppet::Network::FormatHandler.mime(header)
+      if format.nil?
+        raise "Client sent a mime-type (#{header}) that doesn't correspond to a format we support"
+      else
+        report_if_deprecated(format)
+        return format.name.to_s if format.suitable?
+      end
+    end
+
+    raise "No Content-Type header was received, it isn't possible to unserialize the request"
+  end
+
+  def response_formatter_for(supported_formats, accepted_formats = headers['accept'])
+    formatter = Puppet::Network::FormatHandler.most_suitable_format_for(
+      accepted_formats.split(/\s*,\s*/),
+      supported_formats)
+
+      if formatter.nil?
+        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)
+
+      formatter
+  end
+
+  def report_if_deprecated(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")
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+class Puppet::Network::HTTP::Response
+  def initialize(handler, response)
+    @handler = handler
+    @response = response
+  end
+
+  def respond_with(code, type, body)
+    @handler.set_content_type(@response, type)
+    @handler.set_response(@response, body, code)
+  end
+end

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

@@ -0,0 +1,91 @@
+class Puppet::Network::HTTP::Route
+  MethodNotAllowedHandler = lambda do |req, res|
+    raise Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError.new("method #{req.method} not allowed for route #{req.path}", Puppet::Network::HTTP::Issues::UNSUPPORTED_METHOD)
+  end
+
+  attr_reader :path_matcher
+
+  def self.path(path_matcher)
+    new(path_matcher)
+  end
+
+  def initialize(path_matcher)
+    @path_matcher = path_matcher
+    @method_handlers = {
+      :GET => [MethodNotAllowedHandler],
+      :HEAD => [MethodNotAllowedHandler],
+      :OPTIONS => [MethodNotAllowedHandler],
+      :POST => [MethodNotAllowedHandler],
+      :PUT => [MethodNotAllowedHandler]
+    }
+    @chained = []
+  end
+
+  def get(*handlers)
+    @method_handlers[:GET] = handlers
+    return self
+  end
+
+  def head(*handlers)
+    @method_handlers[:HEAD] = handlers
+    return self
+  end
+
+  def options(*handlers)
+    @method_handlers[:OPTIONS] = handlers
+    return self
+  end
+
+  def post(*handlers)
+    @method_handlers[:POST] = handlers
+    return self
+  end
+
+  def put(*handlers)
+    @method_handlers[:PUT] = handlers
+    return self
+  end
+
+  def any(*handlers)
+    @method_handlers.each do |method, registered_handlers|
+      @method_handlers[method] = handlers
+    end
+    return self
+  end
+
+  def chain(*routes)
+    @chained = routes
+    self
+  end
+
+  def matches?(request)
+    Puppet.debug("Evaluating match for #{self.inspect}")
+    if match(request.routing_path)
+      return true
+    else
+      Puppet.debug("Did not match path (#{request.routing_path.inspect})")
+    end
+    return false
+  end
+
+  def process(request, response)
+    @method_handlers[request.method.upcase.intern].each do |handler|
+      handler.call(request, response)
+    end
+
+    subrequest = request.route_into(match(request.routing_path).to_s)
+    if chained_route = @chained.find { |route| route.matches?(subrequest) }
+      chained_route.process(subrequest, response)
+    end
+  end
+
+  def inspect
+    "Route #{@path_matcher.inspect}"
+  end
+
+  private
+
+  def match(path)
+    @path_matcher.match(path)
+  end
+end

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

@@ -22,7 +22,7 @@ class Puppet::Network::HTTP::WEBrick
     @server = WEBrick::HTTPServer.new(arguments)
     @server.listeners.each { |l| l.start_immediately = false }
 
-    @server.mount('/', Puppet::Network::HTTP::WEBrickREST, :this_value_is_apparently_necessary_but_unused)
+    @server.mount('/', Puppet::Network::HTTP::WEBrickREST)
 
     raise "WEBrick server is already listening" if @listening
     @listening = true

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

@@ -7,10 +7,10 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
 
   include Puppet::Network::HTTP::Handler
 
-  def initialize(server, handler)
+  def initialize(server)
     raise ArgumentError, "server is required" unless server
+    register([Puppet::Network::HTTP::API::V2.routes, Puppet::Network::HTTP::API::V1.routes])
     super(server)
-    initialize_for_puppet(:server => server, :handler => handler)
   end
 
   # Retrieve the request parameters, including authentication information.
@@ -39,14 +39,6 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
     result
   end
 
-  def accept_header(request)
-    request["accept"]
-  end
-
-  def content_type_header(request)
-    request["content-type"]
-  end
-
   def http_method(request)
     request.request_method
   end
@@ -60,7 +52,11 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
   end
 
   def client_cert(request)
-    request.client_cert
+    if cert = request.client_cert
+      Puppet::SSL::Certificate.from_instance(cert)
+    else
+      nil
+    end
   end
 
   # Set the specified format as the content type of the response.
@@ -74,7 +70,6 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
       response.body = result
       response["content-length"] = result.stat.size if result.is_a?(File)
     end
-    response.reason_phrase = result if status < 200 or status >= 300
   end
 
   # Retrieve node/cert/ip information from the request object.

data/lib/puppet/network/http_pool.rb

@@ -3,10 +3,10 @@ require 'puppet/network/http/connection'
 module Puppet::Network; end
 
 # This module contains the factory methods that should be used for getting a
-# Puppet::Network::HTTP::Connection instance.
+# {Puppet::Network::HTTP::Connection} instance.
 #
-# The name "HttpPool" is a misnomer, and a leftover of history, but we would
-# like to make this cache connections in the future.
+# @note The name "HttpPool" is a misnomer, and a leftover of history, but we would
+#   like to make this cache connections in the future.
 #
 # @api public
 #

data/lib/puppet/network/rights.rb

@@ -13,7 +13,7 @@ class Rights
     !is_forbidden_and_why?(name, :node => args[0], :ip => args[1])
   end
 
-  def is_request_forbidden_and_why?(indirection, method, key, params)
+  def is_request_forbidden_and_why?(method, path, params)
     methods_to_check = if method == :head
                          # :head is ok if either :find or :save is ok.
                          [:find, :save]
@@ -21,7 +21,7 @@ class Rights
                          [method]
                        end
     authorization_failure_exceptions = methods_to_check.map do |method|
-      is_forbidden_and_why?("/#{indirection}/#{key}", params.merge({:method => method}))
+      is_forbidden_and_why?(path, params.merge({:method => method}))
     end
     if authorization_failure_exceptions.include? nil
       # One of the methods we checked is ok, therefore this request is ok.
@@ -187,8 +187,8 @@ class Rights
       @methods << m
     end
 
-    def restrict_environment(env)
-      env = Puppet::Node::Environment.new(env)
+    def restrict_environment(environment)
+      env = Puppet.lookup(:environments).get(environment)
       raise ArgumentError, "'#{env}' is already in the '#{name}' ACL" if @environment.include?(env)
 
       @environment << env

data/lib/puppet/node.rb

@@ -9,9 +9,6 @@ class Puppet::Node
   # the node sources.
   extend Puppet::Indirector
 
-  # Adds the environment getter and setter, with some instance/string conversion
-  include Puppet::Node::Environment::Helper
-
   # Use the node source as the indirection terminus.
   indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
     A node is composed of its name, its facts, and its environment."
@@ -21,16 +18,21 @@ class Puppet::Node
 
   ::PSON.register_document_type('Node',self)
 
-  def self.from_pson(pson)
-    raise ArgumentError, "No name provided in serialized data" unless name = pson['name']
+  def self.from_data_hash(data)
+    raise ArgumentError, "No name provided in serialized data" unless name = data['name']
 
     node = new(name)
-    node.classes = pson['classes']
-    node.parameters = pson['parameters']
-    node.environment = pson['environment']
+    node.classes = data['classes']
+    node.parameters = data['parameters']
+    node.environment = data['environment']
     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,
@@ -53,15 +55,22 @@ class Puppet::Node
   end
 
   def environment
-    return super if @environment
-
-    if env = parameters["environment"]
+    if @environment
+      @environment
+    elsif env = parameters["environment"]
       self.environment = env
-      return super
+      @environment
+    else
+      Puppet.lookup(:environments).get(Puppet[:environment])
     end
+  end
 
-    # Else, return the default
-    Puppet::Node::Environment.new
+  def environment=(env)
+    if env.is_a?(String) or env.is_a?(Symbol)
+      @environment = Puppet.lookup(:environments).get(env)
+    else
+      @environment = env
+    end
   end
 
   def initialize(name, options = {})

data/lib/puppet/node/environment.rb

@@ -10,59 +10,25 @@ end
 # Puppet::Node::Environment acts as a container for all configuration
 # that is expected to vary between environments.
 #
-# ## Global variables
-#
-# The Puppet::Node::Environment uses a number of global variables.
-#
-# ### `$environment`
-#
-# The 'environment' global variable represents the current environment that's
-# being used in the compiler.
-#
 # ## The root environment
 #
 # In addition to normal environments that are defined by the user,there is a
 # special 'root' environment. It is defined as an instance variable on the
 # Puppet::Node::Environment metaclass. The environment name is `*root*` and can
-# be accessed by calling {Puppet::Node::Environment.root}.
+# be accessed by looking up the `:root_environment` using {Puppet.lookup}.
 #
 # The primary purpose of the root environment is to contain parser functions
 # that are not bound to a specific environment. The main case for this is for
 # logging functions. Logging functions are attached to the 'root' environment
 # when {Puppet::Parser::Functions.reset} is called.
-#
-# The root environment is also used as a fallback environment when the
-# current environment has been requested by {Puppet::Node::Environment.current}
-# requested and no environment was set by {Puppet::Node::Environment.current=}
 class Puppet::Node::Environment
 
-  # This defines a mixin for classes that have an environment. It implements
-  # `environment` and `environment=` that respects the semantics of the
-  # Puppet::Node::Environment class
-  #
-  # @api public
-  module Helper
-
-    def environment
-      Puppet::Node::Environment.new(@environment)
-    end
-
-    def environment=(env)
-      if env.is_a?(String) or env.is_a?(Symbol)
-        @environment = env
-      else
-        @environment = env.name
-      end
-    end
-  end
-
   include Puppet::Util::Cacher
 
-  # @!attribute seen
-  #   @scope class
-  #   @api private
-  #   @return [Hash<Symbol, Puppet::Node::Environment>] All memoized environments
-  @seen = {}
+  # @api private
+  def self.seen
+    @seen ||= {}
+  end
 
   # Create a new environment with the given name, or return an existing one
   #
@@ -94,58 +60,100 @@ class Puppet::Node::Environment
 
     symbol = name.to_sym
 
-    return @seen[symbol] if @seen[symbol]
+    return seen[symbol] if seen[symbol]
 
-    obj = self.allocate
-    obj.send :initialize, symbol
-    @seen[symbol] = obj
+    obj = self.create(symbol,
+             split_path(Puppet.settings.value(:modulepath, symbol)),
+             Puppet.settings.value(:manifest, symbol))
+    seen[symbol] = obj
   end
 
-  # Retrieve the environment for the current thread
-  #
-  # @note This should only used when a catalog is being compiled.
+  # Create a new environment with the given name
   #
-  # @api private
+  # @param name [Symbol] the name of the
+  # @param modulepath [Array<String>] the list of paths from which to load modules
+  # @param manifest [String] the path to the manifest for the environment
+  # @return [Puppet::Node::Environment]
   #
-  # @return [Puppet::Node::Environment] the currently set environment if one
-  #   has been explicitly set, else it will return the '*root*' environment
-  def self.current
-    $environment || root
+  # @api public
+  def self.create(name, modulepath, manifest)
+    obj = self.allocate
+    obj.send(:initialize,
+             name,
+             expand_dirs(extralibs() + modulepath),
+             File.expand_path(manifest))
+    obj
   end
 
-  # Set the environment for the current thread
-  #
-  # @note This should only set when a catalog is being compiled. Under normal
-  #   This value is initially set in {Puppet::Parser::Compiler#environment}
+  # Instantiate a new environment
   #
-  # @note Setting this affects global state during catalog compilation, and
-  #   changing the current environment during compilation can cause unexpected
-  #   and generally very bad behaviors.
+  # @note {Puppet::Node::Environment.new} is overridden to return memoized
+  #   objects, so this will not be invoked with the normal Ruby initialization
+  #   semantics.
   #
-  # @api private
+  # @param name [Symbol] The environment name
+  def initialize(name, modulepath, manifest)
+    @name = name
+    @modulepath = modulepath
+    @manifest = manifest
+  end
+
+  # Creates a new Puppet::Node::Environment instance, overriding any of the passed
+  # parameters.
   #
-  # @param env [Puppet::Node::Environment]
-  def self.current=(env)
-    $environment = new(env)
+  # @param env_params [Hash<{Symbol => String,Array<String>}>] new environment
+  #   parameters (:modulepath, :manifest)
+  # @return [Puppet::Node::Environment]
+  def override_with(env_params)
+    return self.class.create(name,
+                      env_params[:modulepath] || modulepath,
+                      env_params[:manifest] || manifest)
   end
 
+  # Creates a new Puppet::Node::Environment instance, overriding manfiest
+  # and modulepath from the passed settings if they were originally set from
+  # the commandline, or returns self if there is nothing to override.
+  #
+  # @param settings [Puppet::Settings] an initialized puppet settings instance
+  # @return [Puppet::Node::Environment] new overridden environment or self if
+  #   there are no commandline changes from settings.
+  def override_from_commandline(settings)
+    overrides = {}
+    overrides[:modulepath] = self.class.split_path(settings[:modulepath]) if settings.set_by_cli?(:modulepath)
+    if settings.set_by_cli?(:manifest) ||
+      (settings.set_by_cli?(:manifestdir) && settings[:manifest].start_with?(settings[:manifestdir]))
+      overrides[:manifest] = settings[:manifest]
+    end
+    overrides.empty? ?
+      self :
+      self.override_with(overrides)
+  end
 
-  # @return [Puppet::Node::Environment] The `*root*` environment.
+  # Retrieve the environment for the current process.
   #
-  # This is only used for handling functions that are not attached to a
-  # specific environment.
+  # @note This should only used when a catalog is being compiled.
   #
   # @api private
-  def self.root
-    @root
+  #
+  # @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
+  def self.valid_name?(name)
+    !!name.match(/\A\w+\Z/)
   end
 
   # Clear all memoized environments and the 'current' environment
   #
   # @api private
   def self.clear
-    @seen.clear
-    $environment = nil
+    seen.clear
   end
 
   # @!attribute [r] name
@@ -154,6 +162,25 @@ class Puppet::Node::Environment
   #     environment identifier
   attr_reader :name
 
+  # @api public
+  # @return [Array<String>] All directories present on disk in the modulepath
+  def modulepath
+    @modulepath.find_all do |p|
+      Puppet::FileSystem.directory?(p)
+    end
+  end
+
+  # @api public
+  # @return [Array<String>] All directories in the modulepath (even if they are not present on disk)
+  def full_modulepath
+    @modulepath
+  end
+
+  # @!attribute [r] manifest
+  #   @api public
+  #   @return [String] path to the manifest file or directory.
+  attr_reader :manifest
+
   # Return an environment-specific Puppet setting.
   #
   # @api public
@@ -164,26 +191,6 @@ class Puppet::Node::Environment
     Puppet.settings.value(param, self.name)
   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.
-  #
-  # @param name [Symbol] The environment name
-  def initialize(name)
-    @name = name
-  end
-
-  # The current global TypeCollection
-  #
-  # @note The environment is loosely coupled with the {Puppet::Resource::TypeCollection}
-  #   class. While there is a 1:1 relationship between an environment and a
-  #   TypeCollection instance, there is only one TypeCollection instance
-  #   available at any given time. It is stored in `$known_resource_types`.
-  #   `$known_resource_types` is accessed as an instance method, but is global
-  #   to all environment variables.
-  #
   # @api public
   # @return [Puppet::Resource::TypeCollection] The current global TypeCollection
   def known_resource_types
@@ -230,21 +237,6 @@ class Puppet::Node::Environment
       nil
   end
 
-  # @!attribute [r] modulepath
-  #   Return all existent directories in the modulepath for this environment
-  #   @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<String>] All directories present in the modulepath
-  cached_attr(:modulepath, Puppet[:filetimeout]) do
-    dirs = self[:modulepath].split(File::PATH_SEPARATOR)
-    dirs = ENV["PUPPETLIB"].split(File::PATH_SEPARATOR) + dirs if ENV["PUPPETLIB"]
-    validate_dirs(dirs)
-  end
-
   # @!attribute [r] modules
   #   Return all modules for this environment in the order they appear in the
   #   modulepath.
@@ -367,9 +359,16 @@ class Puppet::Node::Environment
     deps
   end
 
+  # Set a periodic watcher on the file, so we can tell if it has changed.
+  # @param filename [File,String] File instance or filename
+  # @api private
+  def watch_file(file)
+    known_resource_types.watch_file(file.to_s)
+  end
 
   def check_for_reparse
-    if @known_resource_types && @known_resource_types.require_reparse?
+    if (Puppet[:code] != @parsed_code) || (@known_resource_types && @known_resource_types.require_reparse?)
+      @parsed_code = nil
       @known_resource_types = nil
     end
   end
@@ -402,22 +401,37 @@ class Puppet::Node::Environment
     self.to_s.to_zaml(z)
   end
 
-  # Validate a list of file paths and return the paths that are directories on the filesystem
-  #
-  # @api private
-  #
-  # @param dirs [Array<String>] The file paths to validate
-  # @return [Array<String>] All file paths that exist and are directories
-  def validate_dirs(dirs)
+  def self.split_path(path_string)
+    path_string.split(File::PATH_SEPARATOR)
+  end
+
+  def ==(other)
+    return true if other.kind_of?(Puppet::Node::Environment) &&
+      self.name == other.name &&
+      self.full_modulepath == other.full_modulepath &&
+      self.manifest == other.manifest
+  end
+
+  def hash
+    [self.class, name, full_modulepath, manifest].hash
+  end
+
+  private
+
+  def self.extralibs()
+    if ENV["PUPPETLIB"]
+      split_path(ENV["PUPPETLIB"])
+    else
+      []
+    end
+  end
+
+  def self.expand_dirs(dirs)
     dirs.collect do |dir|
       File.expand_path(dir)
-    end.find_all do |p|
-      FileTest.directory?(p)
     end
   end
 
-  private
-
   # Reparse the manifests for the given environment
   #
   # There are two sources that can be used for the initial parse:
@@ -435,16 +449,28 @@ class Puppet::Node::Environment
   # @return [Puppet::Parser::AST::Hostclass] The AST hostclass object
   #   representing the 'main' hostclass
   def perform_initial_import
-    return empty_parse_result if Puppet.settings[:ignoreimport]
-#    parser = Puppet::Parser::Parser.new(self)
+    return empty_parse_result if Puppet[:ignoreimport]
     parser = Puppet::Parser::ParserFactory.parser(self)
-    if code = Puppet.settings.uninterpolated_value(:code, name.to_s) and code != ""
-      parser.string = code
+    @parsed_code = Puppet[:code]
+    if @parsed_code != ""
+      parser.string = @parsed_code
+      parser.parse
     else
-      file = Puppet.settings.value(:manifest, name.to_s)
-      parser.file = file
+      file = self.manifest
+      # if the manifest file is a reference to a directory, parse and combine all .pp files in that
+      # directory
+      if File.directory?(file)
+        parse_results = Dir.entries(file).find_all { |f| f =~ /\.pp$/ }.sort.map do |pp_file|
+          parser.file = File.join(file, pp_file)
+          parser.parse
+        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
+        parser.file = file
+        parser.parse
+      end
     end
-    parser.parse
   rescue => detail
     @known_resource_types.parse_failed = true
 
@@ -463,6 +489,4 @@ class Puppet::Node::Environment
   def empty_parse_result
     return Puppet::Parser::AST::Hostclass.new('')
   end
-
-  @root = new(:'*root*')
 end