puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

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

@@ -1,7 +1,14 @@
-require 'puppet/provider/package'
+# frozen_string_literal: true
+
+require_relative '../../../puppet/provider/package'
 
 Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package do
-  desc "OpenSolaris image packaging system. See pkg(5) for more information."
+  desc "OpenSolaris image packaging system. See pkg(5) for more information.
+
+    This provider supports the `install_options` attribute, which allows
+    command-line flags to be passed to pkg. These options should be specified as an
+    array where each element is either a string or a hash."
+
   # https://docs.oracle.com/cd/E19963-01/html/820-6572/managepkgs.html
   # A few notes before we start:
   # Opensolaris pkg has two slightly different formats (as of now.)
@@ -19,14 +26,16 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
 
   has_feature :holdable
 
+  has_feature :install_options
+
   commands :pkg => "/usr/bin/pkg"
 
-  confine :osfamily => :solaris
+  confine 'os.family' => :solaris
 
-  defaultfor :osfamily => :solaris, :kernelrelease => ['5.11', '5.12']
+  defaultfor 'os.family' => :solaris, :kernelrelease => ['5.11', '5.12']
 
   def self.instances
-    pkg(:list, '-Hv').split("\n").map{|l| new(parse_line(l))}
+    pkg(:list, '-Hv').split("\n").map { |l| new(parse_line(l)) }
   end
 
   # The IFO flag field is just what it names, the first field can have either
@@ -39,22 +48,22 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     (
       case flags[0..0]
       when 'i'
-        {:status => 'installed'}
+        { :status => 'installed' }
       when '-'
-        {:status => 'known'}
+        { :status => 'known' }
       else
         raise ArgumentError, _('Unknown format %{resource_name}: %{full_flags}[%{bad_flag}]') %
-            { resource_name: self.name, full_flags: flags, bad_flag: flags[0..0] }
+            { resource_name: name, full_flags: flags, bad_flag: flags[0..0] }
       end
     ).merge(
       case flags[1..1]
       when 'f'
-        {:ensure => 'held'}
+        { :mark => :hold }
       when '-'
         {}
       else
         raise ArgumentError, _('Unknown format %{resource_name}: %{full_flags}[%{bad_flag}]') %
-            { resource_name: self.name, full_flags: flags, bad_flag: flags[1..1] }
+            { resource_name: name, full_flags: flags, bad_flag: flags[1..1] }
       end
     )
   end
@@ -80,11 +89,11 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
   def self.pkg_state(state)
     case state
     when /installed/
-      {:status => 'installed'}
+      { :status => 'installed' }
     when /known/
-      {:status => 'known'}
+      { :status => 'known' }
     else
-      raise ArgumentError, _('Unknown format %{resource_name}: %{state}') % { resource_name: self.name, state: state }
+      raise ArgumentError, _('Unknown format %{resource_name}: %{state}') % { resource_name: name, state: state }
     end
   end
 
