puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/lib/puppet/module_tool/skeleton/templates/generator/README.md.erb

@@ -0,0 +1,79 @@
+# <%= metadata.name %>
+
+#### Table of Contents
+
+1. [Overview](#overview)
+2. [Module Description - What the module does and why it is useful](#module-description)
+3. [Setup - The basics of getting started with <%= metadata.name %>](#setup)
+    * [What <%= metadata.name %> affects](#what-<%= metadata.name %>-affects)
+    * [Setup requirements](#setup-requirements)
+    * [Beginning with <%= metadata.name %>](#beginning-with-<%= metadata.name %>)
+4. [Usage - Configuration options and additional functionality](#usage)
+5. [Reference - An under-the-hood peek at what the module is doing and how](#reference)
+5. [Limitations - OS compatibility, etc.](#limitations)
+6. [Development - Guide for contributing to the module](#development)
+
+## Overview
+
+A one-maybe-two sentence summary of what the module does/what problem it solves.
+This is your 30 second elevator pitch for your module. Consider including
+OS/Puppet version it works with.
+
+## Module Description
+
+If applicable, this section should have a brief description of the technology
+the module integrates with and what that integration enables. This section
+should answer the questions: "What does this module *do*?" and "Why would I use
+it?"
+
+If your module has a range of functionality (installation, configuration,
+management, etc.) this is the time to mention it.
+
+## Setup
+
+### What <%= metadata.name %> affects
+
+* A list of files, packages, services, or operations that the module will alter,
+  impact, or execute on the system it's installed on.
+* This is a great place to stick any warnings.
+* Can be in list or paragraph form.
+
+### Setup Requirements **OPTIONAL**
+
+If your module requires anything extra before setting up (pluginsync enabled,
+etc.), mention it here.
+
+### Beginning with <%= metadata.name %>
+
+The very basic steps needed for a user to get the module up and running.
+
+If your most recent release breaks compatibility or requires particular steps
+for upgrading, you may wish to include an additional section here: Upgrading
+(For an example, see http://forge.puppetlabs.com/puppetlabs/firewall).
+
+## Usage
+
+Put the classes, types, and resources for customizing, configuring, and doing
+the fancy stuff with your module here.
+
+## Reference
+
+Here, list the classes, types, providers, facts, etc contained in your module.
+This section should include all of the under-the-hood workings of your module so
+people know what the module is touching on their system but don't need to mess
+with things. (We are working on automating this section!)
+
+## Limitations
+
+This is where you list OS compatibility, version compatibility, etc.
+
+## Development
+
+Since your module is awesome, other users will want to play with it. Let them
+know what the ground rules for contributing are.
+
+## Release Notes/Contributors/Etc **Optional**
+
+If you aren't using changelog, put your release notes here (though you should
+consider using changelog). You may also add any additional sections you feel are
+necessary or important to include here. Please use the `## ` header.

data/lib/puppet/module_tool/skeleton/templates/generator/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'puppetlabs_spec_helper/rake_tasks'
+require 'puppet-lint/tasks/puppet-lint'
+PuppetLint.configuration.send('disable_80chars')
+PuppetLint.configuration.ignore_paths = ["spec/**/*.pp", "pkg/**/*.pp"]
+
+desc "Validate manifests, templates, and ruby files"
+task :validate do
+  Dir['manifests/**/*.pp'].each do |manifest|
+    sh "puppet parser validate --noop #{manifest}"
+  end
+  Dir['spec/**/*.rb','lib/**/*.rb'].each do |ruby_file|
+    sh "ruby -c #{ruby_file}" unless ruby_file =~ /spec\/fixtures/
+  end
+  Dir['templates/**/*.erb'].each do |template|
+    sh "erb -P -x -T '-' #{template} | ruby -c"
+  end
+end

data/lib/puppet/module_tool/skeleton/templates/generator/metadata.json.erb

@@ -0,0 +1 @@
+<%= metadata.to_json %>

data/lib/puppet/module_tool/skeleton/templates/generator/spec/classes/init_spec.rb.erb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+describe '<%= metadata.name %>' do
+
+  context 'with defaults for all parameters' do
+    it { should contain_class('<%= metadata.name %>') }
+  end
+end

data/lib/puppet/module_tool/tar.rb

@@ -3,17 +3,13 @@ require 'puppet/util'
 
 module Puppet::ModuleTool::Tar
   require 'puppet/module_tool/tar/gnu'
-  require 'puppet/module_tool/tar/solaris'
   require 'puppet/module_tool/tar/mini'
 
-  def self.instance(module_name)
-    gtar_platforms = ['Solaris', 'OpenBSD']
-    if gtar_platforms.include?(Facter.value('osfamily')) && Puppet::Util.which('gtar')
-      Solaris.new
-    elsif Puppet::Util.which('tar') && ! Puppet::Util::Platform.windows?
+  def self.instance
+    if Puppet::Util.which('tar') && ! Puppet::Util::Platform.windows?
       Gnu.new
     elsif Puppet.features.minitar? && Puppet.features.zlib?
-      Mini.new(module_name)
+      Mini.new
     else
       raise RuntimeError, 'No suitable tar implementation found'
     end

data/lib/puppet/module_tool/tar/gnu.rb

@@ -1,16 +1,28 @@
 class Puppet::ModuleTool::Tar::Gnu
-  def initialize(command = "tar")
-    @command = command
-  end
-
   def unpack(sourcefile, destdir, owner)
-    Puppet::Util::Execution.execute("#{@command} xzf #{sourcefile} --no-same-owner -C #{destdir}")
-    Puppet::Util::Execution.execute("find #{destdir} -type d -exec chmod 755 {} +")
-    Puppet::Util::Execution.execute("find #{destdir} -type f -exec chmod a-wst {} +")
-    Puppet::Util::Execution.execute("chown -R #{owner} #{destdir}")
+    sourcefile = File.expand_path(sourcefile)
+    destdir = File.expand_path(destdir)
+
+    Dir.chdir(destdir) do
+      tarball = Puppet::Util::Execution.execute(['gzip', '-dc', sourcefile])
+      Puppet::Util::Execution.execpipe(['tar', 'xof', '-'], true, 'w+') do |pipe|
+        pipe.write(tarball)
+      end
+
+      Puppet::Util::Execution.execute(['find', destdir] + %w[-type d -exec chmod 755 {} +])
+      Puppet::Util::Execution.execute(['find', destdir] + %w[-type f -exec chmod a-wst {} +])
+      Puppet::Util::Execution.execute(['chown', '-R', owner, destdir])
+    end
   end
 
   def pack(sourcedir, destfile)
-    Puppet::Util::Execution.execute("tar cf - #{sourcedir} | gzip -c > #{destfile}")
+    tarball = Puppet::Util::Execution.execute(['tar', 'cf', '-', sourcedir])
+    Puppet::Util::Execution.execpipe(['gzip', '-c'], true, 'w+') do |pipe|
+      pipe.write(tarball)
+      pipe.close_write
+      File.open(destfile, 'w+') do |file|
+        file.write(pipe.read)
+      end
+    end
   end
 end

data/lib/puppet/module_tool/tar/mini.rb

@@ -1,8 +1,4 @@
 class Puppet::ModuleTool::Tar::Mini
-  def initialize(module_name)
-    @module_name = module_name
-  end
-
   def unpack(sourcefile, destdir, _)
     Zlib::GzipReader.open(sourcefile) do |reader|
       Archive::Tar::Minitar.unpack(reader, destdir) do |action, name, stats|
@@ -27,15 +23,13 @@ class Puppet::ModuleTool::Tar::Mini
 
   def validate_entry(destdir, path)
     if Pathname.new(path).absolute?
-      raise Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-        :requested_package => @module_name, :entry_path => path, :directory => destdir
+      raise Puppet::ModuleTool::Errors::InvalidPathInPackageError, :entry_path => path, :directory => destdir
     end
 
     path = File.expand_path File.join(destdir, path)
 
     if path !~ /\A#{Regexp.escape destdir}/
-      raise Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-        :requested_package => @module_name, :entry_path => path, :directory => destdir
+      raise Puppet::ModuleTool::Errors::InvalidPathInPackageError, :entry_path => path, :directory => destdir
     end
   end
 end

data/lib/puppet/network/http/api/v1.rb

@@ -65,7 +65,7 @@ class Puppet::Network::HTTP::API::V1
 
     configured_environment = Puppet.lookup(:environments).get(environment)
     if configured_environment.nil?
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find #{environment}", Puppet::Network::HTTP::Issues::ENVIRONMENT_NOT_FOUND)
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find environment '#{environment}'", Puppet::Network::HTTP::Issues::ENVIRONMENT_NOT_FOUND)
     else
       configured_environment = configured_environment.override_from_commandline(Puppet.settings)
       params[:environment] = configured_environment

data/lib/puppet/network/http/api/v2/authorization.rb

@@ -2,12 +2,14 @@ class Puppet::Network::HTTP::API::V2::Authorization
   include Puppet::Network::Authorization
 
   def call(request, response)
-    raise Puppet::Network::HTTP::Error::HTTPNotAuthorizedError, "Only GET requests are authorized for V2 endpoints" unless request.method == "GET"
+    if request.method != "GET"
+      raise Puppet::Network::HTTP::Error::HTTPNotAuthorizedError.new("Only GET requests are authorized for V2 endpoints", Puppet::Network::HTTP::Issues::UNSUPPORTED_METHOD)
+    end
 
     begin
       check_authorization(:find, request.path, request.params)
     rescue Puppet::Network::AuthorizationError => e
-      raise Puppet::Network::HTTP::Error::HTTPNotAuthorizedError, e.message, e.backtrace
+      raise Puppet::Network::HTTP::Error::HTTPNotAuthorizedError.new(e.message, Puppet::Network::HTTP::Issues::FAILED_AUTHORIZATION)
     end
   end
 end

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

@@ -7,4 +7,5 @@ module Puppet::Network::HTTP::Issues
   MISSING_HEADER_FIELD = :MISSING_HEADER_FIELD
   UNSUPPORTED_FORMAT = :UNSUPPORTED_FORMAT
   UNSUPPORTED_METHOD = :UNSUPPORTED_METHOD
+  FAILED_AUTHORIZATION = :FAILED_AUTHORIZATION
 end

data/lib/puppet/network/http_pool.rb

@@ -12,6 +12,15 @@ module Puppet::Network; end
 #
 module Puppet::Network::HttpPool
 
+  @http_client_class = Puppet::Network::HTTP::Connection
+
+  def self.http_client_class
+    @http_client_class
+  end
+  def self.http_client_class=(klass)
+    @http_client_class = klass
+  end
+
   # Retrieve a connection for the given host and port.
   #
   # @param host [String] The hostname to connect to
@@ -29,9 +38,9 @@ module Puppet::Network::HttpPool
                  Puppet::SSL::Validator.no_validator()
                end
 
-    Puppet::Network::HTTP::Connection.new(host, port,
-                                          :use_ssl => use_ssl,
-                                          :verify => verifier)
+    http_client_class.new(host, port,
+                            :use_ssl => use_ssl,
+                            :verify => verifier)
   end
 
   # Get an http connection that will be secured with SSL and have the
@@ -46,8 +55,8 @@ module Puppet::Network::HttpPool
   # @api public
   #
   def self.http_ssl_instance(host, port, verifier = Puppet::SSL::Validator.default_validator())
-    Puppet::Network::HTTP::Connection.new(host, port,
-                                          :use_ssl => true,
-                                          :verify => verifier)
+    http_client_class.new(host, port,
+                            :use_ssl => true,
+                            :verify => verifier)
   end
 end

data/lib/puppet/node/environment.rb

@@ -65,7 +65,8 @@ class Puppet::Node::Environment
 
     obj = self.create(symbol,
              split_path(Puppet.settings.value(:modulepath, symbol)),
-             Puppet.settings.value(:manifest, symbol))
+             Puppet.settings.value(:manifest, symbol),
+             Puppet.settings.value(:config_version, symbol))
     seen[symbol] = obj
   end
 
@@ -75,18 +76,36 @@ class Puppet::Node::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)
+  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))
+             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
@@ -94,38 +113,67 @@ class Puppet::Node::Environment
   #   semantics.
   #
   # @param name [Symbol] The environment name
-  def initialize(name, modulepath, manifest)
+  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)
+  #   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[:manifest] || manifest,
+                      env_params[:config_version] || config_version)
   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.
+  # 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 = {}
-    overrides[:modulepath] = self.class.split_path(settings[:modulepath]) if settings.set_by_cli?(:modulepath)
+
+    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[:manifest].start_with?(settings[:manifestdir]))
-      overrides[:manifest] = settings[: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)
@@ -183,6 +231,12 @@ class Puppet::Node::Environment
   #   @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
+
   # Return an environment-specific Puppet setting.
   #
   # @api public
@@ -342,36 +396,47 @@ class Puppet::Node::Environment
   #   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|
-        deps[mod_dep['name']] ||= []
-        dep_details = {
+        dep_name = mod_dep['name'].tr('-', '/')
+        (deps[dep_name] ||= []) << {
           'name'                => mod.forge_name,
           'version'             => mod.version,
           'version_requirement' => mod_dep['version_requirement']
         }
-        deps[mod_dep['name']] << dep_details
       end
     end
+
     deps.each do |mod, mod_deps|
-      deps[mod] = mod_deps.sort_by {|d| d['name']}
+      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.
-  # @param filename [File,String] File instance or filename
+  # 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)
-    known_resource_types.watch_file(file.to_s)
+    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) || (@known_resource_types && @known_resource_types.require_reparse?)
-      @parsed_code = nil
-      @known_resource_types = nil
+    if watching?
+      if (Puppet[:code] != @parsed_code) || (@known_resource_types && @known_resource_types.require_reparse?)
+        @parsed_code = nil
+        @known_resource_types = nil
+      end
     end
   end
 
@@ -493,4 +558,10 @@ class Puppet::Node::Environment
   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