puppet 4.1.0 → 4.2.0

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

@@ -23,6 +23,11 @@ class Puppet::Parser::AST::PopsBridge
       Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
     end
 
+    def source_text
+      source_adapter = Puppet::Pops::Utils.find_closest_positioned(@value)
+      source_adapter ? source_adapter.extract_text() : nil
+    end
+
     def evaluate(scope)
       object = @@evaluator.evaluate(scope, @value)
       @@evaluator.convert_to_3x(object, scope)

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

@@ -4,7 +4,7 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalu
   "Usage: `fqdn_rand(MAX, [SEED])`. MAX is required and must be a positive
   integer; SEED is optional and may be any number or string.
 
-  Generates a random whole number greater than or equal to 0 and less than MAX,
+  Generates a random Integer number greater than or equal to 0 and less than MAX,
   combining the `$fqdn` fact and the value of SEED for repeatable randomness.
   (That is, each node will get a different random number from this function, but
   a given node's result will be the same every time unless its hostname changes.)
@@ -17,5 +17,5 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalu
   `fqdn_rand(30, 'expensive job 2')` will produce totally different numbers.)") do |args|
     max = args.shift.to_i
     seed = Digest::MD5.hexdigest([self['::fqdn'],args].join(':')).hex
-    Puppet::Util.deterministic_rand(seed,max)
+    Puppet::Util.deterministic_rand_int(seed,max)
 end

data/lib/puppet/parser/scope.rb

@@ -484,24 +484,36 @@ class Puppet::Parser::Scope
   def lookup_qualified_variable(class_name, variable_name, position)
     begin
       if lookup_as_local_name?(class_name, variable_name)
-        self[variable_name]
+        if is_topscope?
+          # This is the case where $::x is looked up from within the topscope itself, or from a local scope
+          # parented at the top scope. In this case, the lookup must ignore local and ephemeral scopes.
+          #
+          handle_not_found(class_name, variable_name, position) unless @symtable.include?(variable_name)
+          @symtable[variable_name]
+        else
+          self[variable_name]
+        end
       else
         qualified_scope(class_name).lookupvar(variable_name, position)
       end
     rescue RuntimeError => e
-      unless Puppet[:strict_variables]
-        # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found
-        location = if position[:lineproc]
-                     " at #{position[:lineproc].call}"
-                   elsif position[:file] && position[:line]
-                     " at #{position[:file]}:#{position[:line]}"
-                   else
-                     ""
-                   end
-        warning "Could not look up qualified variable '#{class_name}::#{variable_name}'; #{e.message}#{location}"
-      end
-      variable_not_found("#{class_name}::#{variable_name}", e.message)
+      handle_not_found(class_name, variable_name, position, e.message)
+    end
+  end
+
+  def handle_not_found(class_name, variable_name, position, reason = nil)
+    unless Puppet[:strict_variables]
+      # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found
+      location = if position[:lineproc]
+                   " at #{position[:lineproc].call}"
+                 elsif position[:file] && position[:line]
+                   " at #{position[:file]}:#{position[:line]}"
+                 else
+                   ""
+                 end
+      warning "Could not look up qualified variable '#{class_name}::#{variable_name}'; #{reason}#{location}"
     end
+    variable_not_found("#{class_name}::#{variable_name}", reason)
   end
 
   # Handles the special case of looking up fully qualified variable in not yet evaluated top scope
@@ -724,6 +736,8 @@ class Puppet::Parser::Scope
     "Scope(#{@resource})"
   end
 
+  alias_method :inspect, :to_s
+
   # remove ephemeral scope up to level
   # TODO: Who uses :all ? Remove ??
   #
@@ -860,6 +874,18 @@ class Puppet::Parser::Scope
     end
   end
 
+  # Calls a 3.x or 4.x function by name with arguments given in an array using the 4.x calling convention
+  # and returns the result.
+  # Note that it is the caller's responsibility to rescue the given ArgumentError and provide location information
+  # to aid the user find the problem. The problem is otherwise reported against the source location that
+  # invoked the function that ultimately called this method.
+  #
+  # @return [Object] the result of the called function
+  # @raise ArgumentError if the function does not exist
+  def call_function(func_name, args, &block)
+    Puppet::Pops::Parser::EvaluatingParser.new.evaluator.external_call_function(func_name, args, self, &block)
+  end
+
   private
 
   def assert_class_and_title(type_name, title)

data/lib/puppet/pops.rb

@@ -131,5 +131,6 @@ module Puppet
   require 'puppet/parser/ast/pops_bridge'
   require 'puppet/bindings'
   require 'puppet/functions'
+  require 'puppet/loaders'
 end
 require 'puppet/plugins/data_providers'

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

