puppet 6.0.10 → 6.1.0

data/lib/puppet/provider/exec.rb

@@ -15,7 +15,7 @@ class Puppet::Provider::Exec < Puppet::Provider
 
     envlist = [envlist] unless envlist.is_a? Array
     envlist.each do |setting|
-      unless (match = /^(\w+)=((.|\n)+)$/.match(setting))
+      unless (match = /^(\w+)=((.|\n)*)$/.match(setting))
         warning _("Cannot understand environment setting %{setting}") % { setting: setting.inspect }
         next
       end
@@ -26,6 +26,11 @@ class Puppet::Provider::Exec < Puppet::Provider
         warning _("Overriding environment setting '%{var}' with '%{value}'") % { var: var, value: value }
       end
 
+      if value.nil? || value.empty?
+        msg = _("Empty environment setting '%{var}'") % {var: var}
+        Puppet.warn_once('undefined_variables', "empty_env_var_#{var}", msg, resource.file, resource.line)
+      end
+
       env[var] = value
     end
 

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

@@ -71,9 +71,7 @@ Puppet::Type.type(:file).provide :windows do
 
   def mode=(value)
     begin
-      managing_owner = !resource[:owner].nil?
-      managing_group = !resource[:group].nil?
-      set_mode(value.to_i(8), resource[:path], true, managing_owner, managing_group)
+      set_mode(value.to_i(8), resource[:path])
     rescue => detail
       error = Puppet::Error.new(_("failed to set mode %{mode} on %{path}: %{message}") % { mode: mode, path: resource[:path], message: detail.message })
       error.set_backtrace detail.backtrace
@@ -88,52 +86,6 @@ Puppet::Type.type(:file).provide :windows do
     end
   end
 
-  # munge the windows group permissions if the user or group are set to SYSTEM
-  #
-  # when SYSTEM user is the group or user and the resoure is not managing them then treat
-  # the resource as insync if System has FullControl access.
-  #
-  # @param [String] current - the current mode returned by the resource
-  # @param [String] should  - what the mode should be
-  #
-  # @return [String, nil] munged mode or nil if the resource should be out of sync
-  def munge_windows_system_group(current, should)
-    [
-      {
-        'type'        => 'group',
-        'resource'    => resource[:group],
-        'set_to_user' => group,
-        'fullcontrol' => "070".to_i(8),
-        'remove_mask' => "707".to_i(8),
-        'should_mask' => (should[0].to_i(8) & "070".to_i(8)),
-      },
-      {
-        'type'        => 'owner',
-        'resource'    => resource[:owner],
-        'set_to_user' => owner,
-        'fullcontrol' => "700".to_i(8),
-        'remove_mask' => "077".to_i(8),
-        'should_mask' => (should[0].to_i(8) & "700".to_i(8)),
-      }
-    ].each do |mode_part|
-      if mode_part['resource'].nil? && (mode_part['set_to_user'] == Puppet::Util::Windows::SID::LocalSystem)
-        if (current.to_i(8) & mode_part['fullcontrol']) == mode_part['fullcontrol']
-          # Since the group is LocalSystem, and the permissions are FullControl,
-          # replace the value returned with the value expected. This will treat
-          # this specific situation as "insync"
-          current = ( (current.to_i(8) & mode_part['remove_mask']) | mode_part['should_mask'] ).to_s(8).rjust(4, '0')
-        else
-          # If the SYSTEM account does _not_ have FullControl in this scenario, we should
-          # force the resource out of sync no matter what.
-          #TRANSLATORS 'SYSTEM' is a Windows name and should not be translated
-          Puppet.debug _("%{resource_name}: %{mode_part_type} set to SYSTEM. SYSTEM permissions cannot be set below FullControl ('7')") % { resource_name: resource[:name], mode_part_type: mode_part['type']}
-          return nil
-        end
-      end
-    end
-    current
-  end
-
   attr_reader :file
   private
   def file

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

@@ -67,10 +67,7 @@ Puppet::Type.type(:group).provide :windows_adsi do
 
   def members
     @members ||= Puppet::Util::Windows::ADSI::Group.name_sid_hash(group.members)
-
-    # @members.keys returns an array of SIDs. We need to convert those SIDs into
-    # names so that `puppet resource` prints the right output.
-    members_to_s(@members.keys).split(',')
+    @members.keys
   end
 
   def members=(members)

