puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/network/rights.rb

@@ -0,0 +1,219 @@
+require 'puppet/network/authstore'
+require 'puppet/error'
+
+module Puppet::Network
+
+# this exception is thrown when a request is not authenticated
+class AuthorizationError < Puppet::Error; end
+
+# Rights class manages a list of ACLs for paths.
+class Rights
+  # Check that name is allowed or not
+  def allowed?(name, *args)
+    !is_forbidden_and_why?(name, :node => args[0], :ip => args[1])
+  end
+
+  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]
+                       else
+                         [method]
+                       end
+    authorization_failure_exceptions = methods_to_check.map do |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.
+      nil
+    else
+      # Just need to return any of the failure exceptions.
+      authorization_failure_exceptions.first
+    end
+  end
+
+  def is_forbidden_and_why?(name, args = {})
+    res = :nomatch
+    right = @rights.find do |acl|
+      found = false
+      # an acl can return :dunno, which means "I'm not qualified to answer your question,
+      # please ask someone else". This is used when for instance an acl matches, but not for the
+      # current rest method, where we might think some other acl might be more specific.
+      if match = acl.match?(name)
+        args[:match] = match
+        if (res = acl.allowed?(args[:node], args[:ip], args)) != :dunno
+          # return early if we're allowed
+          return nil if res
+          # we matched, select this acl
+          found = true
+        end
+      end
+      found
+    end
+
+    # if we end up here, then that means we either didn't match or failed, in any
+    # case will return an error to the outside world
+    host_description = args[:node] ? "#{args[:node]}(#{args[:ip]})" : args[:ip]
+
+    msg = "#{host_description} access to #{name} [#{args[:method]}]"
+
+    if args[:authenticated]
+      msg += " authenticated "
+    end
+
+    if right
+      msg += " at #{right.file}:#{right.line}"
+    end
+
+    AuthorizationError.new("Forbidden request: #{msg}")
+  end
+
+  def initialize
+    @rights = []
+  end
+
+  def [](name)
+    @rights.find { |acl| acl == name }
+  end
+
+  def empty?
+    @rights.empty?
+  end
+
+  def include?(name)
+    @rights.include?(name)
+  end
+
+  def each
+    @rights.each { |r| yield r.name,r }
+  end
+
+  # Define a new right to which access can be provided.
+  def newright(name, line=nil, file=nil)
+    add_right( Right.new(name, line, file) )
+  end
+
+  private
+
+  def add_right(right)
+    @rights << right
+    right
+  end
+
+  # Retrieve a right by name.
+  def right(name)
+    self[name]
+  end
+
+  # A right.
+  class Right < Puppet::Network::AuthStore
+    attr_accessor :name, :key
+    # Overriding Object#methods sucks for debugging. If we're in here in the
+    # future, it would be nice to rename Right#methods
+    attr_accessor :methods, :environment, :authentication
+    attr_accessor :line, :file
+
+    ALL = [:save, :destroy, :find, :search]
+
+    Puppet::Util.logmethods(self, true)
+
+    def initialize(name, line, file)
+      @methods = []
+      @environment = []
+      @authentication = true # defaults to authenticated
+      @name = name
+      @line = line || 0
+      @file = file
+      @methods = ALL
+
+      case name
+      when /^\//
+        @key = Regexp.new("^" + Regexp.escape(name))
+      when /^~/ # this is a regex
+        @name = name.gsub(/^~\s+/,'')
+        @key = Regexp.new(@name)
+      else
+        raise ArgumentError, "Unknown right type '#{name}'"
+      end
+
+      super()
+    end
+
+    def to_s
+      "access[#{@name}]"
+    end
+
+    # There's no real check to do at this point
+    def valid?
+      true
+    end
+
+    # does this right is allowed for this triplet?
+    # if this right is too restrictive (ie we don't match this access method)
+    # then return :dunno so that upper layers have a chance to try another right
+    # tailored to the given method
+    def allowed?(name, ip, args = {})
+      if not @methods.include?(args[:method])
+        return :dunno
+      elsif @environment.size > 0 and not @environment.include?(args[:environment])
+        return :dunno
+      elsif (@authentication and not args[:authenticated])
+        return :dunno
+      end
+
+      begin
+        # make sure any capture are replaced if needed
+        interpolate(args[:match]) if args[:match]
+        res = super(name,ip)
+      ensure
+        reset_interpolation
+      end
+      res
+    end
+
+    # restrict this right to some method only
+    def restrict_method(m)
+      m = m.intern if m.is_a?(String)
+
+      raise ArgumentError, "'#{m}' is not an allowed value for method directive" unless ALL.include?(m)
+
+      # if we were allowing all methods, then starts from scratch
+      if @methods === ALL
+        @methods = []
+      end
+
+      raise ArgumentError, "'#{m}' is already in the '#{name}' ACL" if @methods.include?(m)
+
+      @methods << m
+    end
+
+    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
+    end
+
+    def restrict_authenticated(authentication)
+      case authentication
+      when "yes", "on", "true", true
+        authentication = true
+      when "no", "off", "false", false, "all" ,"any", :all, :any
+        authentication = false
+      else
+        raise ArgumentError, "'#{name}' incorrect authenticated value: #{authentication}"
+      end
+      @authentication = authentication
+    end
+
+    def match?(key)
+      # otherwise match with the regex
+      self.key.match(key)
+    end
+
+    def ==(name)
+      self.name == name.gsub(/^~\s+/,'')
+    end
+  end
+end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/network/server.rb

