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

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

@@ -14,7 +14,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
   commands :aptcache => "/usr/bin/apt-cache"
   commands :preseed => "/usr/bin/debconf-set-selections"
 
-  defaultfor :operatingsystem => [:debian, :ubuntu]
+  defaultfor :osfamily => :debian
 
   ENV['DEBIAN_FRONTEND'] = "noninteractive"
 

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

@@ -7,9 +7,13 @@ require 'xmlrpc/client'
 Puppet::Type.type(:package).provide :pip,
   :parent => ::Puppet::Provider::Package do
 
-  desc "Python packages via `pip`."
+  desc "Python packages via `pip`.
 
-  has_feature :installable, :uninstallable, :upgradeable, :versionable
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip.
+  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 :installable, :uninstallable, :upgradeable, :versionable, :install_options
 
   # Parse lines of output from `pip freeze`, which are structured as
   # _package_==_version_.
@@ -71,6 +75,7 @@ Puppet::Type.type(:package).provide :pip,
   # gives the fully-qualified URL to the repository.
   def install
     args = %w{install -q}
+    args +=  install_options if @resource[:install_options]
     if @resource[:source]
       if String === @resource[:ensure]
         args << "#{@resource[:source]}@#{@resource[:ensure]}#egg=#{
@@ -115,4 +120,8 @@ Puppet::Type.type(:package).provide :pip,
       raise e, 'Could not locate the pip command.', e.backtrace
     end
   end
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
 end

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