data/lib/puppet/provider/package.rb

@@ -1,5 +1,3 @@
-require 'puppet/provider'
-
 class Puppet::Provider::Package < Puppet::Provider
   # Prefetch our package list, yo.
   def self.prefetch(packages)

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

@@ -81,6 +81,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     unless file = @resource[:source]
       raise ArgumentError, _("You cannot install dpkg packages without a source")
     end
+
     args = []
 
     # We always unhold when installing to remove any prior hold.
@@ -145,9 +146,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
   end
 
   def hold
-    if package_not_installed?(@resource[:name])
-      self.install
-    end
+    self.install
     Tempfile.open('puppet_dpkg_set_selection') do |tmpfile|
       tmpfile.write("#{@resource[:name]} hold\n")
       tmpfile.flush
@@ -163,16 +162,4 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     end
   end
 
-  def package_not_installed?(name)
-    if !name.nil? && !name.empty?
-      begin
-       dpkgquery("-W", "--showformat", self.class::DPKG_QUERY_FORMAT_STRING, name)
-      rescue Puppet::ExecutionFailure
-        # return true if exception is generated because package is not found
-        return true
-      end
-      return false
-    end
-    raise ArgumentError.new("Package name is nil or empty")
-  end
 end

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

@@ -1,8 +1,8 @@
-require 'puppet/provider/package_targetable'
+require 'puppet/provider/package'
 require 'uri'
 
 # Ruby gems support.
-Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::Targetable do
+Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package do
   desc "Ruby Gem support. If a URL is passed via `source`, then that URL is
     appended to the list of remote gem repositories; to ensure that only the
     specified source is used, also pass `--clear-sources` via `install_options`.
@@ -15,79 +15,27 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     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 :versionable, :install_options, :uninstall_options, :targetable
+  has_feature :versionable, :install_options, :uninstall_options
 
-  # Override the specificity method to return 1 if gem is not set as default provider
-  def self.specificity
-    match = default_match
-    length = match ? match.length : 0
-
-    return 1 if length == 0
-
-    super
-  end
-
-  # Define the default provider package command name when the provider is targetable.
-  # Required by Puppet::Provider::Package::Targetable::resource_or_provider_command
-
-  def self.provider_command
-    command(:gemcmd)
-  end
-
-  # Define the default provider package command as optional when the provider is targetable.
-  # Doing do defers the evaluation of provider suitability until all commands are evaluated.
-
-  has_command(:gemcmd, 'gem') do
-    is_optional
-  end
-
-  # CommandDefiner in provider.rb creates convenience execution methods that set failonfail, combine, and optionally, environment.
-  # And when a child provider defines its own command via commands() or has_command(), the provider-specific path is always returned by command().
-  # But when the convenience execution method is invoked, the last convenience method to be defined is executed.
-  # This makes invoking those convenience execution methods unsuitable for inherited providers.
-  #
-  # In this case, causing the puppet_gem provider to inherit the parent gem provider's convenience gemcmd() methods, with the wrong path.
-
-  def self.execute_gem_command(command, command_options)
-    validate_command(command)
-    cmd = [command] << command_options
-
-    execute(cmd, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}})
-  end
-
-  def self.instances(target_command = nil)
-    if target_command
-      command = target_command
-    else
-      command = provider_command
-      # The default provider package command is optional.
-      return [] unless command
-    end
-
-    gemlist(:command => command, :local => true).collect do |pkg|
-      # Track the command when the provider is targetable.
-      pkg[:command] = command
-      new(pkg)
-    end
-  end
+  commands :gemcmd => "gem"
 
   def self.gemlist(options)
-    command_options = ["list"]
+    gem_list_command = [command(:gemcmd), "list"]
 
     if options[:local]
-      command_options << "--local"
+      gem_list_command << "--local"
     else
-      command_options << "--remote"
+      gem_list_command << "--remote"
     end
     if options[:source]
-      command_options << "--source" << options[:source]
+      gem_list_command << "--source" << options[:source]
     end
     if name = options[:justme]
-      command_options << '\A' + name + '\z'
+      gem_list_command << '\A' + name + '\z'
     end
 
     begin
-      list = execute_gem_command(options[:command], command_options).lines.
+      list = execute(gem_list_command, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).lines.
         map {|set| gemsplit(set) }.
         reject {|x| x.nil? }
     rescue Puppet::ExecutionFailure => detail
