puppet 3.4.3 → 3.5.0.rc1

data/lib/puppet/pops/validation/validator_factory_4_0.rb

@@ -0,0 +1,31 @@
+# Configures validation suitable for 4.0
+#
+class Puppet::Pops::Validation::ValidatorFactory_4_0 < Puppet::Pops::Validation::Factory
+  Issues = Puppet::Pops::Issues
+
+  # Produces the checker to use
+  def checker diagnostic_producer
+    Puppet::Pops::Validation::Checker4_0.new(diagnostic_producer)
+  end
+
+  # Produces the label provider to use
+  def label_provider
+    Puppet::Pops::Model::ModelLabelProvider.new()
+  end
+
+  # Produces the severity producer to use
+  def severity_producer
+    p = super
+
+    # Configure each issue that should **not** be an error
+    #
+    # Validate as per the current runtime configuration
+    p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
+    p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
+
+    p[Issues::NAME_WITH_HYPHEN]             = :error
+    p[Issues::DEPRECATED_NAME_AS_TYPE]      = :error
+
+    p
+  end
+end

data/lib/puppet/pops/visitor.rb

@@ -37,14 +37,156 @@ class Puppet::Pops::Visitor
       return receiver.send(method_name, thing, *args)
     else
       thing.class.ancestors().each do |ancestor|
-        method_name = :"#{@message}_#{ancestor.name.split("::").last}"
-        # DEBUG OUTPUT
-        # puts "Visitor checking: #{receiver.class}.#{method_name}, responds to: #{@receiver.respond_to? method_name}"
-        next unless receiver.respond_to? method_name
+        method_name = :"#{@message}_#{ancestor.name.split(/::/).last}"
+        next unless receiver.respond_to?(method_name, true)
         @cache[thing.class] = method_name
         return receiver.send(method_name, thing, *args)
       end
     end
     raise "Visitor Error: the configured receiver (#{receiver.class}) can't handle instance of: #{thing.class}"
   end
