puppet 3.8.7 → 4.0.0

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

@@ -165,6 +165,115 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     join_options(resource[:uninstall_options])
   end
 
+  # This is an attempt at implementing RPM's
+  # lib/rpmvercmp.c rpmvercmp(a, b) in Ruby.
+  #
+  # Some of the things in here look REALLY
+  # UGLY and/or arbitrary. Our goal is to
+  # match how RPM compares versions, quirks
+  # and all.
+  #
+  # I've kept a lot of C-like string processing
+  # in an effort to keep this as identical to RPM
+  # as possible.
+  #
+  # returns 1 if str1 is newer than str2,
+  #         0 if they are identical
+  #        -1 if str1 is older than str2
+  def rpmvercmp(str1, str2)
+    return 0 if str1 == str2
+
+    front_strip_re = /^[^A-Za-z0-9~]+/
+    segment_re = /^[A-Za-z0-9]/
+    # these represent RPM rpmio/rpmstring.c functions
+    risalnum = /[A-Za-z0-9]/
+    risdigit = /^[0-9]+/
+    risalpha = /[A-Za-z]/
+
+    while str1.length > 0 or str2.length > 0
+      # trim anything that's !risalnum() and != '~' off the beginning of each string
+      str1 = str1.gsub(front_strip_re, '')
+      str2 = str2.gsub(front_strip_re, '')
+
+      # "handle the tilde separator, it sorts before everything else"
+      if /^~/.match(str1) && /^~/.match(str2)
+        # if they both have ~, strip it
+        str1 = str1[1..-1]
+        str2 = str2[1..-1]
+      elsif /^~/.match(str1)
+        return -1
+      elsif /^~/.match(str2)
+        return 1
+      end
+
+      break if str1.length == 0 or str2.length == 0
+
+      # "grab first completely alpha or completely numeric segment"
+      isnum = false
+      # if the first char of str1 is a digit, grab the chunk of continuous digits from each string
+      if risdigit.match(str1)
+        if str1 =~ /^[0-9]+/
+          segment1 = $~.to_s
+          str1 = $~.post_match
+        else
+          segment1 = ''
+        end
+        if str2 =~ /^[0-9]+/
+          segment2 = $~.to_s
+          str2 = $~.post_match
+        else
+          segment2 = ''
+        end
+        isnum = true
+      # else grab the chunk of continuous alphas from each string (which may be '')
+      else
+        if str1 =~ /^[A-Za-z]+/
+          segment1 = $~.to_s
+          str1 = $~.post_match
+        else
+          segment1 = ''
+        end
+        if str2 =~ /^[A-Za-z]+/
+          segment2 = $~.to_s
+          str2 = $~.post_match
+        else
+          segment2 = ''
+        end
+      end
+
+      # if the segments we just grabbed from the strings are different types (i.e. one numeric one alpha),
+      # where alpha also includes ''; "numeric segments are always newer than alpha segments"
+      if segment2.length == 0
+        return 1 if isnum
+        return -1
+      end
+
+      if isnum
+        # "throw away any leading zeros - it's a number, right?"
+        segment1 = segment1.gsub(/^0+/, '')
+        segment2 = segment2.gsub(/^0+/, '')
+        # "whichever number has more digits wins"
+        return 1 if segment1.length > segment2.length
+        return -1 if segment1.length < segment2.length
+      end
+
+      # "strcmp will return which one is greater - even if the two segments are alpha
+      # or if they are numeric. don't return if they are equal because there might
+      # be more segments to compare"
+      rc = segment1 <=> segment2
+      return rc if rc != 0
+    end #end while loop
+
+    # if we haven't returned anything yet, "whichever version still has characters left over wins"
+    if str1.length > str2.length
+      return 1
+    elsif str1.length < str2.length
+      return -1
+    else
+      return 0
+    end
+  end
+
   private
   # @param line [String] one line of rpm package query information
   # @return [Hash] of NEVRA_FIELDS strings parsed from package info

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

@@ -5,7 +5,6 @@ Puppet::Type.type(:package).provide :rug, :parent => :rpm do
 
   commands :rug => "/usr/bin/rug"
   commands :rpm => "rpm"
-  defaultfor :operatingsystem => [:suse, :sles]
   confine    :operatingsystem => [:suse, :sles]
 
   # Install a package using 'rug'.

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

@@ -35,7 +35,7 @@ class Puppet::Provider::Package::Windows
           mode |= KEY_READ
           begin
             open(hive, 'Software\Microsoft\Windows\CurrentVersion\Uninstall', mode) do |uninstall|