@@ -92,19 +101,19 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
   # formats of output for different pkg versions.
   def self.parse_line(line)
     (case line.chomp
-    # FMRI                                                                         IFO
-    # pkg://omnios/SUNWcs@0.5.11,5.11-0.151008:20131204T022241Z                    ---
-    when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(...)$'
-      {:publisher => $1, :name => $2, :ensure => $3}.merge ifo_flag($4)
+     # FMRI                                                                         IFO
+     # pkg://omnios/SUNWcs@0.5.11,5.11-0.151008:20131204T022241Z                    ---
+     when %r{^pkg://([^/]+)/([^@]+)@(\S+) +(...)$}
+       { :publisher => Regexp.last_match(1), :name => Regexp.last_match(2), :ensure => Regexp.last_match(3) }.merge ifo_flag(Regexp.last_match(4))
 
-    # FMRI                                                             STATE      UFOXI
-    # pkg://solaris/SUNWcs@0.5.11,5.11-0.151.0.1:20101105T001108Z      installed  u----
-    when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(\S+) +(.....)$'
-      {:publisher => $1, :name => $2, :ensure => $3}.merge pkg_state($4).merge(ufoxi_flag($5))
+     # FMRI                                                             STATE      UFOXI
+     # pkg://solaris/SUNWcs@0.5.11,5.11-0.151.0.1:20101105T001108Z      installed  u----
+     when %r{^pkg://([^/]+)/([^@]+)@(\S+) +(\S+) +(.....)$}
+       { :publisher => Regexp.last_match(1), :name => Regexp.last_match(2), :ensure => Regexp.last_match(3) }.merge pkg_state(Regexp.last_match(4)).merge(ufoxi_flag(Regexp.last_match(5)))
 
-    else
-      raise ArgumentError, _('Unknown line format %{resource_name}: %{parse_line}') % { resource_name: self.name, parse_line: line }
-    end).merge({:provider => self.name})
+     else
+       raise ArgumentError, _('Unknown line format %{resource_name}: %{parse_line}') % { resource_name: name, parse_line: line }
+     end).merge({ :provider => name })
   end
 
   def hold
@@ -113,7 +122,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
 
   def unhold
     r = exec_cmd(command(:pkg), 'unfreeze', @resource[:name])
-    raise Puppet::Error, _("Unable to unfreeze %{package}") % { package: r[:out] } unless [0,4].include? r[:exit]
+    raise Puppet::Error, _("Unable to unfreeze %{package}") % { package: r[:out] } unless [0, 4].include? r[:exit]
   end
 
   def insync?(is)
@@ -145,14 +154,23 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
       # unfortunately it doesn't consider downgrades 'available' (eg. with
       # installed foo@1.0, list -a foo@0.9 would fail).
       name = @resource[:name]
-      potential_matches = pkg(:list, '-Hvfa', "#{name}@#{should}").split("\n").map{|l|self.class.parse_line(l)}
+      potential_matches = pkg(:list, '-Hvfa', "#{name}@#{should}").split("\n").map { |l| self.class.parse_line(l) }
       n = potential_matches.length
       if n > 1
         warning(_("Implicit version %{should} has %{n} possible matches") % { should: should, n: n })
       end
-      potential_matches.each{ |p|
+      potential_matches.each { |p|
         command = is == :absent ? 'install' : 'update'
-        status = exec_cmd(command(:pkg), command, '-n', "#{name}@#{p[:ensure]}")[:exit]
+        options = ['-n']
+        options.concat(join_options(@resource[:install_options])) if @resource[:install_options]
+
+        begin
+          unhold if properties[:mark] == :hold
+          status = exec_cmd(command(:pkg), command, *options, "#{name}@#{p[:ensure]}")[:exit]
+        ensure
+          hold if properties[:mark] == :hold
+        end
+
         case status
         when 4
           # if the first installable match would cause no changes, we're in sync
@@ -164,7 +182,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
         end
       }
       raise Puppet::DevError, _("No version of %{name} matching %{should} is installable, even though the package is currently installed") %
-          { name: name, should: should }
+                              { name: name, should: should }
     end
 
     false
@@ -190,33 +208,52 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     # Now we know there is a newer version. But is that installable? (i.e are there any constraints?)
     # return the first known we find. The only way that is currently available is to do a dry run of
     # pkg update and see if could get installed (`pkg update -n res`).
-    known = lst.find {|p| p[:status] == 'known' }
-    return known[:ensure] if known and exec_cmd(command(:pkg), 'update', '-n', @resource[:name])[:exit].zero?
+    known = lst.find { |p| p[:status] == 'known' }
+    if known
+      options = ['-n']
+      options.concat(join_options(@resource[:install_options])) if @resource[:install_options]
+      return known[:ensure] if exec_cmd(command(:pkg), 'update', *options, @resource[:name])[:exit].zero?
+    end
 
     # If not, then return the installed, else nil
-    (lst.find {|p| p[:status] == 'installed' } || {})[:ensure]
+    (lst.find { |p| p[:status] == 'installed' } || {})[:ensure]
   end
 
   # install the package and accept all licenses.
   def install(nofail = false)
     name = @resource[:name]
     should = @resource[:ensure]
-    # always unhold if explicitly told to install/update
-    self.unhold
-    is = self.query
+    is = query
     if is[:ensure].to_sym == :absent
       command = 'install'
     else
       command = 'update'
     end
     args = ['--accept']
-    if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemrelease), '11.2') >= 0
+    if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.full'), '11.2') >= 0
       args.push('--sync-actuators-timeout', '900')
     end
+    args.concat(join_options(@resource[:install_options])) if @resource[:install_options]
     unless should.is_a? Symbol
       name += "@#{should}"
     end
-    r = exec_cmd(command(:pkg), command, *args, name)
+    unhold if properties[:mark] == :hold
+    begin
+      tries = 1
+      # pkg install exits with code 7 when the image is currently in use by another process and cannot be modified
+      r = exec_cmd(command(:pkg), command, *args, name)
+      while r[:exit] == 7
+        if tries > 4
+          raise Puppet::Error, _("Pkg could not install %{name} after %{tries} tries. Aborting run") % { name: name, tries: tries }
+        end
+
+        sleep 2**tries
+        tries += 1
+        r = exec_cmd(command(:pkg), command, *args, name)
+      end
+    ensure
+      hold if @resource[:mark] == :hold
+    end
     return r if nofail
     raise Puppet::Error, _("Unable to update %{package}") % { package: r[:out] } if r[:exit] != 0
   end