@@ -140,7 +140,7 @@ class Runtime3Converter
       when Puppet::Pops::Types::PResourceType
         type_name = split_type.type_name
         title = split_type.title
-        if type_name =~ /^(::)?[Cc]lass/
+        if type_name =~ /^(::)?[Cc]lass$/
           ['class', title.nil? ? nil : title.sub(/^::/, '')]
         else
           # Ensure that title is '' if nil

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

@@ -231,6 +231,37 @@ module Puppet::Pops::Evaluator::Runtime3Support
     n
   end
 
+  # Provides the ability to call a 3.x or 4.x function from the perspective of a 3.x function or ERB template.
+  # The arguments to the function must be an Array containing values compliant with the 4.x calling convention.
+  # If the targeted function is a 3.x function, the values will be transformed.
+  # @param name [String] the name of the function (without the 'function_' prefix used by scope)
+  # @param args [Array] arguments, may be empty
+  # @param scope [Object] the (runtime specific) scope where evaluation takes place
+  # @raise ArgumentError 'unknown function' if the function does not exist
+  #
+  def external_call_function(name, args, scope, &block)
+    # Call via 4x API if the function exists there
+    loaders = scope.compiler.loaders
+    # Since this is a call from non puppet code, it is not possible to relate it to a module loader
+    # It is known where the call originates by using the scope associated module - but this is the calling scope
+    # and it does not defined the visibility of functions from a ruby function's perspective. Instead,
+    # this is done from the perspective of the environment.
+    loader = loaders.private_environment_loader
+    if loader && func = loader.load(:function, name)
+      return func.call(scope, *args, &block)
+    end
+
+    # Call via 3x API if function exists there
+    raise ArgumentError, "Unknown function '#{name}'" unless Puppet::Parser::Functions.function(name)
+
+    # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
+    # NOTE: Passing an empty string last converts nil/:undef to empty string
+    mapped_args = Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, scope, '')
+    result = scope.send("function_#{name}", mapped_args, &block)
+    # Prevent non r-value functions from leaking their result (they are not written to care about this)
+    Puppet::Parser::Functions.rvalue?(name) ? result : nil
+  end
+
   def call_function(name, args, o, scope, &block)
     # Call via 4x API if the function exists there
     loaders = scope.compiler.loaders

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

@@ -183,7 +183,7 @@ module Puppet::Pops::Parser::EppSupport
       until scanner.eos?
         part = @scanner.scan_until(/(<%)|\z/)
         if @skip_leading
-          part.gsub!(/^[ \t]*\r?\n?/,'')
+          part.sub!(/^[ \t]*\r?(?:\n|\z)?/,'')
           @skip_leading = false
         end
         # The spec for %%> is to transform it into a literal %>. This is done here, as %%> otherwise would go
@@ -208,7 +208,7 @@ module Puppet::Pops::Parser::EppSupport
           # trim trailing whitespace on same line from accumulated s
           # return text and signal switch to pp mode
           @scanner.getch # drop the -
-          s.gsub!(/\r?\n?[ \t]*<%\z/, '')
+          s.sub!(/[ \t]*<%\z/, '')
           @mode = :epp
           return s
 
@@ -240,6 +240,8 @@ module Puppet::Pops::Parser::EppSupport
             @mode = :error
             return s
           end
+          # Always trim leading whitespace on the same line when there is a comment
+          s.sub!(/[ \t]*\z/, '')
           @skip_leading = true if part.end_with?("-%>")
           # Continue scanning for more text
 

data/lib/puppet/property/ensure.rb

@@ -49,7 +49,7 @@ class Puppet::Property::Ensure < Puppet::Property
 
   def change_to_s(currentvalue, newvalue)
     begin
-      if currentvalue == :absent or currentvalue.nil?
+      if currentvalue == :absent || currentvalue.nil?
         return "created"
       elsif newvalue == :absent
         return "removed"

data/lib/puppet/provider.rb

@@ -551,6 +551,11 @@ class Puppet::Provider
     "#{@resource}(provider=#{self.class.name})"
   end
 
+  # @return [String] Returns a human readable string with information about the resource and the provider.
+  def inspect
+    to_s
+  end
+
   # Makes providers comparable.
   include Comparable
   # Compares this provider against another provider.

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

@@ -41,6 +41,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     "clearm" => [ :path, :string ],
     "touch" => [ :path ],
     "mv" => [ :path, :path ],
+    "rename" => [ :path, :string ],
     "insert" => [ :string, :string, :path ],
     "get" => [ :path, :comparator, :string ],
     "defvar" => [ :string, :path ],
