puppet 4.0.0-x64-mingw32 → 4.1.0-x64-mingw32

data/lib/puppet/file_system.rb

@@ -126,6 +126,19 @@ module Puppet::FileSystem
     @impl.read(assert_path(path))
   end
 
+  # Read a file keeping the original line endings intact. This
+  # attempts to open files using binary mode using some encoding
+  # overrides and falling back to IO.read when none of the
+  # encodings are valid.
+  #
+  # @return [String] The contents of the file
+  #
+  # @api public
+  #
+  def self.read_preserve_line_endings(path)
+    @impl.read_preserve_line_endings(assert_path(path))
+  end
+
   # @return [String] The binary contents of the file
   #
   # @api public

data/lib/puppet/file_system/file_impl.rb

@@ -75,6 +75,10 @@ class Puppet::FileSystem::FileImpl
     path.read
   end
 
+  def read_preserve_line_endings(path)
+    read(path)
+  end
+
   def binread(path)
     raise NotImplementedError
   end

data/lib/puppet/file_system/memory_impl.rb

@@ -44,6 +44,10 @@ class Puppet::FileSystem::MemoryImpl
     handle.read
   end
 
+  def read_preserve_line_endings(path)
+    read(path)
+  end
+
   def open(path, *args, &block)
     handle = assert_path(path).handle
     if block_given?

data/lib/puppet/file_system/windows.rb

@@ -91,6 +91,14 @@ class Puppet::FileSystem::Windows < Puppet::FileSystem::Posix
     Puppet::Util::Windows::Security.set_mode(mode, path.to_s)
   end
 
+  def read_preserve_line_endings(path)
+    contents = path.read( :mode => 'rb', :encoding => Encoding::UTF_8)
+    contents = path.read( :mode => 'rb', :encoding => Encoding::default_external) unless contents.valid_encoding?
+    contents = path.read unless contents.valid_encoding?
+
+    contents
+  end
+
   private
 
   def raise_if_symlinks_unsupported

data/lib/puppet/functions.rb

@@ -256,6 +256,14 @@ module Puppet::Functions
     end
   end
 
+  # Base class for all functions implemented in the puppet language
+  class PuppetFunction < Function
+    def self.init_dispatch(a_closure)
+      # A closure is compatible with a dispatcher - they are both callable signatures
+      dispatcher.add(a_closure)
+    end
+  end
+
   # Public api methods of the DispatcherBuilder are available within dispatch()
   # blocks declared in a Puppet::Function.create_function() call.
   #
@@ -311,7 +319,25 @@ module Puppet::Functions
     #
     # @api public
     def repeated_param(type, name)
-      internal_param(type, name)
+      internal_param(type, name, true)
+      @max = :default
+    end
+    alias optional_repeated_param repeated_param
+
+    # Defines a repeated positional parameter with _type_ and _name_ that may occur 1 to "infinite" number of times.
+    # It may only appear last or just before a block parameter.
+    #
+    # @param type [String] The type specification for the parameter.
+    # @param name [Symbol] The name of the parameter. This is primarily used
+    #   for error message output and does not have to match an implementation
+    #   method parameter.
+    # @return [Void]
+    #
+    # @api public
+    def required_repeated_param(type, name)
+      internal_param(type, name, true)
+      raise ArgumentError, 'A required repeated parameter cannot be added after an optional parameter' if @min != @max
+      @min += 1
       @max = :default
     end
 
@@ -368,7 +394,7 @@ module Puppet::Functions
     private
 
     # @api private
-    def internal_param(type, name)
+    def internal_param(type, name, repeat = false)
       raise ArgumentError, 'Parameters cannot be added after a block parameter' unless @block_type.nil?
       raise ArgumentError, 'Parameters cannot be added after a repeated parameter' if @max == :default
 
@@ -380,7 +406,11 @@ module Puppet::Functions
         @types << type
         @names << name
         # mark what should be picked for this position when dispatching
-        @weaving << @names.size()-1
+        if repeat
+          @weaving << -@names.size()
+        else
+          @weaving << @names.size()-1
+        end
       else
         raise ArgumentError, "Parameter 'type' must be a String reference to a Puppet Data Type. Got #{type.class}"
       end