@@ -230,26 +267,34 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
       cmd << '-r'
     end
     cmd << @resource[:name]
-    pkg cmd
+    unhold if properties[:mark] == :hold
+    begin
+      pkg cmd
+    rescue StandardError, LoadError => e
+      hold if properties[:mark] == :hold
+      raise e
+    end
   end
 
   # update the package to the latest version available
   def update
     r = install(true)
     # 4 == /No updates available for this image./
-    return if [0,4].include? r[:exit]
+    return if [0, 4].include? r[:exit]
+
     raise Puppet::Error, _("Unable to update %{package}") % { package: r[:out] }
   end
 
   # list a specific package
   def query
     r = exec_cmd(command(:pkg), 'list', '-Hv', @resource[:name])
-    return {:ensure => :absent, :name => @resource[:name]} if r[:exit] != 0
+    return { :ensure => :absent, :name => @resource[:name] } if r[:exit] != 0
+
     self.class.parse_line(r[:out])
   end
 
   def exec_cmd(*cmd)
     output = Puppet::Util::Execution.execute(cmd, :failonfail => false, :combine => true)
-    {:out => output, :exit => $CHILD_STATUS.exitstatus}
+    { :out => output, :exit => output.exitstatus }
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Motivation: DMG files provide a true HFS file system
 # and are easier to manage and .pkg bundles.
@@ -8,9 +10,9 @@
 # As a result, we store installed .pkg.dmg file names
 # in /var/db/.puppet_pkgdmg_installed_<name>
 
-require 'puppet/provider/package'
-require 'puppet/util/plist'
-require 'puppet/util/http_proxy'
+require_relative '../../../puppet/provider/package'
+require_relative '../../../puppet/util/plist'
+require_relative '../../../puppet/util/http_proxy'
 
 Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Package do
   desc "Package management based on Apple's Installer.app and DiskUtility.app.
@@ -35,9 +37,9 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
       whether a package has been installed. Thus, to install new a version of a
       package, you must create a new DMG with a different filename."
 
-  confine :operatingsystem => :darwin
-  confine :feature         => :cfpropertylist
-  defaultfor :operatingsystem => :darwin
+  confine 'os.name' => :darwin
+  confine :feature => :cfpropertylist
+  defaultfor 'os.name' => :darwin
   commands :installer => "/usr/sbin/installer"
   commands :hdiutil => "/usr/bin/hdiutil"
   commands :curl => "/usr/bin/curl"
@@ -75,26 +77,27 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
     end
 
     unless source =~ /\.dmg$/i || source =~ /\.pkg$/i
-      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a source string ending in .dmg or flat .pkg file"))
+      raise Puppet::Error, _("Mac OS X PKG DMGs must specify a source string ending in .dmg or flat .pkg file")
     end
+
     require 'open-uri' # Dead code; this is never used. The File.open call 20-ish lines south of here used to be Kernel.open but changed in '09. -NF
     cached_source = source
     tmpdir = Dir.mktmpdir
     ext = /(\.dmg|\.pkg)$/i.match(source)[0]
     begin
-      if %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ cached_source
+      if %r{\A[A-Za-z][A-Za-z0-9+\-.]*://} =~ cached_source
         cached_source = File.join(tmpdir, "#{name}#{ext}")
-        args = [ "-o", cached_source, "-C", "-", "-L", "-s", "--fail", "--url", source ]
+        args = ["-o", cached_source, "-C", "-", "-L", "-s", "--fail", "--url", source]
         if http_proxy_host and http_proxy_port
           args << "--proxy" << "#{http_proxy_host}:#{http_proxy_port}"
-        elsif http_proxy_host and not http_proxy_port
+        elsif http_proxy_host and !http_proxy_port
           args << "--proxy" << http_proxy_host
         end
         begin
           curl(*args)
-            Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(" ")})"
+          Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(' ')})"
         rescue Puppet::ExecutionFailure
-          Puppet.debug "curl #{args.join(" ")} did not transfer [#{name}].  Falling back to local file." # This used to fall back to open-uri. -NF
+          Puppet.debug "curl #{args.join(' ')} did not transfer [#{name}].  Falling back to local file." # This used to fall back to open-uri. -NF
           cached_source = source
         end
       end
@@ -102,12 +105,13 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
       if source =~ /\.dmg$/i
         # If you fix this to use open-uri again, you must update the docs above. -NF
         File.open(cached_source) do |dmg|