@@ -122,6 +70,12 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     end
   end
 
+  def self.instances(justme = false)
+    gemlist(:local => true).collect do |hash|
+      new(hash)
+    end
+  end
+
   def insync?(is)
     return false unless is && is != :absent
 
@@ -138,27 +92,14 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     is.any? { |version| dependency.match?('', version) }
   end
 
-  def rubygem_version(command)
-    command_options = ["--version"]
-    self.class.execute_gem_command(command, command_options)
-  end
-
   def install(useversion = true)
-    command = resource_or_provider_command
-    command_options = ["install"]
-    command_options += install_options if resource[:install_options]
-
+    command = [command(:gemcmd), "install"]
+    command += install_options if resource[:install_options]
     if Puppet::Util::Platform.windows?
       version = resource[:ensure]
-      command_options << "-v" << %Q["#{version}"] if (! resource[:ensure].is_a? Symbol) and useversion
-    else
-      command_options << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
-    end
-
-    if Puppet::Util::Package.versioncmp(rubygem_version(command), '2.0.0') == -1
-      command_options << "--no-rdoc" << "--no-ri"
+      command << "-v" << %Q["#{version}"] if (! resource[:ensure].is_a? Symbol) and useversion
     else
-      command_options << "--no-document"
+      command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
     end
 
     if source = resource[:source]
@@ -171,53 +112,52 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
       case uri.scheme
       when nil
         # no URI scheme => interpret the source as a local file
-        command_options << source
+        command << source
       when /file/i
-        command_options << uri.path
+        command << uri.path
       when 'puppet'
         # we don't support puppet:// URLs (yet)
         raise Puppet::Error.new(_("puppet:// URLs are not supported as gem sources"))
       else
         # check whether it's an absolute file path to help Windows out
         if Puppet::Util.absolute_path?(source)
-          command_options << source
+          command << source
         else
           # interpret it as a gem repository
-          command_options << "--source" << "#{source}" << resource[:name]
+          command << "--source" << "#{source}" << resource[:name]
         end
       end
     else
-      command_options << resource[:name]
+      command << "--no-rdoc" << "--no-ri" << resource[:name]
     end
 
-    output = self.class.execute_gem_command(command, command_options)
-    # Apparently some gem versions don't exit non-0 on failure.
+    output = execute(command, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}})
+    # Apparently some stupid gem versions don't exit non-0 on failure
     self.fail _("Could not install: %{output}") % { output: output.chomp } if output.include?("ERROR")
   end
 
   def latest
-    command = resource_or_provider_command
-    options = { :command => command, :justme => resource[:name] }
-    options[:source] = resource[:source] unless resource[:source].nil?
-    pkg = self.class.gemlist(options)
-    pkg[:ensure][0]
+    # This always gets the latest version available.
+    gemlist_options = {:justme => resource[:name]}
+    gemlist_options.merge!({:source => resource[:source]}) unless resource[:source].nil?
+    hash = self.class.gemlist(gemlist_options)
+
+    hash[:ensure][0]
   end
 
   def query
-    command = resource_or_provider_command
-    options = { :command => command, :justme => resource[:name], :local => true }
-    pkg = self.class.gemlist(options)
-    pkg[:command] = command unless pkg.nil?
-    pkg
+    self.class.gemlist(:justme => resource[:name], :local => true)
   end
 
   def uninstall
-    command = resource_or_provider_command
-    command_options = ["uninstall"]
-    command_options << "--executables" << "--all" << resource[:name]
-    command_options += uninstall_options if resource[:uninstall_options]
-    output = self.class.execute_gem_command(command, command_options)
-    # Apparently some gem versions don't exit non-0 on failure.
+    command = [command(:gemcmd), "uninstall"]
+    command << "--executables" << "--all" << resource[:name]
+
+    command += uninstall_options if resource[:uninstall_options]
+
+    output = execute(command, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}})
+
+    # Apparently some stupid gem versions don't exit non-0 on failure
     self.fail _("Could not uninstall: %{output}") % { output: output.chomp } if output.include?("ERROR")
   end
 

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

@@ -1,10 +1,11 @@
 # Puppet package provider for Python's `pip` package management frontend.
 # <http://pip.pypa.io/>
 
