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

data/lib/puppet/util/execution.rb

@@ -29,28 +29,32 @@ module Puppet::Util::Execution
     end
   end
 
-  # Executes the provided command with STDIN connected to a pipe, yielding the
-  # pipe object.
-  # This allows data to be fed to the subprocess.
-  #
   # The command can be a simple string, which is executed as-is, or an Array,
   # which is treated as a set of command arguments to pass through.
   #
-  # In all cases this is passed directly to the shell, and STDOUT and STDERR
-  # are connected together during execution.
-  # @param command [String, Array<String>] the command to execute as one string, or as parts in an array.
-  #   the parts of the array are joined with one separating space between each entry when converting to
-  #   the command line string to execute.
-  # @param failonfail [Boolean] (true) if the execution should fail with Exception on failure or not.
+  # In either case, the command is passed directly to the shell, STDOUT and
+  # STDERR are connected together, and STDOUT and STDIN are available via the
+  # yielded pipe. (Bear in mind that reading from or writing to a pipe that has
+  # not been opened in read or write mode respectively will block indefinitely.)
+  #
+  # @param command [String, Array<String>] the command to execute as one string,
+  #   or as parts in an array. The parts of the array are joined with one
+  #   separating space between each entry when converting to the command line
+  #   string to execute.
+  # @param failonfail [Boolean] (true) if the execution should fail with
+  #   Exception on failure or not.
+  # @param mode [String] ('r') the mode to open the pipe with
   # @yield [pipe] to a block executing a subprocess
   # @yieldparam pipe [IO] the opened pipe
   # @yieldreturn [String] the output to return
-  # @raise [Puppet::ExecutionFailure] if the executed chiled process did not exit with status == 0 and `failonfail` is
-  #   `true`.
-  # @return [String] a string with the output from the subprocess executed by the given block
-  # @api public
+  # @raise [Puppet::ExecutionFailure] if the executed chiled process did not
+  #   exit with status == 0 and `failonfail` is `true`.
+  # @return [String] a string with the output from the subprocess executed by
+  #   the given block
   #
-  def self.execpipe(command, failonfail = true)
+  # @see Kernel#open for `mode` values
+  # @api public
+  def self.execpipe(command, failonfail = true, mode = 'r')
     # Paste together an array with spaces.  We used to paste directly
     # together, no spaces, which made for odd invocations; the user had to
     # include whitespace between arguments.
@@ -72,7 +76,7 @@ module Puppet::Util::Execution
     # a predictable output
     english_env = ENV.to_hash.merge( {'LANG' => 'C', 'LC_ALL' => 'C'} )
     output = Puppet::Util.withenv(english_env) do
-      open("| #{command_str} 2>&1") do |pipe|
+      open("| #{command_str} 2>&1", mode) do |pipe|
         yield pipe
       end
     end

data/lib/puppet/util/feature.rb

@@ -70,6 +70,9 @@ class Puppet::Util::Feature
   def load_library(lib, name)
     raise ArgumentError, "Libraries must be passed as strings not #{lib.class}" unless lib.is_a?(String)
 
+    @rubygems ||= Puppet::Util::RubyGems::Source.new
+    @rubygems.clear_paths
+
     begin
       require lib
     rescue SystemExit,NoMemoryError

data/lib/puppet/util/logging.rb

@@ -55,19 +55,22 @@ module Puppet::Util::Logging
 
   class DeprecationWarning < Exception; end
 
-  # Log a warning indicating that the code path is deprecated.  Note that this method keeps track of the
-  # offending lines of code that triggered the deprecation warning, and will only log a warning once per
-  # offending line of code.  It will also stop logging deprecation warnings altogether after 100 unique
-  # deprecation warnings have been logged.
-  # Parameters:
-  # [message] The message to log (logs via )
-  def deprecation_warning(message)
+  # Logs a warning indicating that the code path is deprecated.  Note that this
+  # method keeps track of the offending lines of code that triggered the
+  # deprecation warning, and will only log a warning once per offending line of
+  # code.  It will also stop logging deprecation warnings altogether after 100
+  # unique deprecation warnings have been logged.
+  #
+  # @param [String] message The message to log (logs via )
+  # @param [String] key Optional key to mark the message as unique. If not
+  #   passed in, the originating call line will be used instead.
+  def deprecation_warning(message, key = nil)
     $deprecation_warnings ||= {}
     if $deprecation_warnings.length < 100 then
