bolt 0.0.1 → 0.5.0

data/vendored/puppet/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/vendored/puppet/lib/puppet/node.rb

@@ -0,0 +1,262 @@
+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
+
+  # Asymmetric serialization/deserialization required in this class via to/from datahash
+  include Puppet::Util::PsychSupport
+
+  # 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
+
+  attr_reader :server_facts
+
+  ENVIRONMENT = 'environment'.freeze
+
+  def initialize_from_hash(data)
+    @name       = data['name']       || (raise ArgumentError, _("No name provided in serialized data"))
+    @classes    = data['classes']    || []
+    @parameters = data['parameters'] || {}
+    env_name = data['environment']
+    env_name = env_name.intern unless env_name.nil?
+    @environment_name = env_name
+    environment = env_name
+  end
+
+  def self.from_data_hash(data)
+    node = new(name)
+    node.initialize_from_hash(data)
+    node
+  end
+
+  def to_data_hash
+    result = {
+      'name' => name,
+      'environment' => environment.name.to_s,
+    }
+    result['classes'] = classes unless classes.empty?
+    result['parameters'] = parameters unless parameters.empty?
+    result
+  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
+
+    # Keep environment_name attribute and parameter in sync if they have been set
+    unless @environment.nil?
+      @parameters[ENVIRONMENT] = @environment.name.to_s if @parameters.include?(ENVIRONMENT)
+      self.environment_name = @environment.name if instance_variable_defined?(:@environment_name)
+    end
+    @environment
+  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]
+
+    @server_facts = {}
+
+    if env = options[:environment]
+      self.environment = env
+    end
+
+    @time = Time.now
+  end
+
+  # Merge the node facts with parameters from the node source.
+  # @api public
+  # @param facts [optional, Puppet::Node::Facts] facts to merge into node parameters.
+  #   Will query Facts indirection if not supplied.
+  # @raise [Puppet::Error] Raise on failure to retrieve facts if not supplied
+  # @return [nil]
+  def fact_merge(facts = nil)
+    begin
+      @facts = facts.nil? ? Puppet::Node::Facts.indirection.find(name, :environment => environment) : facts
+    rescue => detail
+      error = Puppet::Error.new(_("Could not retrieve facts for %{name}: %{detail}") % { name: name, detail: detail }, detail)
+      error.set_backtrace(detail.backtrace)
+      raise error
+    end
+
+    if !@facts.nil?
+      @facts.sanitize
+      merge(@facts.values)
+    end
+  end
+
+  # Merge any random parameters into our parameter list.
+  def merge(params)
+    params.each do |name, value|
+      if @parameters.include?(name)
+        Puppet::Util::Warnings.warnonce(_("The node parameter '%{param_name}' for node '%{node_name}' was already set to '%{value}'. It could not be set to '%{desired_value}'") % { param_name: name, node_name: @name, value: @parameters[name], desired_value: value })
+      else
+        @parameters[name] = value
+      end
+    end
+
+    @parameters[ENVIRONMENT] ||= self.environment.name.to_s
+  end
+
+  def add_server_facts(facts)
+    # Append the current environment to the list of server facts
+    @server_facts = facts.merge({ "environment" => self.environment.name.to_s})
+
+    # Merge the server facts into the parameters for the node
+    merge(facts)
+  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}") % { name: 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}") % { name: name }) unless @trusted_data.nil?
+    @trusted_data = data.freeze
+  end
+
+  # Resurrects and sanitizes trusted information in the node by modifying it and setting
+  # the trusted_data in the node from parameters.
+  # This modifies the node
+  #
+  def sanitize
+    # Resurrect "trusted information" that comes from node/fact terminus.
+    # The current way this is done in puppet db (currently the only one)
+    # is to store the node parameter 'trusted' as a hash of the trusted information.
+    #
+    # Thus here there are two main cases:
+    # 1. This terminus was used in a real agent call (only meaningful if someone curls the request as it would
+    #  fail since the result is a hash of two catalogs).
+    # 2  It is a command line call with a given node that use a terminus that:
+    # 2.1 does not include a 'trusted' fact - use local from node trusted information
+    # 2.2 has a 'trusted' fact - this in turn could be
+    # 2.2.1 puppet db having stored trusted node data as a fact (not a great design)
+    # 2.2.2 some other terminus having stored a fact called "trusted" (most likely that would have failed earlier, but could
+    #       be spoofed).
+    #
+    # For the reasons above, the resurrection of trusted node data with authenticated => true is only performed
+    # if user is running as root, else it is resurrected as unauthenticated.
+    #
+    trusted_param = @parameters['trusted']
+    if trusted_param
+      # Blows up if it is a parameter as it will be set as $trusted by the compiler as if it was a variable
+      @parameters.delete('trusted')
+      unless trusted_param.is_a?(Hash) && %w{authenticated certname extensions}.all? {|key| trusted_param.has_key?(key) }
+        # trusted is some kind of garbage, do not resurrect
+        trusted_param = nil
+      end
+    else
+      # trusted may be Boolean false if set as a fact by someone
+      trusted_param = nil
+    end
+
+    # The options for node.trusted_data in priority order are:
+    # 1) node came with trusted_data so use that
+    # 2) else if there is :trusted_information in the puppet context
+    # 3) else if the node provided a 'trusted' parameter (parsed out above)
+    # 4) last, fallback to local node trusted information
+    #
+    # Note that trusted_data should be a hash, but (2) and (4) are not
+    # hashes, so we to_h at the end
+    if !trusted_data
+      trusted = Puppet.lookup(:trusted_information) do
+        trusted_param || Puppet::Context::TrustedInformation.local(self)
+      end
+
+      # Ruby 1.9.3 can't apply to_h to a hash, so check first
+      self.trusted_data = (trusted.is_a?(Hash) ? trusted : trusted.to_h)
+    end
+  end
+end

