puppet 3.7.3 → 3.7.4

data/lib/puppet/pops/evaluator/collectors/fixed_set_collector.rb

@@ -0,0 +1,37 @@
+class Puppet::Pops::Evaluator::Collectors::FixedSetCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
+
+  # Creates a FixedSetCollector using the AbstractCollector constructor
+  # to set the scope. It is not possible for a collection to have
+  # overrides in this case, since we have a fixed set of resources that
+  # can be different types.
+  #
+  # @param [Array] resources the fixed set of resources we want to realize
+  def initialize(scope, resources)
+    super(scope)
+    @resources = resources.is_a?(Array)? resources.dup : [resources]
+  end
+
+  # Collects a fixed set of resources and realizes them. Used
+  # by the realize function
+  def collect
+    resolved = []
+    result = @resources.reduce([]) do |memo, ref|
+      if res = @scope.findresource(ref.to_s)
+        res.virtual = false
+        memo << res
+        resolved << ref
+      end
+      memo
+    end
+
+    @resources = @resources - resolved
+
+    @scope.compiler.delete_collection(self) if @resources.empty?
+
+    result
+  end
+
+  def unresolved_resources
+    @resources
+  end
+end

data/lib/puppet/pops/evaluator/compare_operator.rb

@@ -39,47 +39,27 @@ class Puppet::Pops::Evaluator::CompareOperator
   protected
 
   def cmp_String(a, b)
-    # if both are numerics in string form, compare as number
-    n1 = Puppet::Pops::Utils.to_n(a)
-    n2 = Puppet::Pops::Utils.to_n(b)
-
-    # Numeric is always lexically smaller than a string, even if the string is empty.
-    return n1 <=> n2    if n1 && n2
-    return -1           if n1 && b.is_a?(String)
-    return 1            if n2
     return a.casecmp(b) if b.is_a?(String)
-
-    raise ArgumentError.new("A String is not comparable to a non String or Number")
+    raise ArgumentError.new("A String is not comparable to a non String")
   end
 
   # Equality is case independent.
   def equals_String(a, b)
-    if n1 = Puppet::Pops::Utils.to_n(a)
-      if n2 = Puppet::Pops::Utils.to_n(b)
-        n1 == n2
-      else
-        false
-      end
-    else
-      return false unless b.is_a?(String)
-      a.casecmp(b) == 0
-    end
+    return false unless b.is_a?(String)
+    a.casecmp(b) == 0
   end
 
   def cmp_Numeric(a, b)
-    if n2 = Puppet::Pops::Utils.to_n(b)
-      a <=> n2
-    elsif b.kind_of?(String)
-      # Numeric is always lexiographically smaller than a string, even if the string is empty.
-      -1
+    if b.is_a?(Numeric)
+      a <=> b
     else
-      raise ArgumentError.new("A Numeric is not comparable to non Numeric or String")
+      raise ArgumentError.new("A Numeric is not comparable to non Numeric")
     end
   end
 
   def equals_Numeric(a, b)
-    if n2 = Puppet::Pops::Utils.to_n(b)
-      a == n2
+    if b.is_a?(Numeric)
+      a == b
     else
       false
     end

data/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -562,26 +562,12 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     end
   end
 
-  # Evaluates a CollectExpression by transforming it into a 3x AST::Collection and then evaluating that.
-  # This is done because of the complex API between compiler, indirector, backends, and difference between
-  # collecting virtual resources and exported resources.
+  # Evaluates a CollectExpression by creating a collector transformer. The transformer
+  # will evaulate the collection, create the appropriate collector, and hand it off
+  # to the compiler to collect the resources specified by the query.
   #
   def eval_CollectExpression o, scope
-    # The Collect Expression and its contained query expressions are implemented in such a way in
-    # 3x that it is almost impossible to do anything about them (the AST objects are lazily evaluated,
-    # and the built structure consists of both higher order functions and arrays with query expressions
-    # that are either used as a predicate filter, or given to an indirection terminus (such as the Puppet DB
-    # resource terminus). Unfortunately, the 3x implementation has many inconsistencies that the implementation
-    # below carries forward.
-    #
-    collect_3x = Puppet::Pops::Model::AstTransformer.new().transform(o)
-    collected = collect_3x.evaluate(scope)
-    # the 3x returns an instance of Parser::Collector (but it is only registered with the compiler at this
-    # point and does not contain any valuable information (like the result)
-    # Dilemma: If this object is returned, it is a first class value in the Puppet Language and we
-    # need to be able to perform operations on it. We can forbid it from leaking by making CollectExpression
-    # a non R-value. This makes it possible for the evaluator logic to make use of the Collector.
-    collected
+    Puppet::Pops::Evaluator::CollectorTransformer.new().transform(o,scope)
   end
 
   def eval_ParenthesizedExpression(o, scope)