-require 'puppet/provider/package_targetable'
+require 'puppet/provider/package'
 require 'puppet/util/http_proxy'
 
-Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package::Targetable do
+Puppet::Type.type(:package).provide :pip,
+  :parent => ::Puppet::Provider::Package do
 
   desc "Python packages via `pip`.
 
@@ -12,24 +13,43 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   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, :targetable
+  has_feature :installable, :uninstallable, :upgradeable, :versionable, :install_options
 
-  # Override the specificity method to return 1 if pip is not set as default provider
-  def self.specificity
-    match = default_match
-    length = match ? match.length : 0
-
-    return 1 if length == 0
-
-    super
+  # Parse lines of output from `pip freeze`, which are structured as
+  # _package_==_version_.
+  def self.parse(line)
+    if line.chomp =~ /^([^=]+)==([^=]+)$/
+      {:ensure => $2, :name => $1, :provider => name}
+    else
+      nil
+    end
   end
 
-  # Define the default provider package command name when the provider is targetable.
-  # Required by Puppet::Provider::Package::Targetable::resource_or_provider_command
+  # Return an array of structured information about every installed package
+  # that's managed by `pip` or an empty array if `pip` is not available.
+  def self.instances
+    packages = []
+    pip_cmd = self.pip_cmd
+    return [] unless pip_cmd
+    command = [pip_cmd, 'freeze']
+    if Puppet::Util::Package.versioncmp(self.pip_version, '8.1.0') >= 0 # a >= b
+      command << '--all'
+    end
+    execpipe command do |process|
+      process.collect do |line|
+        next unless options = parse(line)
+        packages << new(options)
+      end
+    end
 
-  def self.provider_command
-    # Ensure pip can upgrade pip, which usually puts pip into a new path /usr/local/bin/pip (compared to /usr/bin/pip)
-    self.cmd.map { |c| which(c) }.find { |c| c != nil }
+    # 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)
+    # Not needed when "pip freeze --all" is available
+    if Puppet::Util::Package.versioncmp(self.pip_version, '8.1.0') == -1 && version = self.pip_version
+      packages << new({:ensure => version, :name => File.basename(pip_cmd), :provider => name})
+    end
+
+    packages
   end
 
   def self.cmd
@@ -40,94 +60,104 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     end
   end
 
-  def self.pip_version(command)
-    execpipe [command, '--version'] do |process|
-      process.collect do |line|
-        return line.strip.match(/^pip (\d+\.\d+\.?\d*).*$/)[1]
-      end
-    end
+  def self.pip_cmd
+    self.cmd.map { |c| which(c) }.find { |c| c != nil }
   end
 
-  # Return an array of structured information about every installed package
-  # that's managed by `pip` or an empty array if `pip` is not available.
+  def self.pip_version
+    pip_cmd = self.pip_cmd
+    return nil unless pip_cmd
 
-  def self.instances(target_command = nil)
-    if target_command
-      command = target_command
-      self.validate_command(command)
-    else
-      command = provider_command
-    end
-
-    packages = []
-    return packages unless command
-
-    command_options = ['freeze']
-    command_version = self.pip_version(command)
-    if Puppet::Util::Package.versioncmp(command_version, '8.1.0') >= 0
-      command_options << '--all'
-    end
-
-    execpipe [command, command_options] do |process|
+    execpipe [pip_cmd, '--version'] do |process|
       process.collect do |line|
-        next unless pkg = parse(line)
-        pkg[:command] = command
-        packages << new(pkg)
+        return line.strip.match(/^pip (\d+\.\d+\.?\d*).*$/)[1]
       end
     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)
-    # Not needed when "pip freeze --all" is available.
-    if Puppet::Util::Package.versioncmp(command_version, '8.1.0') == -1
-      packages << new({:ensure => command_version, :name => File.basename(command), :provider => name, :command => command})
+  # Return structured information about a particular package or `nil` if
+  # it is not installed or `pip` itself is not available.
+  def query
+    self.class.instances.each do |provider_pip|
+      return provider_pip.properties if @resource[:name].downcase == provider_pip.name.downcase
     end
-
-    packages
+    return nil
   end
 
