puppet 4.0.0-x86-mingw32 → 4.1.0-x86-mingw32

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

@@ -4,6 +4,7 @@ require 'puppet/provider/mount'
 fstab = nil
 case Facter.value(:osfamily)
 when "Solaris"; fstab = "/etc/vfstab"
+when "AIX"; fstab = "/etc/filesystems"
 else
   fstab = "/etc/fstab"
 end
@@ -25,7 +26,12 @@ Puppet::Type.type(:mount).provide(
     @fields = [:device, :name, :fstype, :options, :dump, :pass]
   end
 
-  text_line :comment, :match => /^\s*#/
+  if Facter.value(:osfamily) == "AIX"
+    # * is the comment character on AIX /etc/filesystems
+    text_line :comment, :match => /^\s*\*/
+  else
+    text_line :comment, :match => /^\s*#/
+  end
   text_line :blank, :match => /^\s*$/
 
   optional_fields  = @fields - [:device, :name, :blockdevice]
@@ -36,7 +42,144 @@ Puppet::Type.type(:mount).provide(
   field_pattern = '(\s*(?>\S+))'
   text_line :incomplete, :match => /^(?!#{field_pattern}{#{mandatory_fields.length}})/
 
-  record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields
+  case Facter.value(:osfamily)
+  when "AIX"
+    # The only field that is actually ordered is :name. See `man filesystems` on AIX
+    @fields = [:name, :account, :boot, :check, :dev, :free, :mount, :nodename,
+               :options, :quota, :size, :type, :vfs, :vol, :log]
+    self.line_separator = "\n"
+    # Override lines and use scan instead of split, because we DON'T want to
+    # remove the separators
+    def self.lines(text)
+      lines = text.split("\n")
+      filesystem_stanza = false
+      filesystem_index = 0
+      ret = Array.new
+      lines.each_with_index do |line,i|
+        if line.match(%r{^\S+:})
+          # Begin new filesystem stanza and save the index
+          ret[filesystem_index] = filesystem_stanza.join("\n") if filesystem_stanza
+          filesystem_stanza = Array(line)
+          filesystem_index = i
+          # Eat the preceeding blank line
+          ret[i-1] = nil if i > 0 and ret[i-1] and ret[i-1].match(%r{^\s*$})
+          nil
+        elsif line.match(%r{^(\s*\*.*|\s*)$})
+          # Just a comment or blank line; add in place
+          ret[i] = line
+        else
+          # Non-comments or blank lines must be part of a stanza
+          filesystem_stanza << line
+        end
+      end
+      # Add the final stanza to the return
+      ret[filesystem_index] = filesystem_stanza.join("\n") if filesystem_stanza
+      ret = ret.compact.flatten
+      ret.reject { |line| line.match(/^\* HEADER/) }
+    end
+    def self.header
+      super.gsub(/^#/,'*')
+    end
+
+    record_line self.name,
+      :fields    => @fields,
+      :separator => /\n/,
+      :block_eval => :instance do
+
+      def post_parse(result)
+        property_map = {
+          :dev      => :device,
+          :nodename => :nodename,
+          :options  => :options,
+          :vfs      => :fstype,
+        }
+        # Result is modified in-place instead of being returned; icky!
+        memo = result.dup
+        result.clear
+        # Save the line for later, just in case it is unparsable
+        result[:line] = @fields.collect do |field|
+          memo[field] if memo[field] != :absent
+        end.compact.join("\n")
+        result[:record_type] = memo[:record_type]
+        special_options = Array.new
+        result[:name] = memo[:name].sub(%r{:\s*$},'').strip
+        memo.each do |_,k_v|
+          if k_v and k_v.is_a?(String) and k_v.match("=")
+            attr_name, attr_value = k_v.split("=",2).map(&:strip)
+            if attr_map_name = property_map[attr_name.to_sym]
+              # These are normal "options" options (see `man filesystems`)
+              result[attr_map_name] = attr_value
+            else
+              # These /etc/filesystem attributes have no mount resource simile,
+              # so are added to the "options" property for puppet's sake
+              special_options << "#{attr_name}=#{attr_value}"
+            end
+            if result[:nodename]
+              result[:device] = "#{result[:nodename]}:#{result[:device]}"
+              result.delete(:nodename)
+            end
+          end
+        end
+        result[:options] = [result[:options],special_options.sort].flatten.compact.join(',')
+        if ! result[:device]
+          result[:device] = :absent
+          Puppet.err "Prefetch: Mount[#{result[:name]}]: Field 'device' is missing"
+        end
+        if ! result[:fstype]
+          result[:fstype] = :absent
+          Puppet.err "Prefetch: Mount[#{result[:name]}]: Field 'fstype' is missing"
+        end
+      end
+      def to_line(result)
+        output = Array.new
+        output << "#{result[:name]}:"
+        if result[:device] and result[:device].match(%r{^/})
+          output << "\tdev\t\t= #{result[:device]}"
+        elsif result[:device] and result[:device] != :absent
+          if ! result[:device].match(%{^.+:/})
+            # Just skip this entry; it was malformed to begin with
+            Puppet.err "Mount[#{result[:name]}]: Field 'device' must be in the format of <absolute path> or <host>:<absolute path>"
+            return result[:line]
+          end
+          nodename, path = result[:device].split(":")
+          output << "\tdev\t\t= #{path}"
+          output << "\tnodename\t= #{nodename}"
+        else
+          # Just skip this entry; it was malformed to begin with
+          Puppet.err "Mount[#{result[:name]}]: Field 'device' is required"
+          return result[:line]
+        end
+        if result[:fstype] and result[:fstype] != :absent
+          output << "\tvfs\t\t= #{result[:fstype]}"
+        else
+          # Just skip this entry; it was malformed to begin with
+          Puppet.err "Mount[#{result[:name]}]: Field 'device' is required"
+          return result[:line]
+        end
+        if result[:options]
+          options = result[:options].split(',')
+          special_options = options.select do |x|
+            x.match('=') and
+              ["account", "boot", "check", "free", "mount", "size", "type",
+               "vol", "log", "quota"].include? x.split('=').first
+          end
+          options = options - special_options
+          special_options.sort.each do |x|
+            k, v = x.split("=")
+            output << "\t#{k}\t\t= #{v}"
+          end
+          output << "\toptions\t\t= #{options.join(",")}" unless options.empty?
+        end
+        if result[:line] and result[:line].split("\n").sort == output.sort
+          return "\n#{result[:line]}"
+        else
+          return "\n#{output.join("\n")}"
+        end
+      end
+    end
+  else
+    record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields
+  end
 
   # Every entry in fstab is :unmounted until we can prove different
   def self.prefetch_hook(target_records)

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