puppet 4.0.0 → 4.9.1

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

@@ -1,15 +1,19 @@
 # Puppet package provider for Python's `pip` package management frontend.
-# <http://pip.openplans.org/>
+# <http://pip.pypa.io/>
 
 require 'puppet/provider/package'
-require 'xmlrpc/client'
+require 'puppet/util/http_proxy'
 
 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_.
@@ -25,21 +29,40 @@ Puppet::Type.type(:package).provide :pip,
   # that's managed by `pip` or an empty array if `pip` is not available.
   def self.instances
     packages = []
-    pip_cmd = which(cmd) or return []
+    pip_cmd = self.pip_cmd
+    return [] unless pip_cmd
     execpipe "#{pip_cmd} freeze" do |process|
       process.collect do |line|
         next unless options = parse(line)
         packages << new(options)
       end
     end
+
+    # Pip can also upgrade pip, but it's not listed in freeze so need to special case it
+    # Pip list would also show pip installed version, but "pip list" doesn't exist for older versions of pip (E.G v1.0)
+    if version = self.pip_version
+      packages << new({:ensure => version, :name => File.basename(pip_cmd), :provider => name})
+    end
+
     packages
   end
 
   def self.cmd
-    if Facter.value(:osfamily) == "RedHat" and Facter.value(:operatingsystemmajrelease).to_i < 7
-      "pip-python"
-    else
-      "pip"
+    ["pip", "pip-python"]
+  end
+
+  def self.pip_cmd
+    self.cmd.map { |c| which(c) }.find { |c| c != nil }
+  end
+
+  def self.pip_version
+    pip_cmd = self.pip_cmd
+    return nil unless pip_cmd
+
+    execpipe [pip_cmd, '--version'] do |process|
+      process.collect do |line|
+        return line.strip.match(/^pip (\d+\.\d+\.?\d*).*$/)[1]
+      end
     end
   end
 
@@ -52,17 +75,13 @@ Puppet::Type.type(:package).provide :pip,
     return nil
   end
 
-  # Ask the PyPI API for the latest version number.  There is no local
-  # cache of PyPI's package list so this operation will always have to
-  # ask the web service.
+  # Use pip CLI to look up versions from PyPI repositories, honoring local pip config such as custom repositories
   def latest
-    client = XMLRPC::Client.new2("http://pypi.python.org/pypi")
-    client.http_header_extra = {"Content-Type" => "text/xml"}
-    client.timeout = 10
-    result = client.call("package_releases", @resource[:name])
-    result.first
-  rescue Timeout::Error => detail
-    raise Puppet::Error, "Timeout while contacting pypi.python.org: #{detail}", detail.backtrace
+    return nil unless self.class.pip_cmd
+    if Puppet::Util::Package.versioncmp(self.class.pip_version, '1.5.4') == -1 # a < b
+      return latest_with_old_pip
+    end
+    latest_with_new_pip
   end
 
   # Install a package.  The ensure parameter may specify installed,
@@ -71,6 +90,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=#{
@@ -108,11 +128,52 @@ Puppet::Type.type(:package).provide :pip,
   def lazy_pip(*args)
     pip *args
   rescue NoMethodError => e
-    if pathname = which(self.class.cmd)
-      self.class.commands :pip => pathname
+    # Ensure pip can upgrade pip, which usually puts pip into a new path /usr/local/bin/pip (compared to /usr/bin/pip)
+    # The path to pip needs to be looked up again in the subsequent request. Using the preferred approach as noted
+    # in provider.rb ensures this (copied below for reference)
+    #
+    # @note From provider.rb; It is preferred if the commands are not entered with absolute paths as this allows puppet
+    # to search for them using the PATH variable.
+    if pathname = self.class.cmd.map { |c| which(c) }.find { |c| c != nil }
+      self.class.commands :pip => File.basename(pathname)
       pip *args
     else