-              uninstall.each_key do |name, wtime|
+              each_key(uninstall) do |name, wtime|
                 open(hive, "#{uninstall.keyname}\\#{name}", mode) do |key|
                   yield key, values(key)
                 end

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

@@ -1,5 +1,3 @@
-require 'puppet/util/package'
-
 Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   desc "Support via `yum`.
 
@@ -13,9 +11,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
 
   has_feature :install_options, :versionable, :virtual_packages
 
-  commands :yum => "yum", :rpm => "rpm", :python => "python"
-
-  self::YUMHELPER = File::join(File::dirname(__FILE__), "yumhelper.py")
+  commands :yum => "yum", :rpm => "rpm"
 
   if command('rpm')
     confine :true => begin
@@ -45,14 +41,15 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   # @param package [String] The name of the package to query
   # @param enablerepo [Array<String>] A list of repositories to enable for this query
   # @param disablerepo [Array<String>] A list of repositories to disable for this query
+  # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
   # @return [Hash<Symbol, String>]
-  def self.latest_package_version(package, enablerepo, disablerepo)
+  def self.latest_package_version(package, enablerepo, disablerepo, disableexcludes)
 
-    key = [enablerepo, disablerepo]
+    key = [enablerepo, disablerepo, disableexcludes]
 
     @latest_versions ||= {}
     if @latest_versions[key].nil?
-      @latest_versions[key] = fetch_latest_versions(enablerepo, disablerepo)
+      @latest_versions[key] = check_updates(enablerepo, disablerepo, disableexcludes)
     end
 
     if @latest_versions[key][package]
@@ -66,27 +63,62 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   # @api private
   # @param enablerepo [Array<String>] A list of repositories to enable for this query
   # @param disablerepo [Array<String>] A list of repositories to disable for this query
+  # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
   # @return [Hash<String, Array<Hash<String, String>>>] All packages that were
   #   found with a list of found versions for each package.
-  def self.fetch_latest_versions(enablerepo, disablerepo)
-    latest_versions = Hash.new {|h, k| h[k] = []}
-
-    args = [self::YUMHELPER]
-    args.concat(enablerepo.map { |repo| ['-e', repo] }.flatten)
-    args.concat(disablerepo.map { |repo| ['-d', repo] }.flatten)
+  def self.check_updates(enablerepo, disablerepo, disableexcludes)
+    args = [command(:yum), 'check-update']
+    args.concat(enablerepo.map { |repo| ["--enablerepo=#{repo}"] }.flatten)
+    args.concat(disablerepo.map { |repo| ["--disablerepo=#{repo}"] }.flatten)
+    args.concat(disableexcludes.map { |repo| ["--disableexcludes=#{repo}"] }.flatten)
+
+    output = Puppet::Util::Execution.execute(args, :failonfail => false, :combine => false)
+
+    updates = {}
+    if output.exitstatus == 100
+      updates = parse_updates(output)
+    elsif output.exitstatus == 0
+      self.debug "yum check-update exited with 0; no package updates available."
+    else
+      self.warn "Could not check for updates, 'yum check-update' exited with #{output.exitstatus}"
+    end
+    updates
+  end
 
-    python(args).scan(/^_pkg (.*)$/) do |match|
-      hash = nevra_to_hash(match[0])
+  def self.parse_updates(str)
+    # Strip off all content before the first blank line
+    body = str.partition(/^\s*\n/m).last
 
+    updates = Hash.new { |h, k| h[k] = [] }
+    body.split.each_slice(3) do |tuple|
+      hash = update_to_hash(*tuple[0..1])
       # Create entries for both the package name without a version and a
       # version since yum considers those as mostly interchangeable.
       short_name = hash[:name]
       long_name  = "#{hash[:name]}.#{hash[:arch]}"
 
-      latest_versions[short_name] << hash
-      latest_versions[long_name]  << hash
+      updates[short_name] << hash
+      updates[long_name] << hash
     end
-    latest_versions
+
+    updates
+  end
+
+  def self.update_to_hash(pkgname, pkgversion)
+    name, arch = pkgname.split('.')
+
+    match = pkgversion.match(/^(?:(\d+):)?(\S+)-(\S+)$/)
+    epoch = match[1] || '0'
+    version = match[2]
+    release = match[3]
+
+    {
+      :name => name,
+      :epoch => epoch,
+      :version => version,
+      :release => release,
+      :arch    => arch,
+    }
   end
 
   def self.clear
@@ -112,7 +144,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
       # Add the package version
       wanted += "-#{should}"
       is = self.query
-      if is && Puppet::Util::Package.versioncmp(should, is[:ensure]) < 0
+      if is && yum_compareEVR(yum_parse_evr(should), yum_parse_evr(is[:ensure])) < 0
         self.debug "Downgrading package #{@resource[:name]} from version #{is[:ensure]} to #{should}"
         operation = :downgrade
       end