data/lib/puppet/pops/evaluator/relationship_operator.rb

@@ -76,6 +76,10 @@ class Puppet::Pops::Evaluator::RelationshipOperator
     o
   end
 
+  def transform_AbstractCollector(o, scope)
+    o
+  end
+
   # Array content needs to be transformed
   def transform_Array(o, scope)
     o.map{|x| transform(x, scope) }

data/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -194,7 +194,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
     # And if that is not enough, a source/target may be a Collector (a baked query that will be evaluated by the
     # compiler - it is simply passed through here for processing by the compiler at the right time).
     #
-    if source.is_a?(Puppet::Parser::Collector)
+    if source.is_a?(Puppet::Parser::Collector) || source.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       source_resource = source
     else
@@ -202,7 +202,7 @@ module Puppet::Pops::Evaluator::Runtime3Support
       type, title = catalog_type_to_split_type_title(source)
       source_resource = Puppet::Resource.new(type, title)
     end
-    if target.is_a?(Puppet::Parser::Collector)
+    if target.is_a?(Puppet::Parser::Collector) || target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       target_resource = target
     else

data/lib/puppet/pops/parser/egrammar.ra

@@ -635,14 +635,14 @@ reserved_word
 
 array
   : LISTSTART assignments endcomma  RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
-  | LISTSTART                       RBRACK { result = Factory.literal([]) ; loc result, val[0] }
+  | LISTSTART                       RBRACK { result = Factory.literal([]) ; loc result, val[0], val[1] }
   | LBRACK    assignments endcomma  RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
-  | LBRACK                          RBRACK { result = Factory.literal([]) ; loc result, val[0] }
+  | LBRACK                          RBRACK { result = Factory.literal([]) ; loc result, val[0], val[1] }
 
 hash
   : LBRACE hashpairs RBRACE       { result = Factory.HASH(val[1]); loc result, val[0], val[2] }
   | LBRACE hashpairs COMMA RBRACE { result = Factory.HASH(val[1]); loc result, val[0], val[3] }
-  | LBRACE RBRACE                 { result = Factory.literal({}) ; loc result, val[0], val[3] }
+  | LBRACE RBRACE                 { result = Factory.literal({}) ; loc result, val[0], val[1] }
 
   hashpairs
     : hashpair                 { result = [val[0]] }

data/lib/puppet/pops/parser/eparser.rb

@@ -2360,7 +2360,7 @@ module_eval(<<'.,.,', 'egrammar.ra', 636)
 
 module_eval(<<'.,.,', 'egrammar.ra', 637)
   def _reduce_180(val, _values, result)
-     result = Factory.literal([]) ; loc result, val[0] 
+     result = Factory.literal([]) ; loc result, val[0], val[1] 
     result
   end
 .,.,
@@ -2374,7 +2374,7 @@ module_eval(<<'.,.,', 'egrammar.ra', 638)
 
 module_eval(<<'.,.,', 'egrammar.ra', 639)
   def _reduce_182(val, _values, result)
-     result = Factory.literal([]) ; loc result, val[0] 
+     result = Factory.literal([]) ; loc result, val[0], val[1] 
     result
   end
 .,.,
@@ -2395,7 +2395,7 @@ module_eval(<<'.,.,', 'egrammar.ra', 643)
 
 module_eval(<<'.,.,', 'egrammar.ra', 644)
   def _reduce_185(val, _values, result)
-     result = Factory.literal({}) ; loc result, val[0], val[3] 
+     result = Factory.literal({}) ; loc result, val[0], val[1] 
     result
   end
 .,.,

data/lib/puppet/pops/parser/evaluating_parser.rb

@@ -60,6 +60,10 @@ class Puppet::Pops::Parser::EvaluatingParser
     @@evaluator
   end
 
+  def convert_to_3x(object, scope)
+    val = @@evaluator.convert(object, scope, nil)
+  end
+
   def validate(parse_result)
     resulting_acceptor = acceptor()
     validator(resulting_acceptor).validate(parse_result)

data/lib/puppet/pops/types/type_calculator.rb

@@ -272,7 +272,12 @@ class Puppet::Pops::Types::TypeCalculator
     # Unit can be assigned to anything
     return true if t2.class == Types::PUnitType
 
-    @@assignable_visitor.visit_this_1(self, t, t2)
+    if t2.class == Types::PVariantType
+      # Assignable if all contained types are assignable
+      t2.types.all? { |vt| @@assignable_visitor.visit_this_1(self, t, vt) }
+    else
+      @@assignable_visitor.visit_this_1(self, t, t2)
+    end
  end
 
   # Returns an enumerable if the t represents something that can be iterated
