puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

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

@@ -24,7 +24,6 @@ class Puppet::Pops::Validation::ValidatorFactory_4_0 < Puppet::Pops::Validation:
     p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
 
     p[Issues::NAME_WITH_HYPHEN]             = :error
-    p[Issues::DEPRECATED_NAME_AS_TYPE]      = :error
     p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
     p
   end

data/lib/puppet/pops/visitor.rb

@@ -86,107 +86,4 @@ class Puppet::Pops::Visitor
     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/provider/exec.rb

@@ -47,12 +47,21 @@ class Puppet::Provider::Exec < Puppet::Provider
           end
         end
 
+        if Puppet.features.microsoft_windows?
+          exec_user = resource[:user]
+        # Etc.getpwuid() returns nil on Windows
+        elsif resource.current_username == resource[:user]
+          exec_user = nil
+        else
+          exec_user = resource[:user]
+        end
+
         Timeout::timeout(resource[:timeout]) do
           # note that we are passing "false" for the "override_locale" parameter, which ensures that the user's
           # default/system locale will be respected.  Callers may override this behavior by setting locale-related
           # environment variables (LANG, LC_ALL, etc.) in their 'environment' configuration.
           output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
-                                  :uid => resource[:user], :gid => resource[:group],
+                                  :uid => exec_user, :gid => resource[:group],
                                   :override_locale => false,
                                   :custom_environment => environment)
         end

data/lib/puppet/provider/file/windows.rb

@@ -8,20 +8,19 @@ Puppet::Type.type(:file).provide :windows do
 
   if Puppet.features.microsoft_windows?
     require 'puppet/util/windows'
-    require 'puppet/util/adsi'
     include Puppet::Util::Windows::Security
   end
 
   # Determine if the account is valid, and if so, return the UID
   def name2id(value)
-    Puppet::Util::Windows::Security.name_to_sid(value)
+    Puppet::Util::Windows::SID.name_to_sid(value)
   end
 
   # If it's a valid SID, get the name. Otherwise, it's already a name,
   # so just return it.
   def id2name(id)
-    if Puppet::Util::Windows::Security.valid_sid?(id)
-      Puppet::Util::Windows::Security.sid_to_name(id)
+    if Puppet::Util::Windows::SID.valid_sid?(id)
+      Puppet::Util::Windows::SID.sid_to_name(id)
     else
       id
     end

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

@@ -1,4 +1,4 @@
-require 'puppet/util/adsi'
+require 'puppet/util/windows'
 
 Puppet::Type.type(:group).provide :windows_adsi do
   desc "Local group management for Windows. Group members can be both users and groups.
@@ -22,15 +22,15 @@ Puppet::Type.type(:group).provide :windows_adsi do
     return false if current.empty? != should_empty
 
     # dupes automatically weeded out when hashes built
-    Puppet::Util::ADSI::Group.name_sid_hash(current) == Puppet::Util::ADSI::Group.name_sid_hash(should)
+    Puppet::Util::Windows::ADSI::Group.name_sid_hash(current) == Puppet::Util::Windows::ADSI::Group.name_sid_hash(should)
   end
 
   def members_to_s(users)
     return '' if users.nil? or !users.kind_of?(Array)
     users = users.map do |user_name|
-      sid = Puppet::Util::Windows::Security.name_to_sid_object(user_name)
+      sid = Puppet::Util::Windows::SID.name_to_sid_object(user_name)
       if sid.account =~ /\\/
-        account, _ = Puppet::Util::ADSI::User.parse_name(sid.account)
+        account, _ = Puppet::Util::Windows::ADSI::User.parse_name(sid.account)
       else
         account = sid.account
       end
@@ -41,7 +41,7 @@ Puppet::Type.type(:group).provide :windows_adsi do
   end
 
   def group
-    @group ||= Puppet::Util::ADSI::Group.new(@resource[:name])
+    @group ||= Puppet::Util::Windows::ADSI::Group.new(@resource[:name])
   end
 
   def members
@@ -53,18 +53,18 @@ Puppet::Type.type(:group).provide :windows_adsi do
   end
 
   def create
-    @group = Puppet::Util::ADSI::Group.create(@resource[:name])
+    @group = Puppet::Util::Windows::ADSI::Group.create(@resource[:name])
     @group.commit
 
     self.members = @resource[:members]
   end
 
   def exists?
-    Puppet::Util::ADSI::Group.exists?(@resource[:name])
+    Puppet::Util::Windows::ADSI::Group.exists?(@resource[:name])
   end
 
   def delete
-    Puppet::Util::ADSI::Group.delete(@resource[:name])
+    Puppet::Util::Windows::ADSI::Group.delete(@resource[:name])
   end
 
   # Only flush if we created or modified a group, not deleted