@@ -129,13 +161,14 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
 
       # FIXME: Should we raise an exception even if should == :latest
       # and yum updated us to a version other than @param_hash[:ensure] ?
-      raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if should != is[:ensure]
+      vercmp_result = yum_compareEVR(yum_parse_evr(should), yum_parse_evr(is[:ensure]))
+      raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if vercmp_result != 0
     end
   end
 
   # What's the latest package version available?
   def latest
-    upd = self.class.latest_package_version(@resource[:name], enablerepo, disablerepo)
+    upd = self.class.latest_package_version(@resource[:name], enablerepo, disablerepo, disableexcludes)
     unless upd.nil?
       # FIXME: there could be more than one update for a package
       # because of multiarch
@@ -157,16 +190,70 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
     yum "-y", :erase, @resource[:name]
   end
 
-  # @deprecated
-  def latest_info
-    Puppet.deprecation_warning("#{self.class}##{__method__} is deprecated and is no longer used.")
-    @latest_info
+  # parse a yum "version" specification
+  # this re-implements yum's
+  # rpmUtils.miscutils.stringToVersion() in ruby
+  def yum_parse_evr(s)
+    ei = s.index(':')
+    if ei
+      e = s[0,ei]
+      s = s[ei+1,s.length]
+    else
+      e = nil
+    end
+    e = String(Bignum(e)) rescue '0'
+    ri = s.index('-')
+    if ri
+      v = s[0,ri]
+      r = s[ri+1,s.length]
+    else
+      v = s
+      r = nil
+    end
+    return { :epoch => e, :version => v, :release => r }
   end
 
-  # @deprecated
-  def latest_info=(latest)
-    Puppet.deprecation_warning("#{self.class}##{__method__} is deprecated and is no longer used.")
-    @latest_info = latest
+  # how yum compares two package versions:
+  # rpmUtils.miscutils.compareEVR(), which massages data types and then calls
+  # rpm.labelCompare(), found in rpm.git/python/header-py.c, which
+  # sets epoch to 0 if null, then compares epoch, then ver, then rel
+  # using compare_values() and returns the first non-0 result, else 0.
+  # This function combines the logic of compareEVR() and labelCompare().
+  #
+  # "version_should" can be v, v-r, or e:v-r.
+  # "version_is" will always be at least v-r, can be e:v-r
+  def yum_compareEVR(should_hash, is_hash)
+    # pass on to rpm labelCompare
+    rc = compare_values(should_hash[:epoch], is_hash[:epoch])
+    return rc unless rc == 0
+    rc = compare_values(should_hash[:version], is_hash[:version])
+    return rc unless rc == 0
+
+    # here is our special case, PUP-1244.
+    # if should_hash[:release] is nil (not specified by the user),
+    # and comparisons up to here are equal, return equal. We need to
+    # evaluate to whatever level of detail the user specified, so we
+    # don't end up upgrading or *downgrading* when not intended.
+    #
+    # This should NOT be triggered if we're trying to ensure latest.
+    return 0 if should_hash[:release].nil?
+
+    rc = compare_values(should_hash[:release], is_hash[:release])
+    return rc
+  end
+
+  # this method is a native implementation of the
+  # compare_values function in rpm's python bindings,
+  # found in python/header-py.c, as used by yum.
+  def compare_values(s1, s2)
+    if s1.nil? && s2.nil?
+      return 0
+    elsif ( not s1.nil? ) && s2.nil?
+      return 1
+    elsif s1.nil? && (not s2.nil?)
+      return -1
+    end
+    return rpmvercmp(s1, s2)
   end
 
   private
@@ -179,6 +266,10 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
     scan_options(resource[:install_options], '--disablerepo')
   end
 
+  def disableexcludes
+    scan_options(resource[:install_options], '--disableexcludes')
+  end
+
   # Scan a structure that looks like the package type 'install_options'
   # structure for all hashes that have a specific key.
   #

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

@@ -9,6 +9,7 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
 
   commands :zypper => "/usr/bin/zypper"
 
+  defaultfor :operatingsystem => [:suse, :sles, :sled, :opensuse]
   confine    :operatingsystem => [:suse, :sles, :sled, :opensuse]
 
   #on zypper versions <1.0, the version option returns 1
@@ -34,9 +35,10 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
     end
 
     #This has been tested with following zypper versions