-      raise e, 'Could not locate the pip command.', e.backtrace
+      raise e, "Could not locate command #{self.class.cmd.join(' and ')}.", e.backtrace
+    end
+  end
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+  def latest_with_new_pip
+    # Less resource intensive approach for pip version 1.5.4 and above
+    execpipe ["#{self.class.pip_cmd}", "install", "#{@resource[:name]}==versionplease"] do |process|
+      process.collect do |line|
+        # PIP OUTPUT: Could not find a version that satisfies the requirement Django==versionplease (from versions: 1.1.3, 1.8rc1)
+        if line =~ /from versions: /
+          textAfterLastMatch = $'.chomp(")\n")
+          versionList = textAfterLastMatch.split(', ').sort do |x,y|
+            Puppet::Util::Package.versioncmp(x, y)
+          end
+          return versionList.last
+        end
+      end
+      return nil
+    end
+  end
+
+  def latest_with_old_pip
+    Dir.mktmpdir("puppet_pip") do |dir|
+      execpipe ["#{self.class.pip_cmd}", "install", "#{@resource[:name]}", "-d", "#{dir}", "-v"] do |process|
+        process.collect do |line|
+          # PIP OUTPUT: Using version 0.10.1 (newest of versions: 0.10.1, 0.10, 0.9, 0.8.1, 0.8, 0.7.2, 0.7.1, 0.7, 0.6.1, 0.6, 0.5.2, 0.5.1, 0.5, 0.4, 0.3.1, 0.3, 0.2, 0.1)
+          if line =~ /Using version (.+?) \(newest of versions/
+            return $1
+          end
+        end
+        return nil
+      end
     end
   end
 end

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

@@ -0,0 +1,20 @@
+# Puppet package provider for Python's `pip3` package management frontend.
+# <http://pip.pypa.io/>
+
+require 'puppet/provider/package/pip'
+
+Puppet::Type.type(:package).provide :pip3,
+  :parent => :pip do
+
+  desc "Python packages via `pip3`.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip3.
+  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
+
+  def self.cmd
+    ["pip3"]
+  end
+end

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

@@ -1,16 +1,16 @@
 require '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"
-  # http://docs.oracle.com/cd/E19963-01/html/820-6572/managepkgs.html
-  # A few notes before we start :
+  desc "OpenSolaris image packaging system. See pkg(5) for more information."
+  # 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.)
   # The first one is what is distributed with the Solaris 11 Express 11/10 dvd
   # The latest one is what you get when you update package.
   # To make things more interesting, pkg version just returns a sha sum.
   # dvd:     pkg version => 052adf36c3f4
   # updated: pkg version => 630e1ffc7a19
-  # Thankfully, solaris has not changed the commands to be used.
+  # Thankfully, Solaris has not changed the commands to be used.
   # TODO: We still have to allow packages to specify a preferred publisher.
 
   has_feature :versionable
@@ -23,17 +23,17 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
 
   confine :osfamily => :solaris
 
-  defaultfor :osfamily => :solaris, :kernelrelease => '5.11'
+  defaultfor :osfamily => :solaris, :kernelrelease => ['5.11', '5.12']
 
   def self.instances
     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 ether
+  # The IFO flag field is just what it names, the first field can have either
   # i_nstalled or -, and second field f_rozen or -, and last
   # o_bsolate or r_rename or -
   # so this checks if the installed field is present, and also verifies that
-  # if not the field is -, else we dont know what we are doing and exit with
+  # if not the field is -, else we don't know what we are doing and exit with
   # out doing more damage.
   def self.ifo_flag(flags)
     (
@@ -203,10 +203,14 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     else
       command = 'update'
     end
+    args = ['--accept']
+    if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemrelease), '11.2') >= 0
+      args.push('--sync-actuators-timeout', '900')
+    end
     unless should.is_a? Symbol
       name += "@#{should}"
     end
-    r = exec_cmd(command(:pkg), command, '--accept', name)
+    r = exec_cmd(command(:pkg), command, *args, name)
     return r if nofail
     raise Puppet::Error, "Unable to update #{r[:out]}" if r[:exit] != 0
   end

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

@@ -9,7 +9,7 @@
 # in /var/db/.puppet_pkgdmg_installed_<name>
 
 require 'puppet/provider/package'
-require 'plist'
+require 'puppet/util/plist'
 require 'puppet/util/http_proxy'
 
 Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Package do
@@ -36,6 +36,7 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
       package, you must create a new DMG with a different filename."
 
   confine :operatingsystem => :darwin