@@ -73,7 +73,7 @@ Puppet::Type.type(:group).provide :windows_adsi do
   end
 
   def gid
-    Puppet::Util::Windows::Security.name_to_sid(@resource[:name])
+    Puppet::Util::Windows::SID.name_to_sid(@resource[:name])
   end
 
   def gid=(value)
@@ -81,6 +81,6 @@ Puppet::Type.type(:group).provide :windows_adsi do
   end
 
   def self.instances
-    Puppet::Util::ADSI::Group.map { |g| new(:ensure => :present, :name => g.name) }
+    Puppet::Util::Windows::ADSI::Group.map { |g| new(:ensure => :present, :name => g.name) }
   end
 end

data/lib/puppet/provider/nameservice/directoryservice.rb

@@ -90,9 +90,6 @@ class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameSe
   def self.get_macosx_version_major
     return @macosx_version_major if defined?(@macosx_version_major)
     begin
-      # Make sure we've loaded all of the facts
-      Facter.loadfacts
-
       product_version_major = Facter.value(:macosx_productversion_major)
 
       fail("#{product_version_major} is not supported by the directoryservice provider") if %w{10.0 10.1 10.2 10.3 10.4}.include?(product_version_major)
@@ -178,7 +175,9 @@ class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameSe
   end
 
   def self.fail_if_wrong_version
-    fail("Puppet does not support OS X versions < 10.5") unless self.get_macosx_version_major >= "10.5"
+    if (Puppet::Util::Package.versioncmp(self.get_macosx_version_major, '10.5') == -1)
+      fail("Puppet does not support OS X versions < 10.5")
+    end
   end
 
   def self.get_exec_preamble(ds_action, resource_name = nil)

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

@@ -2,7 +2,11 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
   # Provide sorting functionality
   include Puppet::Util::Package
 
-  desc "Package management via `apt-get`."
+  desc "Package management via `apt-get`.
+
+    This provider supports the `install_options` attribute, which allows command-line flags to be passed to apt-get.
+    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."
 
   has_feature :versionable, :install_options
 

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

@@ -6,7 +6,11 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
   desc "Ruby Gem support.  If a URL is passed via `source`, then that URL is used as the
     remote gem repository; if a source is present but is not a valid URL, it will be
     interpreted as the path to a local gem file.  If source is not present at all,
-    the gem will be installed from the default gem repositories."
+    the gem will be installed from the default gem repositories.
+
+    This provider supports the `install_options` attribute, which allows command-line flags to be passed to the gem command.
+    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."
 
   has_feature :versionable, :install_options
 
@@ -24,7 +28,7 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
       gem_list_command << "--source" << options[:source]
     end
     if name = options[:justme]
-      gem_list_command << name + "$"
+      gem_list_command << "^" + name + "$"
     end
 
     begin
@@ -128,4 +132,4 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
   def install_options
     join_options(resource[:install_options])
   end
-end
+end

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

@@ -2,9 +2,16 @@ require 'puppet/provider/package'
 
 # Packaging on OpenBSD.  Doesn't work anywhere else that I know of.
 Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Package do
-  desc "OpenBSD's form of `pkg_add` support."
+  desc "OpenBSD's form of `pkg_add` support.
 
-  commands :pkginfo => "pkg_info", :pkgadd => "pkg_add", :pkgdelete => "pkg_delete"
+    This provider supports the `install_options` and `uninstall_options`
+    attributes, which allow command-line flags to be passed to pkg_add and pkg_delete.
+    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."
+
+  commands :pkginfo   => "pkg_info",
+           :pkgadd    => "pkg_add",
+           :pkgdelete => "pkg_delete"
 
   defaultfor :operatingsystem => :openbsd
   confine :operatingsystem => :openbsd
@@ -12,6 +19,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
   has_feature :versionable
   has_feature :install_options
   has_feature :uninstall_options
+  has_feature :upgradeable
 
   def self.instances
     packages = []
@@ -54,6 +62,60 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
     [command(:pkginfo), "-a"]
   end
 