data/lib/puppet/functions/defined.rb

@@ -0,0 +1,130 @@
+# Determines whether
+# a given class or resource type is defined. This function can also determine whether a
+# specific resource has been declared, or whether a variable has been assigned a value
+# (including undef...as opposed to never having been assigned anything). Returns true
+# or false. Accepts class names, type names, resource references, and variable
+# reference strings of the form '$name'.  When more than one argument is
+# supplied, defined() returns true if any are defined.
+#
+# The `defined` function checks both native and defined types, including types
+# provided as plugins via modules. Types and classes are both checked using their names:
+#
+#     defined("file")
+#     defined("customtype")
+#     defined("foo")
+#     defined("foo::bar")
+#     defined('$name')
+#
+# Resource declarations are checked using resource references, e.g.
+# `defined( File['/tmp/myfile'] )`, or `defined( Class[myclass] )`.
+# Checking whether a given resource
+# has been declared is, unfortunately, dependent on the evaluation order of
+# the configuration, and the following code will not work:
+#
+#     if defined(File['/tmp/foo']) {
+#         notify { "This configuration includes the /tmp/foo file.":}
+#     }
+#     file { "/tmp/foo":
+#         ensure => present,
+#     }
+#
+# However, this order requirement refers to evaluation order only, and ordering of
+# resources in the configuration graph (e.g. with `before` or `require`) does not
+# affect the behavior of `defined`.
+#
+# You may also search using types:
+#
+#     defined(Resource['file','/some/file'])
+#     defined(File['/some/file'])
+#     defined(Class['foo'])
+#
+# The `defined` function does not answer if data types (e.g. `Integer`) are defined. If
+# given the string 'integer' the result is false, and if given a non CatalogEntry type,
+# an error is raised.
+#
+# The rules for asking for undef, empty strings, and the main class are different from 3.x
+# (non future parser) and 4.x (with future parser or in Puppet 4.0.0 and later):
+#
+#     defined('')     # 3.x => true,  4.x => false
+#     defined(undef)  # 3.x => true,  4.x => error
+#     defined('main') # 3.x => false, 4.x => true
+#
+# With the future parser, it is also possible to ask specifically if a name is
+# a resource type (built in or defined), or a class, by giving its type:
+#
+#     defined(Type[Class['foo']])
+#     defined(Type[Resource['foo']])
+#
+# Which is different from asking:
+#
+#     defined('foo')
+#
+# Since the later returns true if 'foo' is either a class, a built-in resource type, or a user defined
+# resource type, and a specific request like `Type[Class['foo']]` only returns true if `'foo'` is a class.
+#
+# @since 2.7.0
+# @since 3.6.0 variable reference and future parser types")
+# @since 3.8.1 type specific requests with future parser
+#
+Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunction) do
+
+  dispatch :is_defined do
+    scope_param
+    required_repeated_param 'Variant[String, Type[CatalogEntry], Type[Type[CatalogEntry]]]', :vals
+  end
+
+  def is_defined(scope, *vals)
+    vals.any? do |val|
+      case val
+      when String
+        if val =~ /^\$(.+)$/
+          scope.exist?($1)
+        else
+          case val
+          when ''
+            next nil
+          when 'main'
+            # Find the main class (known as ''), it does not have to be in the catalog
+            scope.find_hostclass('')
+          else
+            # Find a resource type, definition or class definition
+            scope.find_resource_type(val) || scope.find_definition(val) || scope.find_hostclass(val)
+            #scope.compiler.findresource(:class, val)
+          end
+        end
+      when Puppet::Resource
+        # Find instance of given resource type and title that is in the catalog
+        scope.compiler.findresource(val.type, val.title)
+
+      when Puppet::Pops::Types::PResourceType
+        raise ArgumentError, 'The given resource type is a reference to all kind of types' if val.type_name.nil?
+        if val.title.nil?
+          scope.find_builtin_resource_type(val.type_name) || scope.find_definition(val.type_name)
+        else
+          scope.compiler.findresource(val.type_name, val.title)
+        end
+
+      when Puppet::Pops::Types::PHostClassType
+        raise  ArgumentError, 'The given class type is a reference to all classes' if val.class_name.nil?
+        scope.compiler.findresource(:class, val.class_name)
+
+      when Puppet::Pops::Types::PType
+        case val.type
+        when Puppet::Pops::Types::PResourceType
+          # It is most reasonable to take Type[File] and Type[File[foo]] to mean the same as if not wrapped in a Type
+          # Since the difference between File and File[foo] already captures the distinction of type vs instance.
+          is_defined(scope, val.type)
+
+        when Puppet::Pops::Types::PHostClassType
+          # Interpreted as asking if a class (and nothing else) is defined without having to be included in the catalog
+          # (this is the same as asking for just the class' name, but with the added certainty that it cannot be a defined type.
+          #
+          raise  ArgumentError, 'The given class type is a reference to all classes' if val.type.class_name.nil?
+          scope.find_hostclass(val.type.class_name)
+        end
+      else
+        raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
+      end
+    end
+  end
+end