data/vendored/puppet/lib/puppet/node/environment.rb

@@ -0,0 +1,572 @@
+require 'puppet/util'
+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
+
+  NO_MANIFEST = :no_manifest
+
+  # The create() factory method should be used instead.
+  #
+  # @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 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.
+  # @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.intern,
+             expand_dirs(extralibs() + modulepath),
+             manifest == NO_MANIFEST ? manifest : Puppet::FileSystem.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
+  # 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)
+    Remote.create(name, [], NO_MANIFEST)
+  end
+
+  # Instantiate a new environment
+  #
+  # @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)
+    @name = name
+    @modulepath = modulepath
+    @manifest = manifest
+    @config_version = config_version
+    @modules_strict_semver = false
+  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 :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.
+  #
+  # @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)
+      overrides[:manifest] = settings.value(:manifest)
+    end
+
+    overrides.empty? ?
+      self :
+      self.override_with(overrides)
+  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
+
+  # @!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
+
+  # Cached loaders - management of value handled by Puppet::Pops::Loaders
+  # @api private
+  attr_accessor :loaders
+
+  # 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 private
+  def conflicting_manifest_settings?
+    return false if !Puppet[:disable_per_environment_manifest]
+    original_manifest = configuration.raw_setting(:manifest)
+    !original_manifest.nil? && !original_manifest.empty? && original_manifest != Puppet[:default_manifest]
+  end
+
+  # @api private
+  def static_catalogs?
+    if @static_catalogs.nil?
+      environment_conf = Puppet.lookup(:environments).get_conf(name)
+      @static_catalogs = (environment_conf.nil? ? Puppet[:static_catalogs] : environment_conf.static_catalogs)
+    end
+    @static_catalogs
+  end
+
+  # Return the environment configuration
+  # @return [Puppet::Settings::EnvironmentConf] The configuration
+  #
+  # @api private
+  def configuration
+    Puppet.lookup(:environments).get_conf(name)
+  end
+
+  # 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 '%{env_name}' environment has an environment.conf manifest that conflicts with the 'default_manifest' setting.") % { env_name: name }
+    end
+    errors
+  end
+
+  # Checks if this environment permits use of rich data types in the catalog
+  # @return [Boolean] `true` if rich data is permitted.
+  # @api private
+  def rich_data?
+    if @rich_data.nil?
+      environment_conf = Puppet.lookup(:environments).get_conf(name)
+      @rich_data = (environment_conf.nil? ? Puppet[:rich_data] : environment_conf.rich_data)
+    end
+    @rich_data
+  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
+
+  # A SemanticPuppet::VersionRange version >= 1.0.0 will not include versions with pre-release
+  # identifiers unless that is explicitly declared. This may cause backward compatibility
+  # issues when resolving module dependencies and the flag is therefore set to `false` by default.
+  #
+  # @param flag [Boolean] set to true to resolve module dependencies using strict SemVer semantics
+  #
+  def modules_strict_semver=(flag)
+    @modules_strict_semver = flag
+  end
+
+  # @return [Boolean] the current value of the modules_strict_semver flag.
+  # @api public
+  def modules_strict_semver?
+    @modules_strict_semver
+  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
+
+  # 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
+
+      @modules = module_references.collect do |reference|
+        begin
+          Puppet::Module.new(reference[:name], reference[:path], self, modules_strict_semver?)
+        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`.
+  #
+  # @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|
+      if Puppet::FileSystem.exist?(path)
+        Dir.chdir(path) do
+          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, modules_strict_semver?)
+          end
+        end
+      else
+        modules_by_path[path] = []
+      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
+
+  # Checks if a reparse is required (cache of files is stale).
+  #
+  def check_for_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
+  #
+  # @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
+
+  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 Puppet::Util.get_env('PUPPETLIB')
+      split_path(Puppet::Util.get_env('PUPPETLIB'))
+    else
+      []
+    end
+  end
+
+  def self.expand_dirs(dirs)
+    dirs.collect do |dir|
+      Puppet::FileSystem.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[: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 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
+    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 file == NO_MANIFEST
+        empty_parse_result
+      elsif File.directory?(file)
+        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
+        # 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 Puppet::ParseErrorWithIssue => detail
+    @known_resource_types.parse_failed = true
+    detail.environment = self.name
+    raise
+  rescue => detail
+    @known_resource_types.parse_failed = true
+
+    msg = _("Could not parse for environment %{env}: %{detail}") % { env: self, detail: detail }
+    error = Puppet::Error.new(msg)
+    error.set_backtrace(detail.backtrace)
+    raise error
+  end
+
+  # Return an empty top-level hostclass to indicate that no file was loaded
+  #
+  # @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 = None.create(:none, [])
+end