@@ -0,0 +1,39 @@
+require 'puppet/network/http'
+require 'puppet/network/http/webrick'
+
+#
+# @api private
+class Puppet::Network::Server
+  attr_reader :address, :port
+
+  def initialize(address, port)
+    @port = port
+    @address = address
+    @http_server = Puppet::Network::HTTP::WEBrick.new
+
+    @listening = false
+
+    # Make sure we have all of the directories we need to function.
+    Puppet.settings.use(:main, :ssl, :application)
+  end
+
+  def listening?
+    @listening
+  end
+
+  def start
+    raise "Cannot listen -- already listening." if listening?
+    @listening = true
+    @http_server.listen(address, port)
+  end
+
+  def stop
+    raise "Cannot unlisten -- not currently listening." unless listening?
+    @http_server.unlisten
+    @listening = false
+  end
+
+  def wait_for_shutdown
+    @http_server.wait_for_shutdown
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/node.rb

@@ -0,0 +1,184 @@
+require 'puppet/indirector'
+
+# A class for managing nodes, including their facts and environment.
+class Puppet::Node
+  require 'puppet/node/facts'
+  require 'puppet/node/environment'
+
+  # Set up indirection, so that nodes can be looked for in
+  # the node sources.
+  extend Puppet::Indirector
+
+  # 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."
+
+  attr_accessor :name, :classes, :source, :ipaddress, :parameters, :trusted_data, :environment_name
+  attr_reader :time, :facts
+
+  ::PSON.register_document_type('Node',self)
+
+  def self.from_data_hash(data)
+    raise ArgumentError, "No name provided in serialized data" unless name = data['name']
+
+    node = new(name)
+    node.classes = data['classes']
+    node.parameters = data['parameters']
+    node.environment_name = 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,
+      'environment' => environment.name,
+    }
+    result['classes'] = classes unless classes.empty?
+    result['parameters'] = parameters unless parameters.empty?
+    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"]
+        self.environment = env
+      elsif environment_name
+        self.environment = environment_name
+      else
+        # This should not be :current_environment, this is the default
+        # for a node when it has not specified its environment
+        # Tt will be used to establish what the current environment is.
+        #
+        self.environment = Puppet.lookup(:environments).get!(Puppet[:environment])
+      end
+
+      @environment
+    end
+  end
+
+  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 has_environment_instance?
+    !@environment.nil?
+  end
+
+  def initialize(name, options = {})
+    raise ArgumentError, "Node names cannot be nil" unless name
+    @name = name
+
+    if classes = options[:classes]
+      if classes.is_a?(String)
+        @classes = [classes]
+      else
+        @classes = classes
+      end
+    else
+      @classes = []
+    end
+
+    @parameters = options[:parameters] || {}
+
+    @facts = options[:facts]
+
+    if env = options[:environment]
+      self.environment = env
+    end
+
+    @time = Time.now
+  end
+
+  # Merge the node facts with parameters from the node source.
+  def fact_merge
+    if @facts = Puppet::Node::Facts.indirection.find(name, :environment => environment)
+      @facts.sanitize
+      merge(@facts.values)
+    end
+  rescue => detail
+    error = Puppet::Error.new("Could not retrieve facts for #{name}: #{detail}")
+    error.set_backtrace(detail.backtrace)
+    raise error
+  end
+
+  # Merge any random parameters into our parameter list.
+  def merge(params)
+    params.each do |name, value|
+      @parameters[name] = value unless @parameters.include?(name)
+    end
+
+    @parameters["environment"] ||= self.environment.name.to_s
+  end
+
+  # Calculate the list of names we might use for looking
+  # up our node.  This is only used for AST nodes.
+  def names
+    return [name] if Puppet.settings[:strict_hostname_checking]
+
+    names = []
+
+    names += split_name(name) if name.include?(".")
+
+    # First, get the fqdn
+    unless fqdn = parameters["fqdn"]
+      if parameters["hostname"] and parameters["domain"]
+        fqdn = parameters["hostname"] + "." + parameters["domain"]
+      else
+        Puppet.warning "Host is missing hostname and/or domain: #{name}"
+      end
+    end
+
+    # Now that we (might) have the fqdn, add each piece to the name
+    # list to search, in order of longest to shortest.
+    names += split_name(fqdn) if fqdn
+
+    # And make sure the node name is first, since that's the most
+    # likely usage.
+    #   The name is usually the Certificate CN, but it can be
+    # set to the 'facter' hostname instead.
+    if Puppet[:node_name] == 'cert'
+      names.unshift name
+    else
+      names.unshift parameters["hostname"]
+    end
+    names.uniq
+  end
+
+  def split_name(name)
+    list = name.split(".")
+    tmp = []
+    list.each_with_index do |short, i|
+      tmp << list[0..i].join(".")
+    end
+    tmp.reverse
+  end
+
+  # Ensures the data is frozen
+  #
+  def trusted_data=(data)
+    Puppet.warning("Trusted node data modified for node #{name}") unless @trusted_data.nil?
+    @trusted_data = data.freeze
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/node/environment.rb