-  # Parse lines of output from `pip freeze`, which are structured as:
-  # _package_==_version_
-  def self.parse(line)
-    if line.chomp =~ /^([^=]+)==([^=]+)$/
-      {:ensure => $2, :name => $1, :provider => name}
+  # Use pip CLI to look up versions from PyPI repositories, honoring local pip config such as custom repositories
+  def latest
+    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
 
-  # Return structured information about a particular package or `nil`
-  # if the package is not installed or `pip` itself is not available.
-
-  def query
-    command = resource_or_provider_command
-    self.class.validate_command(command)
-
-    self.class.instances(command).each do |pkg|
-      return pkg.properties if @resource[:name].downcase == pkg.name.downcase
+  # Install a package.  The ensure parameter may specify installed,
+  # latest, a version number, or, in conjunction with the source
+  # parameter, an SCM revision.  In that case, the source parameter
+  # 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=#{
+          @resource[:name]}"
+      else
+        args << "#{@resource[:source]}#egg=#{@resource[:name]}"
+      end
+    else
+      case @resource[:ensure]
+      when String
+        args << "#{@resource[:name]}==#{@resource[:ensure]}"
+      when :latest
+        args << "--upgrade" << @resource[:name]
+      else
+        args << @resource[:name]
+      end
     end
-    return nil
+    lazy_pip(*args)
   end
 
-  # Use pip CLI to look up versions from PyPI repositories,
-  # honoring local pip config such as custom repositories.
+  # Uninstall a package.  Uninstall won't work reliably on Debian/Ubuntu
+  # unless this issue gets fixed.
+  # <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=562544>
+  def uninstall
+    lazy_pip "uninstall", "-y", "-q", @resource[:name]
+  end
 
-  def latest
-    command = resource_or_provider_command
-    self.class.validate_command(command)
+  def update
+    install
+  end
 
-    command_version = self.class.pip_version(command)
-    if Puppet::Util::Package.versioncmp(command_version, '1.5.4') == -1
-      latest_with_old_pip
+  # Execute a `pip` command.  If Puppet doesn't yet know how to do so,
+  # try to teach it and if even that fails, raise the error.
+  private
+  def lazy_pip(*args)
+    pip(*args)
+  rescue NoMethodError => e
+    # 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
-      latest_with_new_pip
+      raise e, "Could not locate command #{self.class.cmd.join(' and ')}.", e.backtrace
     end
   end
 
-  def latest_with_new_pip
-    command = resource_or_provider_command
-    self.class.validate_command(command)
+  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 [command, "install", "#{@resource[:name]}==versionplease"] do |process|
+    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: /
@@ -143,11 +173,8 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   end
 
   def latest_with_old_pip
-    command = resource_or_provider_command
-    self.class.validate_command(command)
-
     Dir.mktmpdir("puppet_pip") do |dir|
-      execpipe [command, "install", "#{@resource[:name]}", "-d", "#{dir}", "-v"] do |process|
+      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/
@@ -158,55 +185,4 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
       end
     end
   end
-
-  # Install a package.  The ensure parameter may specify installed,
-  # latest, a version number, or, in conjunction with the source
-  # parameter, an SCM revision.  In that case, the source parameter
-  # gives the fully-qualified URL to the repository.
-
-  def install
-    command = resource_or_provider_command
-    self.class.validate_command(command)
-
-    command_options = %w{install -q}
-    command_options +=  install_options if @resource[:install_options]
-    if @resource[:source]
-      if String === @resource[:ensure]
-        command_options << "#{@resource[:source]}@#{@resource[:ensure]}#egg=#{@resource[:name]}"
-      else
-        command_options << "#{@resource[:source]}#egg=#{@resource[:name]}"
-      end
-    else
-      case @resource[:ensure]
-      when String
-        command_options << "#{@resource[:name]}==#{@resource[:ensure]}"
-      when :latest
-        command_options << "--upgrade" << @resource[:name]
-      else
-        command_options << @resource[:name]
-      end
-    end
-
-    execute([command, command_options])
-  end
-
-  # Uninstall a package. Uninstall won't work reliably on Debian/Ubuntu unless this issue gets fixed.
-  # http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=562544
-
-  def uninstall
-    command = resource_or_provider_command
-    self.class.validate_command(command)
-
-    command_options = ["uninstall", "-y", "-q", @resource[:name]]
-
-    execute([command, command_options])
-  end
-
-  def update
-    install
-  end
-
-  def install_options
-    join_options(@resource[:install_options])
-  end
 end