@@ -502,6 +503,10 @@ Puppet::Type.type(:augeas).provide(:augeas) do
             debug("sending command '#{command}' with params #{cmd_array.inspect}")
             rv = aug.mv(cmd_array[0], cmd_array[1])
             fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
+          when "rename"
+            debug("sending command '#{command}' with params #{cmd_array.inspect}")
+            rv = aug.rename(cmd_array[0], cmd_array[1])
+            fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
           else fail("Command '#{command}' is not supported")
         end
       rescue StandardError => e

data/lib/puppet/provider/group/pw.rb

@@ -7,6 +7,7 @@ Puppet::Type.type(:group).provide :pw, :parent => Puppet::Provider::NameService:
   has_features :manages_members
 
   defaultfor :operatingsystem => [:freebsd, :dragonfly]
+  confine    :operatingsystem => [:freebsd, :dragonfly]
 
   options :members, :flag => "-M", :method => :mem
 

data/lib/puppet/provider/group/windows_adsi.rb

@@ -38,6 +38,11 @@ Puppet::Type.type(:group).provide :windows_adsi do
     return '' if users.nil? or !users.kind_of?(Array)
     users = users.map do |user_name|
       sid = Puppet::Util::Windows::SID.name_to_sid_object(user_name)
+      if !sid
+        resource.debug("#{user_name} (unresolvable to SID)")
+        next user_name
+      end
+
       if sid.account =~ /\\/
         account, _ = Puppet::Util::Windows::ADSI::User.parse_name(sid.account)
       else
@@ -49,6 +54,10 @@ Puppet::Type.type(:group).provide :windows_adsi do
     return users.join(',')
   end
 
+  def member_valid?(user_name)
+    ! Puppet::Util::Windows::SID.name_to_sid_object(user_name).nil?
+  end
+
   def group
     @group ||= Puppet::Util::Windows::ADSI::Group.new(@resource[:name])
   end

data/lib/puppet/provider/mount/parsed.rb