-    #SLE 10.4: 0.6.201
-    #SLE 11.3: 1.6.307
-    #SLE 12.0: 1.11.14
+    #SLE 10.2: 0.6.104
+    #SLE 11.0: 1.0.8
+    #OpenSuse 10.2: 0.6.13
+    #OpenSuse 11.2: 1.2.8
     #Assume that this will work on newer zypper versions
 
     #extract version numbers and convert to integers
@@ -50,24 +52,13 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
       quiet = '--quiet'
     end
 
-    inst_opts = []
-    inst_opts = install_options if resource[:install_options]
-
-
-    options = []
-    options << quiet
-    options << '--no-gpg-check' unless inst_opts.delete('--no-gpg-check').nil?
-    options << :install
+    options = [quiet, :install]
 
     #zypper 0.6.13 (OpenSuSE 10.2) does not support auto agree with licenses
     options << '--auto-agree-with-licenses' unless major < 1 and minor <= 6 and patch <= 13
     options << '--no-confirm'
-    options += inst_opts unless inst_opts.empty?
-
-    # Zypper 0.6.201 doesn't recognize '--name'
-    # It is unclear where this functionality was introduced, but it
-    # is present as early as 1.0.13
-    options << '--name' unless major < 1 || @resource.allow_virtual? || should
+    options << '--name' unless @resource.allow_virtual? || should
+    options += install_options if resource[:install_options]
     options << wanted
 
     zypper *options

data/lib/puppet/provider/scheduled_task/win32_taskscheduler.rb

@@ -10,8 +10,6 @@ Puppet::Type.type(:scheduled_task).provide(:win32_taskscheduler) do
   defaultfor :operatingsystem => :windows
   confine    :operatingsystem => :windows
 
-  MINUTES_IN_DAY = 1440
-
   def self.instances
     Win32::TaskScheduler.new.tasks.collect do |job_file|
       job_title = File.basename(job_file, '.job')
@@ -78,6 +76,7 @@ Puppet::Type.type(:scheduled_task).provide(:win32_taskscheduler) do
                   nil
                 end
       next unless trigger and scheduler_trigger_types.include?(trigger['trigger_type'])
+
       puppet_trigger = {}
       case trigger['trigger_type']
       when Win32::TaskScheduler::TASK_TIME_TRIGGER_DAILY
@@ -102,8 +101,6 @@ Puppet::Type.type(:scheduled_task).provide(:win32_taskscheduler) do
       puppet_trigger['start_date'] = self.class.normalized_date("#{trigger['start_year']}-#{trigger['start_month']}-#{trigger['start_day']}")
       puppet_trigger['start_time'] = self.class.normalized_time("#{trigger['start_hour']}:#{trigger['start_minute']}")
       puppet_trigger['enabled']    = trigger['flags'] & Win32::TaskScheduler::TASK_TRIGGER_FLAG_DISABLED == 0
-      puppet_trigger['minutes_interval'] = trigger['minutes_interval'] ||= 0
-      puppet_trigger['minutes_duration'] = trigger['minutes_duration'] ||= 0
       puppet_trigger['index']      = i
 
       @triggers << puppet_trigger
@@ -212,6 +209,7 @@ Puppet::Type.type(:scheduled_task).provide(:win32_taskscheduler) do
   def create
     clear_task
     @task = Win32::TaskScheduler.new(resource[:name], dummy_time_trigger)
+
     self.command = resource[:command]
 
     [:arguments, :working_dir, :enabled, :trigger, :user].each do |prop|
@@ -260,10 +258,10 @@ Puppet::Type.type(:scheduled_task).provide(:win32_taskscheduler) do
       'flags'                   => 0,
       'random_minutes_interval' => 0,
       'end_day'                 => 0,
-      'end_year'                => 0,
-      'minutes_interval'        => 0,
-      'end_month'               => 0,
-      'minutes_duration'        => 0,
+      "end_year"                => 0,
+      "minutes_interval"        => 0,
+      "end_month"               => 0,
+      "minutes_duration"        => 0,
       'start_year'              => now.year,
       'start_month'             => now.month,
       'start_day'               => now.day,
@@ -282,7 +280,7 @@ Puppet::Type.type(:scheduled_task).provide(:win32_taskscheduler) do
       trigger['flags'] &= ~Win32::TaskScheduler::TASK_TRIGGER_FLAG_DISABLED
     end
 
-    extra_keys = puppet_trigger.keys.sort - ['index', 'enabled', 'schedule', 'start_date', 'start_time', 'every', 'months', 'on', 'which_occurrence', 'day_of_week', 'minutes_interval', 'minutes_duration']
+    extra_keys = puppet_trigger.keys.sort - ['index', 'enabled', 'schedule', 'start_date', 'start_time', 'every', 'months', 'on', 'which_occurrence', 'day_of_week']
     self.fail "Unknown trigger option(s): #{Puppet::Parameter.format_value_for_display(extra_keys)}" unless extra_keys.empty?
     self.fail "Must specify 'start_time' when defining a trigger" unless puppet_trigger['start_time']
 