+  confine :feature         => :cfpropertylist
   defaultfor :operatingsystem => :darwin
   commands :installer => "/usr/sbin/installer"
   commands :hdiutil => "/usr/bin/hdiutil"
@@ -61,18 +62,20 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
   def self.installpkg(source, name, orig_source)
     installer "-pkg", source, "-target", "/"
     # Non-zero exit status will throw an exception.
-    File.open("/var/db/.puppet_pkgdmg_installed_#{name}", "w") do |t|
+    Puppet::FileSystem.open("/var/db/.puppet_pkgdmg_installed_#{name}", nil, "w:UTF-8") do |t|
       t.print "name: '#{name}'\n"
       t.print "source: '#{orig_source}'\n"
     end
   end
 
   def self.installpkgdmg(source, name)
-    http_proxy_host = Puppet::Util::HttpProxy.http_proxy_host
-    http_proxy_port = Puppet::Util::HttpProxy.http_proxy_port
+    unless Puppet::Util::HttpProxy.no_proxy?(source)
+      http_proxy_host = Puppet::Util::HttpProxy.http_proxy_host
+      http_proxy_port = Puppet::Util::HttpProxy.http_proxy_port
+    end
 
     unless source =~ /\.dmg$/i || source =~ /\.pkg$/i
-      raise Puppet::Error.new("Mac OS X PKG DMG's must specify a source string ending in .dmg or flat .pkg file")
+      raise Puppet::Error.new("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
@@ -100,7 +103,7 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
         # 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
-          hdiutil_info = Plist::parse_xml(xml_str)
+          hdiutil_info = Puppet::Util::Plist.parse_plist(xml_str)
           raise Puppet::Error.new("No disk entities returned by mount at #{dmg.path}") unless hdiutil_info.has_key?("system-entities")
           mounts = hdiutil_info["system-entities"].collect { |entity|
             entity["mount-point"]
@@ -139,10 +142,10 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
   def install
     source = nil
     unless source = @resource[:source]
-      raise Puppet::Error.new("Mac OS X PKG DMG's must specify a package source.")
+      raise Puppet::Error.new("Mac OS X PKG DMGs must specify a package source.")
     end
     unless name = @resource[:name]
-      raise Puppet::Error.new("Mac OS X PKG DMG's must specify a package name.")
+      raise Puppet::Error.new("Mac OS X PKG DMGs must specify a package name.")
     end
     self.class.installpkgdmg(source,name)
   end

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

@@ -5,15 +5,15 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
 
   commands :pkgin => "pkgin"
 
-  defaultfor :operatingsystem => [ :dragonfly , :smartos ]
+  defaultfor :operatingsystem => [ :dragonfly , :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+.+$/)
+    #   vim-7.2.446;Vim editor (vi clone) without GUI
+    match, name, version, status = *package.match(/([^\s;]+)-([^\s;]+)[;\s](=|>|<)?.+$/)
     if match
       {
         :name     => name,
@@ -25,7 +25,7 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
 
   def self.prefetch(packages)
     super
-    # Withouth -f, no fresh pkg_summary files are downloaded
+    # Without -f, no fresh pkg_summary files are downloaded
     pkgin("-yf", :update)
   end
 

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

@@ -0,0 +1,143 @@
+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, version_list)
+    if latest_version = 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
+      version_list = self.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)
+      end
+
+      return 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 }
+        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
+      # If resource[:name] is actually an origin (e.g. 'www/curl' instead of
+      # 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] =~ /\//
+        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]
+    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/pkgutil.rb

@@ -78,7 +78,7 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
   # Turn our pkgutil -c listing into a hash for a single package.
   def pkgsingle(resource)
     # The --single option speeds up the execution, because it queries
-    # the package managament system for one package only.
+    # the package management system for one package only.
     command = ["-c", "--single", resource[:name]]
     self.class.parse_pkglist(run_pkgutil(resource, command), { :justme => resource[:name] })
   end

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

@@ -25,12 +25,13 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     result_fields = self.eix_result_fields
 
     version_format = self.eix_version_format