-          xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-noidme", "-mountrandom", "/tmp", dmg.path
+          xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", dmg.path
           hdiutil_info = Puppet::Util::Plist.parse_plist(xml_str)
-          raise Puppet::Error.new(_("No disk entities returned by mount at %{path}") % { path: dmg.path }) unless hdiutil_info.has_key?("system-entities")
-          mounts = hdiutil_info["system-entities"].collect { |entity|
+          raise Puppet::Error, _("No disk entities returned by mount at %{path}") % { path: dmg.path } unless hdiutil_info.has_key?("system-entities")
+
+          mounts = hdiutil_info["system-entities"].filter_map { |entity|
             entity["mount-point"]
-          }.compact
+          }
           begin
             mounts.each do |mountpoint|
               Dir.entries(mountpoint).select { |f|
@@ -133,19 +137,23 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
   def query
     if Puppet::FileSystem.exist?("/var/db/.puppet_pkgdmg_installed_#{@resource[:name]}")
       Puppet.debug "/var/db/.puppet_pkgdmg_installed_#{@resource[:name]} found"
-      return {:name => @resource[:name], :ensure => :present}
+      { :name => @resource[:name], :ensure => :present }
     else
-      return nil
+      nil
     end
   end
 
   def install
-    unless source = @resource[:source]
-      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a package source."))
+    source = @resource[:source]
+    unless source
+      raise Puppet::Error, _("Mac OS X PKG DMGs must specify a package source.")
     end
-    unless name = @resource[:name]
-      raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a package name."))
+
+    name = @resource[:name]
+    unless name
+      raise Puppet::Error, _("Mac OS X PKG DMGs must specify a package name.")
     end
-    self.class.installpkgdmg(source,name)
+
+    self.class.installpkgdmg(source, name)
   end
 end

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

@@ -1,24 +1,25 @@
-require "puppet/provider/package"
+# frozen_string_literal: true
+
+require_relative '../../../puppet/provider/package'
 
 Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package do
   desc "Package management using pkgin, a binary package manager for pkgsrc."
 
   commands :pkgin => "pkgin"
 
-  defaultfor :operatingsystem => [ :smartos, :netbsd ]
+  defaultfor 'os.name' => [:smartos, :netbsd]
 
   has_feature :installable, :uninstallable, :upgradeable, :versionable
 
   def self.parse_pkgin_line(package)
-
     # e.g.
     #   vim-7.2.446;Vim editor (vi clone) without GUI
     match, name, version, status = *package.match(/([^\s;]+)-([^\s;]+)[;\s](=|>|<)?.+$/)
     if match
       {
-        :name     => name,
-        :status   => status,
-        :ensure   => version
+        :name => name,
+        :status => status,
+        :ensure => version
       }
     end
   end
@@ -47,7 +48,7 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
       end
     end
 
-    packages.first.update( :ensure => :absent )
+    packages.first.update(:ensure => :absent)
   end
 
   def parse_pkgsearch_line
@@ -58,12 +59,12 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
     # Remove the last three lines of help text.
     packages.slice!(-4, 4)
 
-    pkglist = packages.map{ |line| self.class.parse_pkgin_line(line) }
-    pkglist.select{ |package| resource[:name] == package[:name] }
+    pkglist = packages.map { |line| self.class.parse_pkgin_line(line) }
+    pkglist.select { |package| resource[:name] == package[:name] }
   end
 
   def install
-    if String === @resource[:ensure]
+    if @resource[:ensure].is_a?(String)
       pkgin("-y", :install, "#{resource[:name]}-#{resource[:ensure]}")
     else
       pkgin("-y", :install, resource[:name])
@@ -75,13 +76,13 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
   end
 
   def latest
-    package = parse_pkgsearch_line.detect{ |p| p[:status] == '<' }
-    return properties[:ensure] if not package
-    return package[:ensure]
+    package = parse_pkgsearch_line.detect { |p| p[:status] == '<' }
+    return properties[:ensure] unless package
+
+    package[:ensure]
   end
 
   def update
     pkgin("-y", :install, resource[:name])
   end
-
 end

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

@@ -1,69 +1,92 @@
-require 'puppet/provider/package'
+# frozen_string_literal: true
+
+require_relative '../../../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]
+  confine 'os.name' => [:freebsd, :dragonfly]
 
-  defaultfor :operatingsystem => [:freebsd, :dragonfly]
+  defaultfor 'os.name' => [:freebsd, :dragonfly]
 
   has_feature :versionable
   has_feature :upgradeable
+  has_feature :install_options
 
   def self.get_query
     pkg(['query', '-a', '%n %v %o'])
   end
 
+  def self.get_resource_info(name)
+    pkg(['query', '%n %v %o', name])
+  end
+
+  def self.cached_version_list
+    # rubocop:disable Naming/MemoizedInstanceVariableName
+    @version_list ||= get_version_list
+    # rubocop:enable Naming/MemoizedInstanceVariableName
+  end
+
   def self.get_version_list
-    pkg(['version', '-voRL='])
+    @version_list = pkg(['version', '-voRL='])
   end
 
-  def self.get_latest_version(origin, version_list)
-    if latest_version = version_list.lines.find { |l| l =~ /^#{origin} / }
-      latest_version = latest_version.split(' ').last.split(')').first
+  def self.get_latest_version(origin)
+    latest_version = cached_version_list.lines.find { |l| l =~ /^#{origin} / }
+    if latest_version
+      _name, compare, status = latest_version.chomp.split(' ', 3)
+      if ['!', '?'].include?(compare)
+        return nil
+      end
+
+      latest_version = status.split(' ').last.split(')').first
       return latest_version
     end
     nil
   end
 
+  def self.parse_pkg_query_line(line)
+    name, version, origin = line.chomp.split(' ', 3)
+    latest_version = get_latest_version(origin) || version
+
+    {
+      :ensure => version,
+      :name => name,
+      :provider => self.name,
+      :origin => origin,
+      :version => version,
+      :latest => latest_version
+    }
+  end
+
   def self.instances
     packages = []
     begin
-      info = self.get_query
-      version_list = self.get_version_list
+      info = get_query
+      get_version_list
 
       unless info
         return packages
       end
 
       info.lines.each do |line|
-
-        name, version, origin = line.chomp.split(" ", 3)
-        latest_version  = get_latest_version(origin, version_list) || version
-
-        pkg = {
-          :ensure   => version,
-          :name     => name,
-          :provider => self.name,
-          :origin   => origin,
-          :version  => version,
-          :latest   => latest_version
-        }
-        packages << new(pkg)
+        hash = parse_pkg_query_line(line)
+        packages << new(hash)
       end
 
-      return packages
+      packages
     rescue Puppet::ExecutionFailure
-      return []
+      []
     end
   end
 
   def self.prefetch(resources)
     packages = instances
     resources.each_key do |name|
-      if provider = packages.find{|p| p.name == name or p.origin == name }
+      provider = packages.find { |p| p.name == name or p.origin == name }
+      if provider
         resources[name].provider = provider
       end
     end
@@ -73,6 +96,7 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
     # extract repo tag from URN: urn:freebsd:repo:<tag>
     match = /^urn:freebsd:repo:(.+)$/.match(urn)
     raise ArgumentError urn.inspect unless match
+
     match[1]
   end
 
@@ -89,21 +113,24 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
       # just 'curl'), drop the category prefix. pkgng doesn't support version
       # pinning with the origin syntax (pkg install curl-1.2.3 is valid, but
       # pkg install www/curl-1.2.3 is not).
-      if resource[:name] =~ /\//
+      if resource[:name] =~ %r{/}
         installname = resource[:name].split('/')[1] + '-' + resource[:ensure]
       else
         installname = resource[:name] + '-' + resource[:ensure]
       end
     end
 
-    if not source # install using default repo logic
-      args = ['install', '-qy', installname]
+    if !source # install using default repo logic
+      args = ['install', '-qy']
     elsif source.scheme == 'urn' # install from repo named in URN
       tag = repo_tag_from_urn(source.to_s)
-      args = ['install', '-qy', '-r', tag, installname]
+      args = ['install', '-qy', '-r', tag]
     else # add package located at URL
-      args = ['add', '-q', source.to_s]
+      args = ['add', '-q']
+      installname = source.to_s
     end
+    args += install_options if @resource[:install_options]
+    args << installname
 
     pkg(args)
   end
@@ -113,18 +140,23 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
   end
 
   def query
-    if @property_hash[:ensure] == nil
+    begin
+      output = self.class.get_resource_info(resource[:name])
+    rescue Puppet::ExecutionFailure
       return nil
-    else
-      version = @property_hash[:version]
-      return { :version => version }
     end
+
+    self.class.parse_pkg_query_line(output)
   end
 
   def version
     @property_hash[:version]
   end
 
+  def version=
+    pkg(['install', '-qfy', "#{resource[:name]}-#{resource[:version]}"])
+  end
+
   # Upgrade to the latest version
   def update
     install
@@ -140,4 +172,7 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
     @property_hash[:origin]
   end
 
+  def install_options
+    join_options(@resource[:install_options])
+  end
 end