+
+  # Visit an explicit receiver with 0 args
+  # (This is ~30% faster than calling the general method)
+  #
+  def visit_this_0(receiver, thing)
+    if method_name = @cache[thing.class]
+      return receiver.send(method_name, thing)
+    end
+    visit_this(receiver, thing)
+  end
+
+  # Visit an explicit receiver with 1 args
+  # (This is ~30% faster than calling the general method)
+  #
+  def visit_this_1(receiver, thing, arg)
+    if method_name = @cache[thing.class]
+      return receiver.send(method_name, thing, arg)
+    end
+    visit_this(receiver, thing, arg)
+  end
+
+  # Visit an explicit receiver with 2 args
+  # (This is ~30% faster than calling th general method)
+  #
+  def visit_this_2(receiver, thing, arg1, arg2)
+    if method_name = @cache[thing.class]
+      return receiver.send(method_name, thing, arg1, arg2)
+    end
+    visit_this(receiver, thing, arg1, arg2)
+  end
+
+  # Visit an explicit receiver with 3 args
+  # (This is ~30% faster than calling the general method)
+  #
+  def visit_this_3(receiver, thing, arg1, arg2, arg3)
+    if method_name = @cache[thing.class]
+      return receiver.send(method_name, thing, arg1, arg2, arg3)
+    end
+    visit_this(receiver, thing, arg1, arg2, arg3)
+  end
+
+  # This is an alternative implementation that separates the finding of method names
+  # (Cached in the Visitor2 class), and bound methods (in an inner Delegator class) that
+  # are cached for this receiver instance. This is based on micro benchmarks measuring that a send is slower
+  # that directly calling a bound method.
+  # Larger benchmark however show that the overhead is fractional. Additional (larger) tests may 
+  # show otherwise.
+  # To use this class instead of the regular Visitor.
+  #   @@the_visitor_c = Visitor2.new(...)
+  #   @@the_visitor = @@the_visitor_c.instance(self)
+  #   then visit with one of the Delegator's visit methods.
+  #
+  # Performance Note: there are still issues with this implementation (although cleaner) since it requires
+  # holding on to the first instance in order to compute respond_do?. This is required if the class
+  # is using method_missing? which cannot be computed by introspection of the class (which would be
+  # ideal). Another approach is to pre-scan all the available methods starting with the pattern for
+  # the visitor, scan the class, and just check if the class has this method. (This will not work
+  # for dispatch to methods that requires method missing. (Maybe that does not matter)
+  # Further experiments could try looking up unbound methods via the class, cloning and binding them
+  # instead of again looking them up with #method(name)
+  # Also note that this implementation does not check min/max args on each call - there was not much gain
+  # from skipping this. It is safe to skip, but produces less friendly errors if there is an error in the
+  # implementation.
+  #
+  class Visitor2
+    attr_reader :receiver, :message, :min_args, :max_args, :cache
+
+    def initialize(receiver, message, min_args=0, max_args=nil)
+      raise ArgumentError.new("receiver can not be nil") if receiver.nil?
+      raise ArgumentError.new("min_args must be >= 0") if min_args < 0
+      raise ArgumentError.new("max_args must be >= min_args or nil") if max_args && max_args < min_args
+
+      @receiver = receiver
+      @message = message
+      @min_args = min_args
+      @max_args = max_args
+      @cache = Hash.new
+    end
+
+    def instance(receiver)
+      # Create a visitable instance for the receiver
+      Delegator.new(receiver, self)
+    end
+
+    # Produce the name of the method to use
+    # @return [Symbol, nil] the method name symbol, or nil if there is no method to call for thing
+    #
+    def method_name_for(thing)
+      if method_name = @cache[thing.class]
+        return method_name
+      else
+        thing.class.ancestors().each do |ancestor|
+          method_name = :"#{@message}_#{ancestor.name.split(/::/).last}"
+          next unless receiver.respond_to?(method_name, true)
+          @cache[thing.class] = method_name
+          return method_name
+        end
+      end
+    end
+
+    class Delegator
+      attr_reader :receiver, :visitor, :cache
+      def initialize(receiver, visitor)
+        @receiver = receiver
+        @visitor = visitor
+        @cache = Hash.new
+      end
+
+      # Visit
+      def visit(thing, *args)
+        if method = @cache[thing.class]
+          return method.call(thing, *args)
+        else
+          method_name = visitor.method_name_for(thing)
+          method = receiver.method(method_name)
+          unless method
+            raise "Visitor Error: the configured receiver (#{receiver.class}) can't handle instance of: #{thing.class}"
+          end
+          @cache[thing.class] = method
+          method.call(thing, *args)
+        end
+      end
+
+      # Visit an explicit receiver with 0 args
+      # (This is ~30% faster than calling the general method)
+      #
+      def visit_0(thing)
+        (method = @cache[thing.class]) ? method.call(thing) : visit(thing)
+      end
+
+      def visit_1(thing, arg)
+        (method = @cache[thing.class]) ? method.call(thing, arg) : visit(thing, arg)
+      end
+
+      def visit_2(thing, arg1, arg2)
+        (method = @cache[thing.class]) ? method.call(thing, arg1, arg2) : visit(thing, arg1, arg2)
+      end
+
+      def visit_3(thing, arg1, arg2, arg3)
+        (method = @cache[thing.class]) ? method.call(thing, arg1, arg2, arg3) : visit(thing, arg1, arg2, arg3)
+      end
+
+    end
+  end
 end

data/lib/puppet/property.rb

@@ -231,7 +231,7 @@ class Puppet::Property < Puppet::Parameter
     rescue => detail
       message = "Could not convert change '#{name}' to string: #{detail}"
       Puppet.log_exception(detail, message)
-      raise Puppet::DevError, message
+      raise Puppet::DevError, message, detail.backtrace
     end
   end
 

data/lib/puppet/property/ensure.rb

@@ -59,7 +59,7 @@ class Puppet::Property::Ensure < Puppet::Property
     rescue Puppet::Error, Puppet::DevError
       raise
     rescue => detail
-      raise Puppet::DevError, "Could not convert change #{self.name} to string: #{detail}"
+      raise Puppet::DevError, "Could not convert change #{self.name} to string: #{detail}", detail.backtrace
     end
   end
 

data/lib/puppet/provider.rb

@@ -280,32 +280,47 @@ class Puppet::Provider
   end
 
   # @return [Boolean] Returns whether this implementation satisfies all of the default requirements or not.
-  #   Returns false If defaults are empty.
+  #   Returns false if there is no matching defaultfor
   # @see Provider.defaultfor
   #
   def self.default?