+    slot_versions_format = self.eix_slot_versions_format
     begin
       eix_file = File.directory?("/var/cache/eix") ? "/var/cache/eix/portage.eix" : "/var/cache/eix"
       update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
 
       search_output = nil
-      Puppet::Util.withenv :LASTVERSION => version_format do
+      Puppet::Util.withenv :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format do
         search_output = eix *(self.eix_search_arguments + ["--installed"])
       end
 
@@ -59,7 +60,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     name = package_name
     unless should == :present or should == :latest
       # We must install a specific version
-      name = "=#{name}-#{should}"
+      name = package_atom_with_version(should)
     end
     emerge name
   end
@@ -69,6 +70,24 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     @resource[:category] ? "#{@resource[:category]}/#{@resource[:name]}" : @resource[:name]
   end
 
+  def package_name_without_slot
+    package_name.sub(self.class.slot_pattern, '')
+  end
+
+  def package_slot
+    if match = package_name.match(self.class.slot_pattern)
+      match[1]
+    end
+  end
+
+  def package_atom_with_version(version)
+    if slot = package_slot
+      "=#{package_name_without_slot}-#{version}:#{package_slot}"
+    else
+      "=#{package_name}-#{version}"
+    end
+  end
+
   def uninstall
     emerge "--unmerge", package_name
   end
@@ -86,15 +105,16 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     result_fields = self.class.eix_result_fields
 
     version_format = self.class.eix_version_format
-    search_field = package_name.count('/') > 0 ? "--category-name" : "--name"
-    search_value = package_name
+    slot_versions_format = self.class.eix_slot_versions_format
+    search_field = package_name_without_slot.count('/') > 0 ? "--category-name" : "--name"
+    search_value = package_name_without_slot
 
     begin
       eix_file = File.directory?("/var/cache/eix") ? "/var/cache/eix/portage.eix" : "/var/cache/eix"
       update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
 
       search_output = nil
-      Puppet::Util.withenv :LASTVERSION => version_format do
+      Puppet::Util.withenv :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format do
         search_output = eix *(self.class.eix_search_arguments + ["--exact",search_field,search_value])
       end
 
@@ -107,6 +127,10 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
           result_fields.zip(match.captures) do |field, value|
             package[field] = value unless !value or value.empty?
           end
+          if package_slot
+            package[:version_available] = eix_get_version_for_slot(package[:slot_versions_available], package_slot)
+            package[:ensure] = eix_get_version_for_slot(package[:installed_slots], package_slot)
+          end
           package[:ensure] = package[:ensure] ? package[:ensure] : :absent
           packages << package
         end
@@ -131,22 +155,38 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
   end
 
   private
+  def eix_get_version_for_slot(versions_and_slots, slot)
+    return nil if versions_and_slots.nil?
+    versions_and_slots = versions_and_slots.split(",")
+    versions_and_slots.map! { |version_and_slot| version_and_slot.split(":") }
+    version_for_slot = versions_and_slots.find { |version_and_slot| version_and_slot.last == slot }
+    version_for_slot.first if version_for_slot
+  end
+
+  def self.slot_pattern
+    /:([\w+.\/*=-]+)$/
+  end
+
   def self.eix_search_format
-    "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] <homepage> <description>'"
+    "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] [<installedversions:LASTSLOTVERSIONS>] [<bestslotversions:LASTSLOTVERSIONS>] <homepage> <description>\n'"
   end
 
   def self.eix_result_format
-    /^(\S+)\s+(\S+)\s+\[(\S*)\]\s+\[(\S*)\]\s+(\S+)\s+(.*)$/
+    /^(\S+)\s+(\S+)\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+(\S+)\s+(.*)$/
   end
 
   def self.eix_result_fields
-    [:category, :name, :ensure, :version_available, :vendor, :description]
+    [:category, :name, :ensure, :version_available, :installed_slots, :slot_versions_available, :vendor, :description]
   end
 
   def self.eix_version_format
     "{last}<version>{}"
   end
 
+  def self.eix_slot_versions_format
+    "{!first},{}<version>:<slot>"
+  end
+
   def self.eix_search_arguments
     ["--nocolor", "--pure-packages", "--format",self.eix_search_format]
   end

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