data/lib/puppet/functions/regsubst.rb

@@ -68,7 +68,7 @@ Puppet::Functions.create_function(:regsubst) do
   end
 
   def regsubst_regexp(target, pattern, replacement, flags = nil)
-    pattern = pattern.pattern if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
+    pattern = (pattern.pattern || '') if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
     inner_regsubst(target, pattern, replacement, operation = flags == 'G' ? :gsub : :sub)
   end
 

data/lib/puppet/functions/split.rb

@@ -42,6 +42,6 @@ Puppet::Functions.create_function(:split) do
   end
 
   def split_RegexpType(str, pattern)
-    str.split(pattern.pattern)
+    str.split(pattern.regexp)
   end
 end

data/lib/puppet/indirector/catalog/compiler.rb

@@ -78,7 +78,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   # Add any extra data necessary to the node.
   def add_node_data(node)
     # Merge in our server-side facts, so they can be used during compilation.
-    node.merge(@server_facts)
+    node.add_server_facts(@server_facts)
   end
 
   # Compile the actual catalog.

data/lib/puppet/indirector/facts/facter.rb

@@ -21,9 +21,20 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
   # Lookup a host's facts up in Facter.
   def find(request)
     Facter.reset
+
+    # Note: we need to setup puppet's external search paths before adding the puppetversion
+    # fact. This is because in Facter 2.x, the first `Facter.add` causes Facter to create
+    # its directory loaders which cannot be changed, meaning other external facts won't
+    # be resolved. (PUP-4607)
     self.class.setup_external_search_paths(request) if Puppet.features.external_facts?
     self.class.setup_search_paths(request)
 
+    # Add the puppetversion fact; this is done before generating the hash so it is
+    # accessible to custom facts.
+    Facter.add(:puppetversion) do
+      setcode { Puppet.version.to_s }
+    end
+
     result = Puppet::Node::Facts.new(request.key, Facter.to_hash)
     result.add_local_facts
     result.sanitize

data/lib/puppet/loaders.rb

@@ -11,6 +11,7 @@ module Puppet
       require 'puppet/pops/loader/null_loader'
       require 'puppet/pops/loader/static_loader'
       require 'puppet/pops/loader/ruby_function_instantiator'
+      require 'puppet/pops/loader/puppet_function_instantiator'
       require 'puppet/pops/loader/loader_paths'
       require 'puppet/pops/loader/simple_environment_loader'
     end

data/lib/puppet/node.rb

@@ -16,6 +16,8 @@ class Puppet::Node
   attr_accessor :name, :classes, :source, :ipaddress, :parameters, :trusted_data, :environment_name
   attr_reader :time, :facts
 
+  attr_reader :server_facts
+
   def self.from_data_hash(data)
     raise ArgumentError, "No name provided in serialized data" unless name = data['name']
 
@@ -86,6 +88,8 @@ class Puppet::Node
 
     @facts = options[:facts]
 