-    return false if @defaults.empty?
-    if @defaults.find do |fact, values|
-        values = [values] unless values.is_a? Array
-        if fval = Facter.value(fact).to_s and fval != ""
-          fval = fval.to_s.downcase.intern
-        else
-          return false
-        end
+    default_match ? true : false
+  end
 
-        # If any of the values match, we're a default.
-        if values.find do |value| fval == value.to_s.downcase.intern end
-          false
-        else
-          true
+  # Look through the array of defaultfor hashes and return the first match.
+  # @return [Hash<{String => Object}>] the matching hash specified by a defaultfor
+  # @see Provider.defaultfor
+  # @api private
+  def self.default_match
+    @defaults.find do |default|
+      default.all? do |key, values|
+        case key
+          when :feature
+            feature_match(values)
+          else
+            fact_match(key, values)
         end
       end
-      return false
+    end
+  end
+
+  def self.fact_match(fact, values)
+    values = [values] unless values.is_a? Array
+    values.map! { |v| v.to_s.downcase.intern }
+
+    if fval = Facter.value(fact).to_s and fval != ""
+      fval = fval.to_s.downcase.intern
+
+      values.include?(fval)
     else
-      return true
+      false
     end
   end
 
+  def self.feature_match(value)
+    Puppet.features.send(value.to_s + "?")
+  end
+
   # Sets a facts filter that determine which of several suitable providers should be picked by default.
   # This selection only kicks in if there is more than one suitable provider.
   # To filter on multiple facts the given hash may contain more than one fact name/value entry.
@@ -315,14 +330,12 @@ class Puppet::Provider
   # @return [void]
   #
   def self.defaultfor(hash)
-    hash.each do |d,v|
-      @defaults[d] = v
-    end
+    @defaults << hash
   end
 
   # @return [Integer] Returns a numeric specificity for this provider based on how many requirements it has
   #  and number of _ancestors_. The higher the number the more specific the provider.
-  # The number of requirements is based on the number of defaults set up with {Provider.defaultfor}.
+  # The number of requirements is based on the hash size of the matching {Provider.defaultfor}.
   #
   # The _ancestors_ is the Ruby Module::ancestors method and the number of classes returned is used
   # to boost the score. The intent is that if two providers are equal, but one is more "derived" than the other
@@ -335,13 +348,15 @@ class Puppet::Provider
     # are to increase the score. What is will actually do is count all classes that Ruby Module::ancestors
     # returns (which can be other classes than those the parent chain) - in a way, an odd measure of the
     # complexity of a provider).
-    (@defaults.length * 100) + ancestors.select { |a| a.is_a? Class }.length
+    match = default_match
+    length = match ? match.length : 0
+    (length * 100) + ancestors.select { |a| a.is_a? Class }.length
   end
 
   # Initializes defaults and commands (i.e. clears them).
   # @return [void]
   def self.initvars
-    @defaults = {}
+    @defaults = []
     @commands = {}
   end
 
@@ -419,7 +434,11 @@ class Puppet::Provider
       attr = attr.intern
       next if attr == :name
       define_method(attr) do
-        @property_hash[attr] || :absent
+        if @property_hash[attr].nil?
+          :absent
+        else
+          @property_hash[attr]
+        end
       end
 
       define_method(attr.to_s + "=") do |val|
@@ -487,9 +506,11 @@ class Puppet::Provider
 
   dochook(:defaults) do
     if @defaults.length > 0
-      return "Default for " + @defaults.collect do |f, v|
-        "`#{f}` == `#{[v].flatten.join(', ')}`"
-      end.sort.join(" and ") + "."
+      return @defaults.collect do |d|
+        "Default for " + d.collect do |f, v|
+          "`#{f}` == `#{[v].flatten.join(', ')}`"
+        end.sort.join(" and ") + "."
+      end.join(" ")
     end
   end
 

data/lib/puppet/provider/aixobject.rb

@@ -317,7 +317,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
     begin
       execute(self.addcmd)
     rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Could not create #{@resource.class.name} #{@resource.name}: #{detail}"
+      raise Puppet::Error, "Could not create #{@resource.class.name} #{@resource.name}: #{detail}", detail.backtrace
     end
   end
 
@@ -332,7 +332,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
     begin
       execute(self.deletecmd)
     rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Could not delete #{@resource.class.name} #{@resource.name}: #{detail}"