@@ -0,0 +1,134 @@
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package do
+  desc "A PkgNG provider for FreeBSD and DragonFly."
+
+  commands :pkg => "/usr/local/sbin/pkg"
+
+  confine :operatingsystem => [:freebsd, :dragonfly]
+
+  defaultfor :operatingsystem => :freebsd
+
+  has_feature :versionable
+  has_feature :upgradeable
+
+  def self.get_query
+    pkg(['query', '-a', '%n %v %o'])
+  end
+
+  def self.get_version_list
+    pkg(['version', '-voRL='])
+  end
+
+  def self.get_latest_version(origin)
+    if latest_version = self.get_version_list.lines.find { |l| l =~ /^#{origin} / }
+      latest_version = latest_version.split(' ').last.split(')').first
+      return latest_version
+    end
+    nil
+  end
+
+  def self.instances
+    packages = []
+    begin
+      info = self.get_query
+
+      unless info
+        return packages
+      end
+
+      info.lines.each do |line|
+
+        name, version, origin = line.chomp.split(" ", 3)
+        latest_version  = get_latest_version(origin) || version
+
+        pkg = {
+          :ensure   => version,
+          :name     => name,
+          :provider => self.name,
+          :origin   => origin,
+          :version  => version,
+          :latest   => latest_version
+        }
+        packages << new(pkg)
+      end
+
+      return packages
+    rescue Puppet::ExecutionFailure
+      nil
+    end
+  end
+
+  def self.prefetch(resources)
+    packages = instances
+    resources.keys.each do |name|
+      if provider = packages.find{|p| p.name == name or p.origin == name }
+        resources[name].provider = provider
+      end
+    end
+  end
+
+  def repo_tag_from_urn(urn)
+    # extract repo tag from URN: urn:freebsd:repo:<tag>
+    match = /^urn:freebsd:repo:(.+)$/.match(urn)
+    raise ArgumentError urn.inspect unless match
+    match[1]
+  end
+
+  def install
+    source = resource[:source]
+    source = URI(source) unless source.nil?
+
+    # Ensure we handle the version
+    case resource[:ensure]
+    when true, false, Symbol
+      installname = resource[:name]
+    else
+      installname = resource[:name] + '-' + resource[:ensure]
+    end
+
+    if not source # install using default repo logic
+      args = ['install', '-qy', installname]
+    elsif source.scheme == 'urn' # install from repo named in URN
+      tag = repo_tag_from_urn(source.to_s)
+      args = ['install', '-qy', '-r', tag, installname]
+    else # add package located at URL
+      args = ['add', '-q', source.to_s]
+    end
+
+    pkg(args)
+  end
+
+  def uninstall
+    pkg(['remove', '-qy', resource[:name]])
+  end
+
+  def query
+    if @property_hash[:ensure] == nil
+      return nil
+    else
+      version = @property_hash[:version]
+      return { :version => version }
+    end
+  end
+
+  def version
+    @property_hash[:version]
+  end
+
+  # Upgrade to the latest version
+  def update
+    install
+  end
+
+  # Return the latest version of the package
+  def latest
+    debug "returning the latest #{@property_hash[:name].inspect} version #{@property_hash[:latest].inspect}"
+    @property_hash[:latest]
+  end
+
+  def origin
+    @property_hash[:origin]
+  end
+
+end

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

@@ -132,7 +132,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
 
   private
   def self.eix_search_format
-    "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] <homepage> <description>'"
+    "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] <homepage> <description>\n'"
   end
 
   def self.eix_result_format

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

@@ -6,9 +6,6 @@ Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :fre
     :portuninstall => "/usr/local/sbin/pkg_deinstall",
     :portinfo => "/usr/sbin/pkg_info"
 
-  defaultfor :operatingsystem => :freebsd
-
-  # I hate ports
   %w{INTERACTIVE UNAME}.each do |var|
     ENV.delete(var) if ENV.include?(var)
   end

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

@@ -20,7 +20,6 @@ class Puppet::Provider::Package::Windows
       # See http://community.spiceworks.com/how_to/show/2238
       !!(values['DisplayName'] and values['DisplayName'].length > 0 and
          values['UninstallString'] and values['UninstallString'].length > 0 and
-         values['SystemComponent'] != 1 and # DWORD
          values['WindowsInstaller'] != 1 and # DWORD
          name !~ /^KB[0-9]{6}/ and
          values['ParentKeyName'] == nil and

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

@@ -32,7 +32,6 @@ class Puppet::Provider::Package::Windows
     def self.valid?(name, values)
       # See http://community.spiceworks.com/how_to/show/2238
       !!(values['DisplayName'] and values['DisplayName'].length > 0 and
-         values['SystemComponent'] != 1 and # DWORD
          values['WindowsInstaller'] == 1 and # DWORD
          name =~ /\A\{[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}\Z/i)
     end

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

@@ -12,6 +12,37 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
   defaultfor :operatingsystem => [:suse, :sles, :sled, :opensuse]
   confine    :operatingsystem => [:suse, :sles, :sled, :opensuse]
 
+  # @api private
+  # Reset the latest version hash to nil
+  # needed for spec tests to clear cached value
+  def self.reset!
+    @latest_versions = nil
+  end
+
+  def self.latest_package_version(package)
+    if @latest_versions.nil?
+      @latest_versions = list_updates
+    end
+
+    @latest_versions[package]
+  end
+
+  def self.list_updates
+    output = zypper 'list-updates'
+
+    avail_updates = {}
+
+    # split up columns
+    output.lines.each do |line|
+      pkg_ver = line.split(/\s*\|\s*/)
+      # ignore zypper headers
+      next unless pkg_ver[0] == 'v'
+      avail_updates[pkg_ver[2]] = pkg_ver[4]
+    end
+
+    avail_updates
+  end
+
   #on zypper versions <1.0, the version option returns 1
   #some versions of zypper output on stderr
   def zypper_version
@@ -35,10 +66,9 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
     end
 
     #This has been tested with following zypper versions
-    #SLE 10.2: 0.6.104
-    #SLE 11.0: 1.0.8
-    #OpenSuse 10.2: 0.6.13
-    #OpenSuse 11.2: 1.2.8
+    #SLE 10.4: 0.6.201
+    #SLE 11.3: 1.6.307
+    #SLE 12.0: 1.11.14
     #Assume that this will work on newer zypper versions
 
     #extract version numbers and convert to integers
@@ -52,13 +82,24 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
       quiet = '--quiet'
     end
 
-    options = [quiet, :install]
+    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
 
     #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 << '--name' unless @resource.allow_virtual? || should
-    options += install_options if resource[:install_options]
+    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 << wanted
 
     zypper *options
@@ -72,16 +113,10 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
 
   # What's the latest package version available?
   def latest
-    #zypper can only get a list of *all* available packages?
-    output = zypper "list-updates"
-
-    if output =~ /#{Regexp.escape @resource[:name]}\s*\|.*?\|\s*([^\s\|]+)/
-      return $1
-    else
+    return self.class.latest_package_version(@resource[:name]) ||
       # zypper didn't find updates, pretend the current
       # version is the latest
-      return @property_hash[:ensure]
-    end
+      @property_hash[:ensure]
   end
 
   def update

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

@@ -10,6 +10,8 @@ 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')
@@ -76,7 +78,6 @@ 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
@@ -101,6 +102,8 @@ 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
@@ -209,7 +212,6 @@ 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|
@@ -258,10 +260,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,
@@ -280,7 +282,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']
+    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']
     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']
 
@@ -333,6 +335,29 @@ 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/debian.rb

@@ -16,7 +16,7 @@ Puppet::Type.type(:service).provide :debian, :parent => :init do
   # is resolved.
   commands :invoke_rc => "/usr/sbin/invoke-rc.d"
 
-  defaultfor :operatingsystem => :debian
+  defaultfor :operatingsystem => [:debian, :cumuluslinux]
 
   # Remove the symlinks
   def disable

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

@@ -152,6 +152,13 @@ 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.

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

@@ -11,6 +11,7 @@ Puppet::Type.type(:user).provide :openbsd, :parent => :useradd do
            :password => "passwd"
 
   defaultfor :operatingsystem => :openbsd
+  confine    :operatingsystem => :openbsd
 
   options :home, :flag => "-d", :method => :dir
   options :comment, :method => :gecos

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

@@ -8,18 +8,59 @@ Puppet::Type.type(:user).provide :windows_adsi do
 
   has_features :manages_homedir, :manages_passwords
 
+  def initialize(value={})
+    super(value)
+    @deleted = false
+  end
+
   def user
     @user ||= Puppet::Util::Windows::ADSI::User.new(@resource[:name])
   end
 
   def groups
-    user.groups.join(',')
+    @groups ||= Puppet::Util::Windows::ADSI::Group.name_sid_hash(user.groups)
+    @groups.keys
   end
 
   def groups=(groups)
     user.set_groups(groups, @resource[:membership] == :minimum)
   end
 
+  def groups_insync?(current, should)
+    return false unless current
+
+    # By comparing account SIDs we don't have to worry about case
+    # sensitivity, or canonicalization of account names.
+
+    # Cannot use munge of the group property to canonicalize @should
+    # since the default array_matching comparison is not commutative
+
+    # dupes automatically weeded out when hashes built
+    current_users = Puppet::Util::Windows::ADSI::Group.name_sid_hash(current)
+    specified_users = Puppet::Util::Windows::ADSI::Group.name_sid_hash(should)
+
+    if @resource[:membership] == :inclusive
+      current_users == specified_users
+    else
+      (specified_users.keys.to_a & current_users.keys.to_a) == specified_users.keys.to_a
+    end
+  end
+
+  def groups_to_s(groups)
+    return '' if groups.nil? || !groups.kind_of?(Array)
+    groups = groups.map do |group_name|
+      sid = Puppet::Util::Windows::SID.name_to_sid_object(group_name)
+      if sid.account =~ /\\/
+        account, _ = Puppet::Util::Windows::ADSI::Group.parse_name(sid.account)
+      else
+        account = sid.account
+      end
+      resource.debug("#{sid.domain}\\#{account} (#{sid.to_s})")
+      "#{sid.domain}\\#{account}"
+    end
+    return groups.join(',')
+  end
+
   def create
     @user = Puppet::Util::Windows::ADSI::User.create(@resource[:name])
     @user.password = @resource[:password]
@@ -47,11 +88,13 @@ Puppet::Type.type(:user).provide :windows_adsi do
     if sid
       Puppet::Util::Windows::ADSI::UserProfile.delete(sid)
     end
+
+    @deleted = true
   end
 
   # Only flush if we created or modified a user, not deleted
   def flush
-    @user.commit if @user
+    @user.commit if @user && !@deleted
   end
 
   def comment