@@ -411,9 +416,18 @@ class Puppet::Pops::Types::TypeCalculator
     return false unless o.is_a?(Array)
     return false unless o.all? {|element| instance_of(t.element_type, element) }
     size_t = t.size_type || @collection_default_size_t
-    size_t2 = size_as_type(o)
     # optimize by calling directly
-    assignable_PIntegerType(size_t, size_t2)
+    return instance_of_PIntegerType(size_t, o.size)
+  end
+
+  # @api private
+  def instance_of_PIntegerType(t, o)
+    return false unless o.is_a?(Integer)
+    x = t.from
+    x = -Float::INFINITY if x.nil? || x == :default
+    y = t.to
+    y = Float::INFINITY if y.nil? || y == :default
+    return x < y ? x <= o && y >= o : y <= o && x >= o
   end
 
   def instance_of_PTupleType(t, o)
@@ -421,9 +435,7 @@ class Puppet::Pops::Types::TypeCalculator
     # compute the tuple's min/max size, and check if that size matches
     size_t = t.size_type || Puppet::Pops::Types::TypeFactory.range(*t.size_range)
 
-    # compute the array's size as type
-    size_t2 = size_as_type(o)
-    return false unless assignable?(size_t, size_t2)
+    return false unless instance_of_PIntegerType(size_t, o.size)
     o.each_with_index do |element, index|
        return false unless instance_of(t.types[index] || t.types[-1], element)
     end
@@ -443,9 +455,8 @@ class Puppet::Pops::Types::TypeCalculator
     element_t = t.element_type
     return false unless o.keys.all? {|key| instance_of(key_t, key) } && o.values.all? {|value| instance_of(element_t, value) }
     size_t = t.size_type || @collection_default_size_t
-    size_t2 = size_as_type(o)
     # optimize by calling directly
-    assignable_PIntegerType(size_t, size_t2)
+    return instance_of_PIntegerType(size_t, o.size)
   end
 
   def instance_of_PDataType(t, o)

data/lib/puppet/pops/types/type_parser.rb

@@ -230,9 +230,6 @@ class Puppet::Pops::Types::TypeParser
 
     when "hash"
       result = case parameters.size
-      when 1
-        assert_type(parameters[0])
-        TYPES.hash_of(parameters[0])
       when 2
         assert_type(parameters[0])
         assert_type(parameters[1])
@@ -256,7 +253,7 @@ class Puppet::Pops::Types::TypeParser
         assert_type(parameters[1])
         TYPES.hash_of(parameters[1], parameters[0])
       else
-        raise_invalid_parameters_error("Hash", "1 to 4", parameters.size)
+        raise_invalid_parameters_error("Hash", "2 to 4", parameters.size)
       end
       result.size_type = size_type if size_type
       result

data/lib/puppet/provider/service/redhat.rb

@@ -15,9 +15,11 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init, :source => :init
     # The off method operates on run levels 2,3,4 and 5 by default We ensure
     # all run levels are turned off because the reset method may turn on the
     # service in run levels 0, 1 and/or 6
-    output = chkconfig("--level", "0123456", @resource[:name], :off)
-  rescue Puppet::ExecutionFailure
-    raise Puppet::Error, "Could not disable #{self.name}: #{output}", $!.backtrace
+    # We're not using --del here because we want to disable the service only,
+    # and --del removes the service from chkconfig management
+    chkconfig("--level", "0123456", @resource[:name], :off)
+  rescue Puppet::ExecutionFailure => detail
+    raise Puppet::Error, "Could not disable #{self.name}: #{detail}", detail.backtrace
   end
 
   def enabled?
@@ -39,6 +41,7 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init, :source => :init
   # Don't support them specifying runlevels; always use the runlevels
   # in the init scripts.
   def enable
+      chkconfig("--add", @resource[:name])
       chkconfig(@resource[:name], :on)
   rescue Puppet::ExecutionFailure => detail
     raise Puppet::Error, "Could not enable #{self.name}: #{detail}", detail.backtrace

data/lib/puppet/resource/catalog.rb

@@ -416,7 +416,18 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # If the block result is false, the resource will
   # be kept otherwise it will be skipped
   def filter(&block)
-    to_catalog :to_resource, &block
+    # to_catalog must take place in a context where current_environment is set to the same env as the
+    # environment set in the catalog (if it is set)
+    # See PUP-3755
+    if environment_instance
+      Puppet.override({:current_environment => environment_instance}) do
+        to_catalog :to_resource, &block
+      end
+    else
+      # If catalog has no environment_instance, hope that the caller has made sure the context has the
+      # correct current_environment
+      to_catalog :to_resource, &block
+    end
   end
 
   # Store the classes in the classfile.