+      raise Puppet::Error, "Could not delete #{@resource.class.name} #{@resource.name}: #{detail}", detail.backtrace
     end
   end
 
@@ -376,7 +376,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
       begin
         execute(cmd)
       rescue Puppet::ExecutionFailure  => detail
-        raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}"
+        raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}", detail.backtrace
       end
     end
 

data/lib/puppet/provider/augeas/augeas.rb

@@ -169,7 +169,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
       if resource[:incl]
         aug.set("/augeas/load/Xfm/lens", resource[:lens])
         aug.set("/augeas/load/Xfm/incl", resource[:incl])
-        restricted = true
+        restricted_metadata = "/augeas//error"
       elsif glob_avail and opt_ctx
         # Optimize loading if the context is given, requires the glob function
         # from Augeas 0.8.2 or up
@@ -178,14 +178,14 @@ Puppet::Type.type(:augeas).provide(:augeas) do
 
         if aug.match(load_path).size < aug.match("/augeas/load/*").size
           aug.rm(load_path)
-          restricted = true
+          restricted_metadata = "/augeas/files#{ctx_path}/error"
         else
           # This will occur if the context is less specific than any glob
           debug("Unable to optimize files loaded by context path, no glob matches")
         end
       end
       aug.load
-      print_load_errors(:warning => restricted)
+      print_load_errors(restricted_metadata)
     end
     @aug
   end
@@ -308,7 +308,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
       load_path.flatten!
     end
 
-    if Puppet::FileSystem::File.exist?("#{Puppet[:libdir]}/augeas/lenses")
+    if Puppet::FileSystem.exist?("#{Puppet[:libdir]}/augeas/lenses")
       load_path << "#{Puppet[:libdir]}/augeas/lenses"
     end
 
@@ -323,10 +323,10 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     @aug.set("/augeas/save", mode)
   end
 
-  def print_load_errors(args={})
+  def print_load_errors(path)
     errors = @aug.match("/augeas//error")
     unless errors.empty?
-      if args[:warning]
+      if path && !@aug.match(path).empty?
         warning("Loading failed for one or more files, see debug for /augeas//error output")
       else
         debug("Loading failed for one or more files, output from /augeas//error:")
@@ -385,7 +385,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
           save_result = @aug.save
           unless save_result
             print_put_errors
-            fail("Save failed with return code #{save_result}, see debug")
+            fail("Saving failed, see debug")
           end
 
           saved_files = @aug.match("/augeas/events/saved")
@@ -425,10 +425,10 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     set_augeas_save_mode(SAVE_OVERWRITE) if versioncmp(get_augeas_version, "0.3.6") >= 0
     @aug.load
     do_execute_changes
-        unless @aug.save
-          print_put_errors
-          fail("Save failed with return code #{success}, see debug")
-        end
+    unless @aug.save
+      print_put_errors
+      fail("Save failed, see debug")
+    end
 
     :executed
   ensure

data/lib/puppet/provider/cron/crontab.rb

@@ -68,6 +68,7 @@ Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFi
 
     def to_line(record)
       str = ""
+      record[:name] = nil if record[:unmanaged]
       str = "# Puppet Name: #{record[:name]}\n" if record[:name]
       if record[:environment] and record[:environment] != :absent
         str += record[:environment].map {|line| "#{line}\n"}.join('')
@@ -132,7 +133,8 @@ Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFi
   # See if we can match the record against an existing cron job.
   def self.match(record, resources)
     # if the record is named, do not even bother (#19876)
-    return false if record[:name]
+    # except the resource name was implicitly generated (#3220)
+    return false if record[:name] and !record[:unmanaged]
     resources.each do |name, resource|
       # Match the command first, since it's the most important one.
       next unless record[:target] == resource[:target]
@@ -167,6 +169,8 @@ Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFi
     false
   end
 
+  @name_index = 0
+
   # Collapse name and env records.
   def self.prefetch_hook(records)
     name = nil
@@ -194,6 +198,11 @@ Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFi
         if name
           record[:name] = name
           name = nil
+        else
+          cmd_string = record[:command].gsub(/\s+/, "_")
+          index = ( @name_index += 1 )
+          record[:name] = "unmanaged:#{cmd_string}-#{ index.to_s }"
+          record[:unmanaged] = true
         end
         if envs.nil? or envs.empty?
           record[:environment] = :absent