+    @server_facts = {}
+
     if env = options[:environment]
       self.environment = env
     end
@@ -108,12 +112,24 @@ class Puppet::Node
   # Merge any random parameters into our parameter list.
   def merge(params)
     params.each do |name, value|
-      @parameters[name] = value unless @parameters.include?(name)
+      if @parameters.include?(name)
+        Puppet::Util::Warnings.warnonce("The node parameter '#{name}' for node '#{@name}' was already set to '#{@parameters[name]}'. It could not be set to '#{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

data/lib/puppet/node/environment.rb

@@ -488,6 +488,10 @@ class Puppet::Node::Environment
         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
 

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -85,6 +85,10 @@ class Puppet::Parser::AST::PopsBridge
           instantiate_ResourceTypeDefinition(d, modname)
         when Puppet::Pops::Model::NodeDefinition
           instantiate_NodeDefinition(d, modname)
+        when Puppet::Pops::Model::FunctionDefinition
+          instantiate_FunctionDefinition(d, modname)
+          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
+          next
         else
           raise Puppet::ParseError, "Internal Error: Unknown type of definition - got '#{d.class}'"
         end

data/lib/puppet/parser/compiler.rb

@@ -32,6 +32,10 @@ class Puppet::Parser::Compiler
     end
 
     new(node).compile {|resulting_catalog| resulting_catalog.to_resource }
+  rescue Puppet::ParseErrorWithIssue => detail
+    detail.node = node.name
+    Puppet.log_exception(detail)
+    raise
   rescue => detail
     message = "#{detail} on node #{node.name}"
     Puppet.log_exception(detail, message)
@@ -556,6 +560,11 @@ class Puppet::Parser::Compiler
     catalog.client_version = node.parameters["clientversion"]
     catalog.server_version = node.parameters["serverversion"]
     @topscope.set_trusted(node.trusted_data)
+
+    if Puppet[:trusted_server_facts]
+      @topscope.set_server_facts(node.server_facts)
+    end
+
     facts_hash = node.facts.nil? ? {} : node.facts.values
     @topscope.set_facts(facts_hash)
   end

data/lib/puppet/parser/functions/defined.rb

@@ -39,9 +39,33 @@ Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2,
       defined(File[\'/some/file\'])
       defined(Class[\'foo\'])
 
+  The `defined` function does not answer if 4.x data types (e.g. `Integer`) are defined. If
+  given the string 'integer' the result is false, and if given a non CatalogEntry type,
+  an error is raised.
+
+  The rules for asking for undef, empty strings, and the main class are different from 3.x
+  (non future parser) and 4.x (with future parser or in Puppet 4.0.0 and later):
+
+      defined('')     # 3.x => true, 4.x => false
+      defined(undef)  # 3.x => true, 4.x => error
+      defined('main') # 3.x => false, 4.x => true
+
+  With the future parser, it is also possible to ask specifically if a name is
+  a resource type (built in or defined), or a class, by giving its type:
+
+      defined(Type[Class['foo']])
+      defined(Type[Resource['foo']])
+
+  Which is different from asking:
+
+      defined('foo')
+
+  Since the later returns true if 'foo' is either a class, a built-in resource type, or a user defined
+  resource type, and a specific request like `Type[Class['foo']]` only returns true if `'foo'` is a class.
+
  - Since 2.7.0
  - Since 3.6.0 variable reference and future parser types
- - Since 4.0.0") do |vals|
+ - Since 3.8.1 type specific requests with future parser") do |vals|
   vals = [vals] unless vals.is_a?(Array)
   vals.any? do |val|
     case val

data/lib/puppet/parser/functions/file.rb

@@ -1,3 +1,5 @@
+require 'puppet/file_system'
+
 Puppet::Parser::Functions::newfunction(
   :file, :arity => -2, :type => :rvalue,
   :doc => "Loads a file from a module and returns its contents as a string.
@@ -24,7 +26,7 @@ Puppet::Parser::Functions::newfunction(
     end
 
     if path
-      File.read(path)
+      Puppet::FileSystem.read_preserve_line_endings(path)
     else
       raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
     end