-      offender = get_deprecation_offender()
-      if (! $deprecation_warnings.has_key?(offender)) then
-        $deprecation_warnings[offender] = message
-        warning("#{message}\n   (at #{offender})")
+      key ||= (offender = get_deprecation_offender)
+      if (! $deprecation_warnings.has_key?(key)) then
+        $deprecation_warnings[key] = message
+        warning("#{message}\n   (at #{(offender || get_deprecation_offender).join('; ')})")
       end
     end
   end
@@ -78,7 +81,11 @@ module Puppet::Util::Logging
     #
     # let's find the offending line;  we need to jump back up the stack a few steps to find the method that called
     #  the deprecated method
-    caller()[2]
+    if Puppet[:trace]
+      caller()[2..-1]
+    else
+      [caller()[2]]
+    end
   end
 
   def clear_deprecation_warnings

data/lib/puppet/util/rubygems.rb

@@ -45,6 +45,10 @@ module Puppet::Util::RubyGems
         File.join(spec.full_gem_path, 'lib')
       end
     end
+
+    def clear_paths
+      Gem.clear_paths
+    end
   end
 
   # RubyGems < 1.8.0
@@ -53,6 +57,10 @@ module Puppet::Util::RubyGems
     def directories
       @paths ||= Gem.latest_load_paths
     end
+
+    def clear_paths
+      Gem.clear_paths
+    end
   end
 
   # @api private
@@ -60,6 +68,8 @@ module Puppet::Util::RubyGems
     def directories
       []
     end
+
+    def clear_paths; end
   end
 end
 

data/lib/puppet/util/watched_file.rb

@@ -8,7 +8,7 @@ class Puppet::Util::WatchedFile
   attr_reader :filename
 
   # @param filename [String] The fully qualified path to the file.
-  # @param file_timeout [Integer] The polling interval for checking for file
+  # @param timer [Puppet::Util::Watcher::Timer] The polling interval for checking for file
   #   changes. Setting the timeout to a negative value will treat the file as
   #   always changed. Defaults to `Puppet[:filetimeout]`
   def initialize(filename, timer = Puppet::Util::Watcher::Timer.new(Puppet[:filetimeout]))

data/lib/puppet/util/windows/security.rb

@@ -398,11 +398,13 @@ module Puppet::Util::Windows::Security
     end
   end
 
-  def add_access_denied_ace(acl, mask, sid)
+  def add_access_denied_ace(acl, mask, sid, inherit = nil)
+    inherit ||= NO_INHERITANCE
+
     string_to_sid_ptr(sid) do |sid_ptr|
       raise Puppet::Util::Windows::Error.new("Invalid SID") unless IsValidSid(sid_ptr)
 
-      unless AddAccessDeniedAce(acl, ACL_REVISION, mask, sid_ptr)
+      unless AddAccessDeniedAceEx(acl, ACL_REVISION, inherit, mask, sid_ptr)
         raise Puppet::Util::Windows::Error.new("Failed to add access control entry")
       end
     end
@@ -606,7 +608,7 @@ module Puppet::Util::Windows::Security
                   add_access_allowed_ace(acl, ace.mask, ace.sid, ace.flags)
                 when ACCESS_DENIED_ACE_TYPE
                   #puts "ace: deny, sid #{sid_to_name(ace.sid)}, mask 0x#{ace.mask.to_s(16)}"
-                  add_access_denied_ace(acl, ace.mask, ace.sid)
+                  add_access_denied_ace(acl, ace.mask, ace.sid, ace.flags)
                 else
                   raise "We should never get here"
                   # TODO: this should have been a warning in an earlier commit

data/lib/puppet/vendor/load_semantic.rb

@@ -0,0 +1 @@
+$: << File.join([File.dirname(__FILE__), "semantic/lib"])

data/lib/puppet/vendor/require_vendored.rb

@@ -3,3 +3,5 @@
 
 require 'safe_yaml'
 require 'puppet/vendor/safe_yaml_patches'
+
+# The vendored library 'semantic' is loaded on demand.

data/lib/puppet/vendor/semantic/Gemfile

@@ -0,0 +1,20 @@
+source "https://rubygems.org"
+
+group :development do
+  gem 'rake'
+  gem 'rubygems-tasks'
+end
+
+group :test do
+  gem 'rspec'
+end
+
+group :metrics do
+  gem 'cane',      :platform => [ :mri_19, :mri_20, :mri_21 ]
+  gem 'simplecov', :platform => [ :mri_19, :mri_20, :mri_21 ]
+end
+
+group :doc do
+  gem 'yard', '~> 0.8', :platform => [ :mri_19, :mri_20, :mri_21 ]
+  gem 'redcarpet',      :platform => [ :mri_19, :mri_20, :mri_21 ]
+end