data/lib/puppet/settings/environment_conf.rb

@@ -37,11 +37,11 @@ class Puppet::Settings::EnvironmentConf
   # Configuration values are exactly those returned by the environment object,
   # without interpolation.  This is a special case for the default configured
   # environment returned by the Puppet::Environments::StaticPrivate loader.
-  def self.static_for(environment)
-    Static.new(environment)
+  def self.static_for(environment, environment_timeout = 0)
+    Static.new(environment, environment_timeout)
   end
 
-  attr_reader :section
+  attr_reader :section, :path_to_env, :global_modulepath
 
   # Create through EnvironmentConf.load_from()
   def initialize(path_to_env, section, global_module_path)
@@ -151,8 +151,11 @@ class Puppet::Settings::EnvironmentConf
   #
   # @api private
   class Static
-    def initialize(environment)
+    attr_reader :environment_timeout
+
+    def initialize(environment, environment_timeout)
       @environment = environment
+      @environment_timeout = environment_timeout
     end
 
     def manifest
@@ -166,10 +169,6 @@ class Puppet::Settings::EnvironmentConf
     def config_version
       @environment.config_version
     end
-
-    def environment_timeout
-      0
-    end
   end
 
 end

data/lib/puppet/type/cron.rb

@@ -290,7 +290,11 @@ Puppet::Type.newtype(:cron) do
 
   newproperty(:month, :parent => CronParam) do
     def alpha
-      %w{january february march april may june july
+      # The ___placeholder accounts for the fact that month is unique among
+      # "nameable" crontab entries in that it does not use 0-based indexing.
+      # Padding the array with a placeholder introduces the appropriate shift
+      # in indices.
+      %w{___placeholder january february march april may june july
         august september october november december}
     end
     self.boundaries = [1, 12]

data/lib/puppet/type/file/content.rb

@@ -135,7 +135,7 @@ module Puppet
     def should=(value)
       # treat the value as a bytestring, in Ruby versions that support it, regardless of the encoding
       # in which it has been supplied
-      value = value.clone.force_encoding(Encoding::ASCII_8BIT) if value.respond_to?(:force_encoding)
+      value = value.dup.force_encoding(Encoding::ASCII_8BIT) if value.respond_to?(:force_encoding)
       @resource.newattr(:checksum) unless @resource.parameter(:checksum)
       super
     end

data/lib/puppet/util/tagging.rb

@@ -23,9 +23,28 @@ module Puppet::Util::Tagging
     end
   end
 
-  # Is the receiver tagged with the given tags?
+  # Answers if this resource is tagged with at least one of the given tags.
+  #
+  # The given tags are converted to downcased strings before the match is performed.
+  #
+  # @param *tags [String] splat of tags to look for
+  # @return [Boolean] true if this instance is tagged with at least one of the provided tags
+  #
   def tagged?(*tags)
-    not ( self.tags & tags.flatten.collect { |t| t.to_s } ).empty?
+    raw_tagged?(tags.collect {|t| t.to_s.downcase})
+  end
+
+  # Answers if this resource is tagged with at least one of the tags given in downcased string form.
+  #
+  # The method is a faster variant of the tagged? method that does no conversion of its
+  # arguments.
+  #
+  # @param tag_array [Array[String]] array of tags to look for
+  # @return [Boolean] true if this instance is tagged with at least one of the provided tags
+  #
+  def raw_tagged?(tag_array)
+    my_tags = self.tags
+    !tag_array.index { |t| my_tags.include?(t) }.nil?
   end
 
   # Return a copy of the tag list, so someone can't ask for our tags

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.7.3'
+  PUPPETVERSION = '3.7.4'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/integration/indirector/catalog/compiler_spec.rb

@@ -62,4 +62,15 @@ describe Puppet::Resource::Catalog::Compiler do
 
     Puppet::Resource::Catalog.indirection.find("mynode").resource_refs.should == [ @two.ref ]
   end
+
+  it "filters out virtual exported resources using the agent's production environment" do
+    Puppet[:node_terminus] = :memory
+    Puppet::Node.indirection.save(Puppet::Node.new("mynode"))
+
+    Puppet::Parser::Resource::Catalog.any_instance.expects(:to_resource).with do |catalog|
+      expect(Puppet.lookup(:current_environment).name).to eq(:production)
+    end
+
+    Puppet::Resource::Catalog.indirection.find("mynode")
+  end
 end