@@ -178,7 +178,21 @@ Puppet::Type.type(:mount).provide(
       end
     end
   else
-    record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields
+    record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields, :block_eval => :instance do
+      def pre_gen(record)
+        if !record[:options] || record[:options].empty?
+          if Facter.value(:kernel) == 'Linux'
+            record[:options] = 'defaults'
+          else
+            raise Puppet::Error, "Mount[#{record[:name]}]: Field 'options' is required"
+          end
+        end
+        if !record[:fstype] || record[:fstype].empty?
+          raise Puppet::Error, "Mount[#{record[:name]}]: Field 'fstype' is required"
+        end
+        record
+      end
+    end
   end
 
   # Every entry in fstab is :unmounted until we can prove different

data/lib/puppet/provider/package.rb

@@ -16,8 +16,12 @@ class Puppet::Provider::Package < Puppet::Provider
   # Look up the current status.
   def properties
     if @property_hash.empty?
-      @property_hash = query || {:ensure => :absent}
-      @property_hash[:ensure] = :absent if @property_hash.empty?
+      # For providers that support purging, default to purged; otherwise default to absent
+      # Purged is the "most uninstalled" a package can be, so a purged package will be in-sync with
+      # either `ensure => absent` or `ensure => purged`; an absent package will be out of sync with `ensure => purged`.
+      default_status = self.class.feature?(:purgeable) ? :purged : :absent
+      @property_hash = query || { :ensure => ( default_status )}
+      @property_hash[:ensure] = default_status if @property_hash.empty?
     end
     @property_hash.dup
   end

data/lib/puppet/provider/package/gem.rb

@@ -74,6 +74,22 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
     end
   end
 
+  def insync?(is)
+    return false unless is && is != :absent
+
+    begin
+      dependency = Gem::Dependency.new('', resource[:ensure])
+    rescue ArgumentError
+      # Bad requirements will cause an error during gem command invocation, so just return not in sync
+      return false
+    end
+
+    is = [is] unless is.is_a? Array
+
+    # Check if any version matches the dependency
+    is.any? { |version| dependency.match?('', version) }
+  end
+
   def install(useversion = true)
     command = [command(:gemcmd), "install"]
     command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion

data/lib/puppet/provider/package/openbsd.rb

@@ -78,10 +78,11 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
     end
 
     output = Puppet::Util.withenv(e_vars) {pkginfo "-Q", query}
+    version = properties[:ensure]
 
     if output.nil? or output.size == 0 or output =~ /Error from /
       debug "Failed to query for #{resource[:name]}"
-      return properties[:ensure]
+      return version
     else
       # Remove all fuzzy matches first.
       output = output.split.select {|p| p =~ /^#{resource[:name]}-(\d[^-]*)[-]?(\w*)/ }.join
@@ -90,22 +91,21 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
 
     if output =~ /^#{resource[:name]}-(\d[^-]*)[-]?(\w*) \(installed\)$/
       debug "Package is already the latest available"
-      return properties[:ensure]
+      return version
     else
       match = /^(.*)-(\d[^-]*)[-]?(\w*)$/.match(output)
       debug "Latest available for #{resource[:name]}: #{match[2]}"
 
-      if properties[:ensure].to_sym == :absent
+      if version.to_sym == :absent || version.to_sym == :purged
         return match[2]
       end
 
-      vcmp = properties[:ensure].split('.').map{|s|s.to_i} <=> match[2].split('.').map{|s|s.to_i}
+      vcmp = version.split('.').map{|s|s.to_i} <=> match[2].split('.').map{|s|s.to_i}
       if vcmp > 0
-        debug "ensure: #{properties[:ensure]}"
         # The locally installed package may actually be newer than what a mirror
         # has. Log it at debug, but ignore it otherwise.
-        debug "Package #{resource[:name]} #{properties[:ensure]} newer then available #{match[2]}"
-        return properties[:ensure]
+        debug "Package #{resource[:name]} #{version} newer then available #{match[2]}"
+        return version
       else
         return match[2]
       end

data/lib/puppet/provider/package/pacman.rb

@@ -30,7 +30,8 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     begin
       !pacman("-Sg", name).empty?
     rescue Puppet::ExecutionFailure
-      fail("Error while determining if '#{@resource[:name]}' is a group")
+      # pacman returns an expected non-zero exit code when the name is not a group
+      false
     end
   end
 
@@ -74,10 +75,10 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
   def self.get_installed_packages
     begin
       packages = {}
-      execpipe([command(:pacman), "-Q"]) do |process|
+      execpipe([command(:pacman), "-Q"]) do |pipe|
         # pacman -Q output is 'packagename version-rel'
         regex = %r{^(\S+)\s(\S+)}
-        process.each_line do |line|
+        pipe.each_line do |line|
           if match = regex.match(line)
             packages[match.captures[0]] = match.captures[1]
           else
@@ -98,8 +99,8 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
       # Build a hash of group name => list of packages
       command = [command(:pacman), "-Sgg"]
       command << filter if filter
-      execpipe(command) do |process|
-        process.each_line do |line|
+      execpipe(command) do |pipe|
+        pipe.each_line do |line|
           name, package = line.split
           packages = (groups[name] ||= [])
           packages << package
@@ -115,11 +116,11 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
       groups.each do |name, packages|
         groups[name] = packages.sort.map {|package| "#{package} #{installed_packages[package]}"}.join ', '
       end
-
-      groups
     rescue Puppet::ExecutionFailure
-      fail("Error while getting installed groups")
+      # pacman returns an expected non-zero exit code when the filter name is not a group
+      raise unless filter
     end
+    groups
   end
 
   # Because Archlinux is a rolling release based distro, installing a package

data/lib/puppet/provider/package/pip.rb

@@ -117,7 +117,7 @@ Puppet::Type.type(:package).provide :pip,
       self.class.commands :pip => pathname
       pip *args
     else
-      raise e, 'Could not locate the pip command.', e.backtrace
+      raise e, "Could not locate the #{self.class.cmd} command.", e.backtrace
     end
   end
 

data/lib/puppet/provider/package/pip3.rb

@@ -0,0 +1,18 @@
+# Puppet package provider for Python's `pip3` package management frontend.
+# <http://pip.openplans.org/>
+
+require 'puppet/provider/package/pip'
+
+Puppet::Type.type(:package).provide :pip3,
+  :parent => :pip do
+
+  desc "Python packages via `pip3`.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip3.
+  These options should be specified as a string (e.g. '--flag'), a hash (e.g. {'--flag' => 'value'}),
+  or an array where each element is either a string or a hash."
+
+  def self.cmd
+    "pip3"
+  end
+end

data/lib/puppet/provider/package/pkgdmg.rb

@@ -68,8 +68,10 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
   end
 
   def self.installpkgdmg(source, name)
-    http_proxy_host = Puppet::Util::HttpProxy.http_proxy_host
-    http_proxy_port = Puppet::Util::HttpProxy.http_proxy_port
+    unless Puppet::Util::HttpProxy.no_proxy?(source)
+      http_proxy_host = Puppet::Util::HttpProxy.http_proxy_host
+      http_proxy_port = Puppet::Util::HttpProxy.http_proxy_port
+    end
 
     unless source =~ /\.dmg$/i || source =~ /\.pkg$/i
       raise Puppet::Error.new("Mac OS X PKG DMG's must specify a source string ending in .dmg or flat .pkg file")