@@ -335,29 +333,6 @@ Puppet::Type.type(:scheduled_task).provide(:win32_taskscheduler) do
       self.fail "Unknown schedule type: #{puppet_trigger["schedule"].inspect}"
     end
 
-    integer_interval = -1
-    if puppet_trigger['minutes_interval']
-      integer_interval = Integer(puppet_trigger['minutes_interval'])
-      self.fail 'minutes_interval must be an integer greater or equal to 0' if integer_interval < 0
-      trigger['minutes_interval'] = integer_interval
-    end
-
-    integer_duration = -1
-    if puppet_trigger['minutes_duration']
-      integer_duration = Integer(puppet_trigger['minutes_duration'])
-      self.fail 'minutes_duration must be an integer greater than minutes_interval and equal to or greater than 0' if integer_duration <= integer_interval && integer_duration != 0
-      trigger['minutes_duration'] = integer_duration
-    end
-
-    if integer_interval > 0 && integer_duration == -1
-      integer_duration = MINUTES_IN_DAY
-      trigger['minutes_duration'] = MINUTES_IN_DAY
-    end
-
-    if integer_interval >= integer_duration && integer_interval > 0
-      self.fail 'minutes_interval cannot be set without minutes_duration also being set to a number greater than 0'
-    end
-
     if start_date = puppet_trigger['start_date']
       start_date = Date.parse(start_date)
       self.fail "start_date must be on or after 1753-01-01" unless start_date >= Date.new(1753, 1, 1)

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

@@ -11,15 +11,28 @@ Puppet::Type.type(:service).provide :base, :parent => :service do
 
   commands :kill => "kill"
 
+  # get the proper 'ps' invocation for the platform
+  # ported from the facter 2.x implementation, since facter 3.x
+  # is dropping the fact (for which this was the only use)
+  def getps
+    case Facter.value(:operatingsystem)
+    when 'OpenWrt'
+      'ps www'
+    when 'FreeBSD', 'NetBSD', 'OpenBSD', 'Darwin', 'DragonFly'
+      'ps auxwww'
+    else
+      'ps -ef'
+     end
+  end
+  private :getps
+
   # Get the process ID for a running process. Requires the 'pattern'
   # parameter.
   def getpid
     @resource.fail "Either stop/status commands or a pattern must be specified" unless @resource[:pattern]
-    ps = Facter["ps"].value
-    @resource.fail "You must upgrade Facter to a version that includes 'ps'" unless ps and ps != ""
     regex = Regexp.new(@resource[:pattern])
     self.debug "Executing '#{ps}'"
-    IO.popen(ps) { |table|
+    IO.popen(getps) { |table|
       table.each_line { |line|
         if regex.match(line)
           self.debug "Process matched: #{line}"
@@ -31,6 +44,7 @@ Puppet::Type.type(:service).provide :base, :parent => :service do
 
     nil
   end
+  private :getpid
 
   # Check if the process is running.  Prefer the 'status' parameter,
   # then 'statuscmd' method, then look in the process table.  We give

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

@@ -7,7 +7,7 @@ Puppet::Type.type(:service).provide :bsd, :parent => :init do
 
   EOT
 
-  confine :operatingsystem => [:freebsd, :netbsd, :openbsd, :dragonfly]
+  confine :operatingsystem => [:freebsd, :netbsd, :dragonfly]
 
   def rcconf_dir
     '/etc/rc.conf.d'

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

@@ -45,7 +45,7 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
     attr_writer :defpath
 
     # Determine the daemon path.
-    def defpath(dummy_argument=:work_arround_for_ruby_GC_bug)
+    def defpath
       unless @defpath
         ["/var/lib/service", "/etc"].each do |path|
           if Puppet::FileSystem.exist?(path)

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

@@ -152,13 +152,6 @@ Puppet::Type.type(:service).provide :init, :parent => :base do
     (@resource[:hasrestart] == :true) && [initscript, :restart]
   end
 
-  def texecute(type, command, fof = true, squelch = false, combine = true)
-    if type == :start && Facter.value(:osfamily) == "Solaris"
-        command =  ["/usr/bin/ctrun -l none", command].flatten.join(" ")
-    end
-    super(type, command, fof, squelch, combine)
-  end
-
   # If it was specified that the init script has a 'status' command, then
   # we just return that; otherwise, we return false, which causes it to
   # fallback to other mechanisms.