data/lib/puppet/vendor/semantic/Rakefile

@@ -0,0 +1,69 @@
+# RSpec tasks
+begin
+  require 'rspec/core/rake_task'
+
+  # Create the 'spec' task
+  RSpec::Core::RakeTask.new(:spec) do |task|
+    task.rspec_opts = '--color'
+  end
+
+  namespace :spec do
+    desc "Run the test suite and generate coverage metrics"
+    task :coverage => [ :simplecov, :spec ]
+
+    # Add test coverage to the 'spec' task.
+    task :simplecov do
+      ENV['COVERAGE'] = '1'
+    end
+  end
+
+  task :default => :spec
+rescue LoadError
+  warn "[Warning]: Could not load `rspec`."
+end
+
+# YARD tasks
+begin
+  require 'yard'
+  require 'yard/rake/yardoc_task'
+
+  YARD::Rake::YardocTask.new(:doc) do |yardoc|
+    yardoc.files = [ 'lib/**/*.rb', '-', '**/*.md' ]
+  end
+rescue LoadError
+  warn "[Warning]: Could not load `yard`."
+end
+
+# Cane tasks
+begin
+  require 'cane/rake_task'
+
+  Cane::RakeTask.new(:cane) do |cane|
+    cane.add_threshold 'coverage/.last_run.json', :>=, 100
+    cane.abc_max = 15
+  end
+
+  Rake::Task['cane'].prerequisites << Rake::Task['spec:coverage']
+  Rake::Task[:default].clear_prerequisites
+  task :default => :cane
+rescue LoadError
+  warn "[Warning]: Could not load `cane`."
+end
+
+# Gem tasks
+begin
+  require 'rubygems/tasks'
+
+  task :gem => 'gem:build'
+  task :validate => [ 'cane', 'doc', 'gem:validate' ]
+
+  namespace :gem do
+    Gem::Tasks.new(
+      :tag => { :format => 'v%s' },
+      :sign => { :checksum => true, :pgp => true },
+      :build => { :tar => true }
+    )
+  end
+rescue LoadError
+  warn "[Warning]: Could not load `rubygems/tasks`."
+end

data/lib/puppet/vendor/semantic/lib/semantic.rb

@@ -0,0 +1,7 @@
+module Semantic
+  autoload :Version, 'semantic/version'
+  autoload :VersionRange, 'semantic/version_range'
+  autoload :Dependency, 'semantic/dependency'
+
+  VERSION = '0.0.1'
+end

data/lib/puppet/vendor/semantic/lib/semantic/dependency.rb