@@ -0,0 +1,595 @@
+require 'puppet/util'
+require 'puppet/util/cacher'
+require 'monitor'
+require 'puppet/parser/parser_factory'
+
+# Just define it, so this class has fewer load dependencies.
+class Puppet::Node
+end
+
+# Puppet::Node::Environment acts as a container for all configuration
+# that is expected to vary between environments.
+#
+# ## 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 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.
+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.
+  #
+  # @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
+  end
+
+  # Create a new environment with the given name
+  #
+  # @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 or
+  # 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]
+  #
+  # @api public
+  def self.create(name, modulepath, manifest = NO_MANIFEST, config_version = nil)
+    obj = self.allocate
+    obj.send(:initialize,
+             name,
+             expand_dirs(extralibs() + modulepath),
+             manifest == NO_MANIFEST ? manifest : File.expand_path(manifest),
+             config_version)
+    obj
+  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
+  # being applied, this will be used on the agent.
+  #
+  # @note This does not provide access to the information of the remote
+  # environment's modules, manifest, or anything else. It is simply a value
+  # object to pass around and use as an environment.
+  #
+  # @param name [Symbol] The name of the remote environment
+  #
+  def self.remote(name)
+    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.
+  #
+  # @param name [Symbol] The environment name
+  def initialize(name, modulepath, manifest, config_version)
+    @name = name
+    @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
+  # parameters.
+  #
+  # @param env_params [Hash<{Symbol => String,Array<String>}>] new environment
+  #   parameters (:modulepath, :manifest, :config_version)
+  # @return [Puppet::Node::Environment]
+  def override_with(env_params)
+    return self.class.create(name,
+                      env_params[:modulepath] || modulepath,
+                      env_params[:manifest] || manifest,
+                      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
+  # 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 = {}
+
+    if settings.set_by_cli?(:modulepath)
+      overrides[:modulepath] = self.class.split_path(settings.value(:modulepath))
+    end
+
+    if settings.set_by_cli?(:config_version)
+      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)))
+      overrides[:manifest] = settings.value(:manifest)
+    end
+
+    overrides.empty? ?
+      self :
+      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
+  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
+  end
+
+  # @!attribute [r] name
+  #   @api public
+  #   @return [Symbol] the human readable environment name that serves as the
+  #     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
+
+  # @!attribute [r] config_version
+  #   @api public
+  #   @return [String] path to a script whose output will be added to report logs
+  #     (optional)
+  attr_reader :config_version
+
+  # Checks to make sure that this environment did not have a manifest set in
+  # its original environment.conf if Puppet is configured with
+  # +disable_per_environment_manifest+ set true.  If it did, the environment's
+  # modules may not function as intended by the original authors, and we may
+  # seek to halt a puppet compilation for a node in this environment.
+  #
+  # The only exception to this would be if the environment.conf manifest is an exact,
+  # uninterpolated match for the current +default_manifest+ setting.
+  #
+  # @return [Boolean] true if using directory environments, and
+  #   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
+  def conflicting_manifest_settings?
+    return false if Puppet[:environmentpath].empty? || !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
+
+  # Return an environment-specific Puppet setting.
+  #
+  # @api public
+  #
+  # @param param [String, Symbol] The environment setting to look up
+  # @return [Object] The resolved setting value
+  def [](param)
+    Puppet.settings.value(param, self.name)
+  end
+
+  # @api public
+  # @return [Puppet::Resource::TypeCollection] The current global TypeCollection
+  def known_resource_types
+    if @known_resource_types.nil?
+      @known_resource_types = Puppet::Resource::TypeCollection.new(self)
+      @known_resource_types.import_ast(perform_initial_import(), '')
+    end
+    @known_resource_types
+  end
+
+  # Yields each modules' plugin directory if the plugin directory (modulename/lib)
+  # is present on the filesystem.
+  #
+  # @yield [String] Yields the plugin directory from each module to the block.
+  # @api public
+  def each_plugin_directory(&block)
+    modules.map(&:plugin_directory).each do |lib|
+      lib = Puppet::Util::Autoload.cleanpath(lib)
+      yield lib if File.directory?(lib)
+    end
+  end
+
+  # Locate a module instance by the module name alone.
+  #
+  # @api public
+  #
+  # @param name [String] The module name
+  # @return [Puppet::Module, nil] The module if found, else nil
+  def module(name)
+    modules.find {|mod| mod.name == name}
+  end
+
+  # Locate a module instance by the full forge name (EG authorname/module)
+  #
+  # @api public
+  #
+  # @param forge_name [String] The module name
+  # @return [Puppet::Module, nil] The module if found, else nil
+  def module_by_forge_name(forge_name)
+    author, modname = forge_name.split('/')
+    found_mod = self.module(modname)
+    found_mod and found_mod.forge_name == forge_name ?
+      found_mod :
+      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
+        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
+  end
+
+  # Generate a warning if the given directory in a module path entry is named `lib`.
+  #
+  # @api private
+  #
+  # @param path [String] The module directory containing the given directory
+  # @param name [String] The directory name
+  def warn_about_mistaken_path(path, name)
+    if name == "lib"
+      Puppet.debug("Warning: Found directory named 'lib' in module path ('#{path}/lib'); unless " +
+          "you are expecting to load a module named 'lib', your module path may be set " +
+          "incorrectly.")
+    end
+  end
+
+  # Modules broken out by directory in the modulepath
+  #
+  # @note This method _changes_ the current working directory while enumerating
+  #   the modules. This seems rather dangerous.
+  #
+  # @api public
+  #
+  # @return [Hash<String, Array<Puppet::Module>>] A hash whose keys are file
+  #   paths, and whose values is an array of Puppet Modules for that path
+  def modules_by_path
+    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/)
+        end
+        modules_by_path[path] = module_names.sort.map do |name|
+          Puppet::Module.new(name, File.join(path, name), self)
+        end
+      end
+    end
+    modules_by_path
+  end
+
+  # All module requirements for all modules in the environment modulepath
+  #
+  # @api public
+  #
+  # @comment This has nothing to do with an environment. It seems like it was
+  #   stuffed into the first convenient class that vaguely involved modules.
+  #
+  # @example
+  #   environment.module_requirements
+  #   # => {
+  #   #   'username/amodule' => [
+  #   #     {
+  #   #       'name'    => 'username/moduledep',
+  #   #       'version' => '1.2.3',
+  #   #       'version_requirement' => '>= 1.0.0',
+  #   #     },
+  #   #     {
+  #   #       'name'    => 'username/anotherdep',
+  #   #       'version' => '4.5.6',
+  #   #       'version_requirement' => '>= 3.0.0',
+  #   #     }
+  #   #   ]
+  #   # }
+  #   #
+  #
+  # @return [Hash<String, Array<Hash<String, String>>>] See the method example
+  #   for an explanation of the return value.
+  def module_requirements
+    deps = {}
+
+    modules.each do |mod|
+      next unless mod.forge_name
+      deps[mod.forge_name] ||= []
+
+      mod.dependencies and mod.dependencies.each do |mod_dep|
+        dep_name = mod_dep['name'].tr('-', '/')
+        (deps[dep_name] ||= []) << {
+          'name'                => mod.forge_name,
+          'version'             => mod.version,
+          'version_requirement' => mod_dep['version_requirement']
+        }
+      end
+    end
+
+    deps.each do |mod, mod_deps|
+      deps[mod] = mod_deps.sort_by { |d| d['name'] }
+    end
+
+    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?)
+      @parsed_code = nil
+      @known_resource_types = nil
+    end
+  end
+
+  # @return [String] The stringified value of the `name` instance variable
+  # @api public
+  def to_s
+    name.to_s
+  end
+
+  # @return [Symbol] The `name` value, cast to a string, then cast to a symbol.
+  #
+  # @api public
+  #
+  # @note the `name` instance variable is a Symbol, but this casts the value
+  #   to a String and then converts it back into a Symbol which will needlessly
+  #   create an object that needs to be garbage collected
+  def to_sym
+    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
+
+  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
+
+  alias eql? ==
+
+  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
+  end
+
+  # Reparse the manifests for the given 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
+  #     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.
+  #
+  # @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)
+    @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 file == NO_MANIFEST
+        Puppet::Parser::AST::Hostclass.new('')
+      elsif File.directory?(file)
+        if Puppet[:parser] == 'future'
+          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
+          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
+        parser.file = file
+        parser.parse
+      end
+    end
+  rescue => detail
+    @known_resource_types.parse_failed = true
+
+    msg = "Could not parse for environment #{self}: #{detail}"
+    error = Puppet::Error.new(msg)
+    error.set_backtrace(detail.backtrace)
+    raise error
+  end
+
+  # 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 special "null" environment
+  #
+  # This environment should be used when there is no specific environment in
+  # effect.
+  NONE = create(:none, [])
+end