+  def latest
+    parse_pkgconf
+
+    if @resource[:source][-1,1] == ::File::SEPARATOR
+      e_vars = { 'PKG_PATH' => @resource[:source] }
+    else
+      e_vars = {}
+    end
+
+    if @resource[:flavor]
+      query = "#{@resource[:name]}--#{@resource[:flavor]}"
+    else
+      query = @resource[:name]
+    end
+
+    output = Puppet::Util.withenv(e_vars) {pkginfo "-Q", query}
+
+    if output.nil? or output.size == 0 or output =~ /Error from /
+      debug "Failed to query for #{resource[:name]}"
+      return properties[:ensure]
+    else
+      # Remove all fuzzy matches first.
+      output = output.split.select {|p| p =~ /^#{resource[:name]}-(\d[^-]*)[-]?(\w*)/ }.join
+      debug "pkg_info -Q for #{resource[:name]}: #{output}"
+    end
+
+    if output =~ /^#{resource[:name]}-(\d[^-]*)[-]?(\w*) \(installed\)$/
+      debug "Package is already the latest available"
+      return properties[:ensure]
+    else
+      match = /^(.*)-(\d[^-]*)[-]?(\w*)$/.match(output)
+      debug "Latest available for #{resource[:name]}: #{match[2]}"
+
+      if properties[:ensure].to_sym == :absent
+        return match[2]
+      end
+
+      vcmp = properties[:ensure].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]
+      else
+        return match[2]
+      end
+    end
+  end
+
+  def update
+    self.install(true)
+  end
+
   def parse_pkgconf
     unless @resource[:source]
       if Puppet::FileSystem.exist?("/etc/pkg.conf")
@@ -80,14 +142,25 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
     end
   end
 
-  def install
+  def install(latest = false)
     cmd = []
 
     parse_pkgconf
 
     if @resource[:source][-1,1] == ::File::SEPARATOR
       e_vars = { 'PKG_PATH' => @resource[:source] }
-      full_name = [ @resource[:name], get_version || @resource[:ensure], @resource[:flavor] ].join('-').chomp('-').chomp('-')
+      # In case of a real update (i.e., the package already exists) then
+      # pkg_add(8) can handle the flavors. However, if we're actually
+      # installing with 'latest', we do need to handle the flavors.
+      # So we always need to handle flavors ourselves as to not break installs.
+      if latest and resource[:flavor]
+        full_name = "#{resource[:name]}--#{resource[:flavor]}"
+      elsif latest
+        # Don't depend on get_version for updates.
+        full_name = @resource[:name]
+      else
+        full_name = [ @resource[:name], get_version || @resource[:ensure], @resource[:flavor] ].join('-').chomp('-').chomp('-')
+      end
     else
       e_vars = {}
       full_name = @resource[:source]
@@ -96,13 +169,17 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
     cmd << install_options
     cmd << full_name
 
-    Puppet::Util.withenv(e_vars) { pkgadd cmd.flatten.compact.join(' ') }
+    if latest
+      cmd.unshift('-rz')
+    end
+
+    Puppet::Util.withenv(e_vars) { pkgadd cmd.flatten.compact }
   end
 
   def get_version
     execpipe([command(:pkginfo), "-I", @resource[:name]]) do |process|
       # our regex for matching pkg_info output
-      regex = /^(.*)-(\d[^-]*)[-]?(\D*)(.*)$/
+      regex = /^(.*)-(\d[^-]*)[-]?(\w*)(.*)$/
       master_version = 0
       version = -1
 
@@ -142,7 +219,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
   end
 
   def uninstall
-    pkgdelete uninstall_options.flatten.compact.join(' '), @resource[:name]
+    pkgdelete uninstall_options.flatten.compact, @resource[:name]
   end
 
   def purge

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

@@ -3,7 +3,11 @@ require 'set'
 require 'uri'
 
 Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Package do
-  desc "Support for the Package Manager Utility (pacman) used in Archlinux."
+  desc "Support for the Package Manager Utility (pacman) used in Archlinux.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pacman.
+  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."
 
   commands :pacman => "/usr/bin/pacman"
   # Yaourt is a common AUR helper which, if installed, we can use to query the AUR
@@ -11,6 +15,8 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
   confine     :operatingsystem => :archlinux
   defaultfor  :operatingsystem => :archlinux
+  has_feature :install_options
+  has_feature :uninstall_options
   has_feature :upgradeable
 
   # If yaourt is installed, we can make use of it
@@ -35,9 +41,15 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
   def install_from_repo
     if yaourt?
-      yaourt "--noconfirm", "-S", @resource[:name]
+      cmd = %w{--noconfirm}
+      cmd += install_options if @resource[:install_options]
+      cmd << "-S" << @resource[:name]
+      yaourt *cmd
     else
-        pacman "--noconfirm", "--noprogressbar", "-Sy", @resource[:name]
+      cmd = %w{--noconfirm --noprogressbar}
+      cmd += install_options if @resource[:install_options]
+      cmd << "-Sy" << @resource[:name]
+      pacman *cmd
     end
   end
   private :install_from_repo
@@ -204,6 +216,19 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
   # Removes a package from the system.
   def uninstall
-    pacman "--noconfirm", "--noprogressbar", "-R", @resource[:name]
+    cmd = %w{--noconfirm --noprogressbar}
+    cmd += uninstall_options if @resource[:uninstall_options]
+    cmd << "-R" << @resource[:name]
+    pacman *cmd
+  end
+
+  private
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(@resource[:uninstall_options])
   end
 end