@@ -0,0 +1,181 @@
+require 'semantic'
+
+module Semantic
+  module Dependency
+    extend self
+
+    autoload :Graph,         'semantic/dependency/graph'
+    autoload :GraphNode,     'semantic/dependency/graph_node'
+    autoload :ModuleRelease, 'semantic/dependency/module_release'
+    autoload :Source,        'semantic/dependency/source'
+
+    autoload :UnsatisfiableGraph, 'semantic/dependency/unsatisfiable_graph'
+
+    # @!group Sources
+
+    # @return [Array<Source>] a frozen copy of the {Source} list
+    def sources
+      (@sources ||= []).dup.freeze
+    end
+
+    # Appends a new {Source} to the current list.
+    # @param source [Source] the {Source} to add
+    # @return [void]
+    def add_source(source)
+      sources
+      @sources << source
+      nil
+    end
+
+    # Clears the current list of {Source}s.
+    # @return [void]
+    def clear_sources
+      sources
+      @sources.clear
+      nil
+    end
+
+    # @!endgroup
+
+    # Fetches a graph of modules and their dependencies from the currently
+    # configured list of {Source}s.
+    #
+    # @todo Return a specialized "Graph" object.
+    # @todo Allow for external constraints to be added to the graph.
+    # @see #sources
+    # @see #add_source
+    # @see #clear_sources
+    #
+    # @param modules [{ String => String }]
+    # @return [Graph] the root of a dependency graph
+    def query(modules)
+      constraints = Hash[modules.map { |k, v| [ k, VersionRange.parse(v) ] }]
+
+      graph = Graph.new(constraints)
+      fetch_dependencies(graph)
+      return graph
+    end
+
+    # Given a graph result from {#query}, this method will resolve the graph of
+    # dependencies, if possible, into a flat list of the best suited modules. If
+    # the dependency graph does not have a suitable resolution, this method will
+    # raise an exception to that effect.
+    #
+    # @param graph [Graph] the root of a dependency graph
+    # @return [Array<ModuleRelease>] the list of releases to act on
+    def resolve(graph)
+      catch :next do
+        return walk(graph, graph.dependencies.dup)
+      end
+      raise UnsatisfiableGraph.new(graph)
+    end
+
+    # Fetches all available releases for the given module name.
+    #
+    # @param name [String] the module name to find releases for
+    # @return [Array<ModuleRelease>] the available releases
+    def fetch_releases(name)
+      releases = {}
+
+      sources.each do |source|
+        source.fetch(name).each do |dependency|
+          releases[dependency.version] ||= dependency
+        end
+      end
+
+      return releases.values
+    end
+
+    private
+
+    # Iterates over a changing set of dependencies in search of the best
+    # solution available. Fitness is specified as meeting all the constraints
+    # placed on it, being {ModuleRelease#satisfied? satisfied}, and having the
+    # greatest version number (with stability being preferred over prereleases).
+    #
+    # @todo Traversal order is not presently guaranteed.
+    #
+    # @param graph [Graph] the root of a dependency graph
+    # @param dependencies [{ String => Array<ModuleRelease> }] the dependencies
+    # @param considering [Array<GraphNode>] the set of releases being tested
+    # @return [Array<GraphNode>] the list of releases to use, if successful
+    def walk(graph, dependencies, *considering)
+      return considering if dependencies.empty?
+
+      # Selecting a dependency from the collection...
+      name = dependencies.keys.sort.first
+      deps = dependencies.delete(name)
+
+      # ... (and stepping over it if we've seen it before) ...
+      unless (deps & considering).empty?
+        return walk(graph, dependencies, *considering)
+      end
+
+      # ... we'll iterate through the list of possible versions in order.
+      preferred_releases(deps).reverse_each do |dep|
+
+        # We should skip any releases that violate any module's constraints.
+        unless [graph, *considering].all? { |x| x.satisfies_constraints?(dep) }
+          next
+        end
+
+        # We should skip over any releases that violate graph-level constraints.
+        potential_solution = considering.dup << dep
+        unless graph.satisfies_graph? potential_solution
+          next
+        end
+
+        catch :next do
+          # After adding any new dependencies and imposing our own constraints
+          # on existing dependencies, we'll mark ourselves as "under
+          # consideration" and recurse.
+          merged = dependencies.merge(dep.dependencies) { |_,a,b| a & b }
+
+          # If all subsequent dependencies resolved well, the recursive call
+          # will return a completed dependency list. If there were problems
+          # resolving our dependencies, we'll catch `:next`, which will cause
+          # us to move to the next possibility.
+          return walk(graph, merged, *potential_solution)
+        end
+      end
+
+      # Once we've exhausted all of our possible versions, we know that our
+      # last choice was unusable, so we'll unwind the stack and make a new
+      # choice.
+      throw :next
+    end
+
+    # Given a {ModuleRelease}, this method will iterate through the current
+    # list of {Source}s to find the complete list of versions available for its
+    # dependencies.
+    #
+    # @param node [GraphNode] the node to fetch details for
+    # @return [void]
+    def fetch_dependencies(node, cache = {})
+      node.dependency_names.each do |name|
+        unless cache.key?(name)
+          cache[name] = fetch_releases(name)
+          cache[name].each { |dep| fetch_dependencies(dep, cache) }
+        end
+
+        node << cache[name]
+      end
+    end
+
+    # Given a list of potential releases, this method returns the most suitable
+    # releases for exploration. Only {ModuleRelease#satisfied? satisfied}
+    # releases are considered, and releases with stable versions are preferred.
+    #
+    # @param releases [Array<ModuleRelease>] a list of potential releases
+    # @return [Array<ModuleRelease>] releases open for consideration
+    def preferred_releases(releases)
+      satisfied = releases.select { |x| x.satisfied? }
+
+      if satisfied.any? { |x| x.version.stable? }
+        return satisfied.select { |x| x.version.stable? }
+      else
+        return satisfied
+      end
+    end
+  end
+end