puppet 0.25.5 → 2.6.0

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

@@ -1,88 +1,86 @@
 require 'puppet/provider/package'
 
 Puppet::Type.type(:package).provide :darwinport, :parent => Puppet::Provider::Package do
-    desc "Package management using DarwinPorts on OS X."
-
-    confine :operatingsystem => :darwin
-    commands :port => "/opt/local/bin/port"
-
-    def self.eachpkgashash
-        # list out all of the packages
-        open("| #{command(:port)} list installed") { |process|
-            regex = %r{(\S+)\s+@(\S+)\s+(\S+)}
-            fields = [:name, :ensure, :location]
-            hash = {}
-
-            # now turn each returned line into a package object
-            process.each { |line|
-                hash.clear
-
-                if match = regex.match(line)
-                    fields.zip(match.captures) { |field,value|
-                        hash[field] = value
-                    }
-
-                    hash.delete :location
-                    hash[:provider] = self.name
-                    yield hash.dup
-                else
-                    raise Puppet::DevError,
-                        "Failed to match dpkg line %s" % line
-                end
-            }
-        }
-    end
-
-    def self.instances
-        packages = []
-
-        eachpkgashash do |hash|
-            packages << new(hash)
+  desc "Package management using DarwinPorts on OS X."
+
+  confine :operatingsystem => :darwin
+  commands :port => "/opt/local/bin/port"
+
+  def self.eachpkgashash
+    # list out all of the packages
+    open("| #{command(:port)} list installed") { |process|
+      regex = %r{(\S+)\s+@(\S+)\s+(\S+)}
+      fields = [:name, :ensure, :location]
+      hash = {}
+
+      # now turn each returned line into a package object
+      process.each { |line|
+        hash.clear
+
+        if match = regex.match(line)
+          fields.zip(match.captures) { |field,value|
+            hash[field] = value
+          }
+
+          hash.delete :location
+          hash[:provider] = self.name
+          yield hash.dup
+        else
+          raise Puppet::DevError,
+            "Failed to match dpkg line #{line}"
         end
+      }
+    }
+  end
 
-        return packages
-    end
+  def self.instances
+    packages = []
 
-    def install
-        should = @resource.should(:ensure)
-
-        # Seems like you can always say 'upgrade'
-        output = port "upgrade", @resource[:name]
-        if output =~ /^Error: No port/
-            raise Puppet::ExecutionFailure, "Could not find package %s" % @resource[:name]
-        end
+    eachpkgashash do |hash|
+      packages << new(hash)
     end
 
-    def query
-        version = nil
-        self.class.eachpkgashash do |hash|
-            if hash[:name] == @resource[:name]
-                return hash
-            end
-        end
+    packages
+  end
 
-        return nil
+  def install
+    should = @resource.should(:ensure)
+
+    # Seems like you can always say 'upgrade'
+    output = port "upgrade", @resource[:name]
+    if output =~ /^Error: No port/
+      raise Puppet::ExecutionFailure, "Could not find package #{@resource[:name]}"
     end
+  end
 
-    def latest
-        info = port :search, "^#{@resource[:name]}$"
+  def query
+    version = nil
+    self.class.eachpkgashash do |hash|
+      return hash if hash[:name] == @resource[:name]
+    end
 
-        if $? != 0 or info =~ /^Error/
-            return nil
-        end
+    nil
+  end
 
-        ary = info.split(/\s+/)
-        version = ary[2].sub(/^@/, '')
+  def latest
+    info = port :search, "^#{@resource[:name]}$"
 
-        return version
+    if $CHILD_STATUS != 0 or info =~ /^Error/
+      return nil
     end
 
-    def uninstall
-        port :uninstall, @resource[:name]
-    end
+    ary = info.split(/\s+/)
+    version = ary[2].sub(/^@/, '')
 
-    def update
-        return install()
-    end
+    version
+  end
+
+  def uninstall
+    port :uninstall, @resource[:name]
+  end
+
+  def update
+    install
+  end
 end
 

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

@@ -1,130 +1,156 @@
 require 'puppet/provider/package'
 
 Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package do
-    desc "Package management via ``dpkg``.  Because this only uses ``dpkg``
-        and not ``apt``, you must specify the source of any packages you want
-        to manage."
-
-    commands :dpkg => "/usr/bin/dpkg"
-    commands :dpkg_deb => "/usr/bin/dpkg-deb"
-    commands :dpkgquery => "/usr/bin/dpkg-query"
-
-    def self.instances
-        packages = []
-
-        # list out all of the packages
-        cmd = "#{command(:dpkgquery)} -W --showformat '${Status} ${Package} ${Version}\\n'"
-        Puppet.debug "Executing '%s'" % cmd
-        execpipe(cmd) do |process|
-            # our regex for matching dpkg output
-            regex = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
-            fields = [:desired, :error, :status, :name, :ensure]
-            hash = {}
-
-            # now turn each returned line into a package object
-            process.each { |line|
-                if hash = parse_line(line)
-                    packages << new(hash)
-                end
-            }
+  desc "Package management via ``dpkg``.  Because this only uses ``dpkg``
+    and not ``apt``, you must specify the source of any packages you want
+    to manage."
+
+  has_feature :holdable
+
+  commands :dpkg => "/usr/bin/dpkg"
+  commands :dpkg_deb => "/usr/bin/dpkg-deb"
+  commands :dpkgquery => "/usr/bin/dpkg-query"
+
+  def self.instances
+    packages = []
+
+    # list out all of the packages
+    cmd = "#{command(:dpkgquery)} -W --showformat '${Status} ${Package} ${Version}\\n'"
+    Puppet.debug "Executing '#{cmd}'"
+    execpipe(cmd) do |process|
+      # our regex for matching dpkg output
+      regex = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
+      fields = [:desired, :error, :status, :name, :ensure]
+      hash = {}
+
+      # now turn each returned line into a package object
+      process.each { |line|
+        if hash = parse_line(line)
+          packages << new(hash)
         end
-
-        return packages
+      }
     end
 
-    REGEX = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
-    FIELDS = [:desired, :error, :status, :name, :ensure]
+    packages
+  end
 
-    def self.parse_line(line)
-        if match = REGEX.match(line)
-            hash = {}
+  self::REGEX = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
+  self::FIELDS = [:desired, :error, :status, :name, :ensure]
 
-            FIELDS.zip(match.captures) { |field,value|
-                hash[field] = value
-            }
+  def self.parse_line(line)
+    if match = self::REGEX.match(line)
+      hash = {}
 
-            hash[:provider] = self.name
+      self::FIELDS.zip(match.captures) { |field,value|
+        hash[field] = value
+      }
 
-            if hash[:status] == 'not-installed'
-                hash[:ensure] = :purged
-            elsif hash[:status] != "installed"
-                hash[:ensure] = :absent
-            end
-        else
-            Puppet.warning "Failed to match dpkg-query line %s" % line.inspect
-            return nil
-        end
+      hash[:provider] = self.name
 
-        return hash
+      if hash[:status] == 'not-installed'
+        hash[:ensure] = :purged
+      elsif ['config-files', 'half-installed', 'unpacked', 'half-configured'].include?(hash[:status])
+        hash[:ensure] = :absent
+      end
+      hash[:ensure] = :held if hash[:desired] == 'hold'
+    else
+      Puppet.warning "Failed to match dpkg-query line #{line.inspect}"
+      return nil
     end
 
-    def install
-        unless file = @resource[:source]
-            raise ArgumentError, "You cannot install dpkg packages without a source"
-        end
+    hash
+  end
 
-        args = []
+  def install
+    unless file = @resource[:source]
+      raise ArgumentError, "You cannot install dpkg packages without a source"
+    end
 
-        if @resource[:configfiles] == :keep
-            args << '--force-confold'
-        else
-            args << '--force-confnew'
-        end
-        args << '-i' << file
+    args = []
 
-        dpkg(*args)
-    end
+    # We always unhold when installing to remove any prior hold.
+    self.unhold
 
-    def update
-        self.install
+    if @resource[:configfiles] == :keep
+      args << '--force-confold'
+    else
+      args << '--force-confnew'
     end
+    args << '-i' << file
 
-    # Return the version from the package.
-    def latest
-        output = dpkg_deb "--show", @resource[:source]
-        matches = /^(\S+)\t(\S+)$/.match(output).captures
-        unless matches[0].match( Regexp.escape(@resource[:name]) )
-            warning "source doesn't contain named package, but %s" % matches[0]
-        end
-        matches[1]
-    end
+    dpkg(*args)
+  end
 
-    def query
-        packages = []
+  def update
+    self.install
+  end
 
-        fields = [:desired, :error, :status, :name, :ensure]
+  # Return the version from the package.
+  def latest
+    output = dpkg_deb "--show", @resource[:source]
+    matches = /^(\S+)\t(\S+)$/.match(output).captures
+    warning "source doesn't contain named package, but #{matches[0]}" unless matches[0].match( Regexp.escape(@resource[:name]) )
+    matches[1]
+  end
 
-        hash = {}
+  def query
+    packages = []
 
-        # list out our specific package
-        begin
-            output = dpkgquery("-W", "--showformat",
-                '${Status} ${Package} ${Version}\\n', @resource[:name]
-            )
-        rescue Puppet::ExecutionFailure
-            # dpkg-query exits 1 if the package is not found.
-            return {:ensure => :purged, :status => 'missing',
-                :name => @resource[:name], :error => 'ok'}
+    fields = [:desired, :error, :status, :name, :ensure]
 
-        end
+    hash = {}
 
-        hash = self.class.parse_line(output) || {:ensure => :absent, :status => 'missing', :name => @resource[:name], :error => 'ok'}
+    # list out our specific package
+    begin
 
-        if hash[:error] != "ok"
-            raise Puppet::Error.new(
-                "Package %s, version %s is in error state: %s" %
-                    [hash[:name], hash[:ensure], hash[:error]]
-            )
-        end
+            output = dpkgquery(
+        "-W", "--showformat",
+        
+        '${Status} ${Package} ${Version}\\n', @resource[:name]
+      )
+    rescue Puppet::ExecutionFailure
+      # dpkg-query exits 1 if the package is not found.
+      return {:ensure => :purged, :status => 'missing', :name => @resource[:name], :error => 'ok'}
 
-        return hash
     end
 
-    def uninstall
-        dpkg "-r", @resource[:name]
+    hash = self.class.parse_line(output) || {:ensure => :absent, :status => 'missing', :name => @resource[:name], :error => 'ok'}
+
+    if hash[:error] != "ok"
+      raise Puppet::Error.new(
+        "Package #{hash[:name]}, version #{hash[:ensure]} is in error state: #{hash[:error]}"
+      )
     end
 
-    def purge
-        dpkg "--purge", @resource[:name]
+    hash
+  end
+
+  def uninstall
+    dpkg "-r", @resource[:name]
+  end
+
+  def purge
+    dpkg "--purge", @resource[:name]
+  end
+
+  def hold
+    self.install
+    begin
+      Tempfile.open('puppet_dpkg_set_selection') { |tmpfile|
+        tmpfile.write("#{@resource[:name]} hold\n")
+        tmpfile.flush
+        execute([:dpkg, "--set-selections"], :stdinfile => tmpfile.path.to_s)
+      }
+    end
+  end
+
+  def unhold
+    begin
+      Tempfile.open('puppet_dpkg_set_selection') { |tmpfile|
+        tmpfile.write("#{@resource[:name]} install\n")
+        tmpfile.flush
+        execute([:dpkg, "--set-selections"], :stdinfile => tmpfile.path.to_s)
+      }
     end
+  end
 end

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

@@ -1,84 +1,82 @@
 Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
-    # Provide sorting functionality
-    include Puppet::Util::Package
-
-    desc "Package management via ``fink``."
+  # Provide sorting functionality
+  include Puppet::Util::Package
+
+  desc "Package management via ``fink``."
+
+  commands :fink => "/sw/bin/fink"
+  commands :aptget => "/sw/bin/apt-get"
+  commands :aptcache => "/sw/bin/apt-cache"
+  commands :dpkgquery => "/sw/bin/dpkg-query"
+
+  has_feature :versionable
+
+  # A derivative of DPKG; this is how most people actually manage
+  # Debian boxes, and the only thing that differs is that it can
+  # install packages from remote sites.
+
+  def finkcmd(*args)
+    fink(*args)
+  end
+
+  # Install a package using 'apt-get'.  This function needs to support
+  # installing a specific version.
+  def install
+    self.run_preseed if @resource[:responsefile]
+    should = @resource.should(:ensure)
+
+    str = @resource[:name]
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      str += "=#{should}"
+    end
+    cmd = %w{-b -q -y}
 
-    commands :fink => "/sw/bin/fink"
-    commands :aptget => "/sw/bin/apt-get"
-    commands :aptcache => "/sw/bin/apt-cache"
-    commands :dpkgquery => "/sw/bin/dpkg-query"
+    keep = ""
 
-    has_feature :versionable
+    cmd << :install << str
 
-    # A derivative of DPKG; this is how most people actually manage
-    # Debian boxes, and the only thing that differs is that it can
-    # install packages from remote sites.
+    finkcmd(cmd)
+  end
 
-    def finkcmd(*args)
-        fink(*args)
-    end
+  # What's the latest package version available?
+  def latest
+    output = aptcache :policy,  @resource[:name]
 
-    # Install a package using 'apt-get'.  This function needs to support
-    # installing a specific version.
-    def install
-        if @resource[:responsefile]
-            self.run_preseed
-        end
-        should = @resource.should(:ensure)
-
-        str = @resource[:name]
-        case should
-        when true, false, Symbol
-            # pass
+    if output =~ /Candidate:\s+(\S+)\s/
+      return $1
         else
-            # Add the package version
-            str += "=%s" % should
+      self.err "Could not find latest version"
+      return nil
+        end
         end
-        cmd = %w{-b -q -y}
-
-        keep = ""
-
-        cmd << :install << str
 
-        finkcmd(cmd)
-    end
+  #
+  # preseeds answers to dpkg-set-selection from the "responsefile"
+  #
+  def run_preseed
+    if response = @resource[:responsefile] and FileTest.exists?(response)
+      self.info("Preseeding #{response} to debconf-set-selections")
 
-    # What's the latest package version available?
-    def latest
-        output = aptcache :policy,  @resource[:name]
-
-        if output =~ /Candidate:\s+(\S+)\s/
-            return $1
-                else
-            self.err "Could not find latest version"
-            return nil
-                end
-                end
-
-    #
-    # preseeds answers to dpkg-set-selection from the "responsefile"
-    #
-    def run_preseed
-        if response = @resource[:responsefile] and FileTest.exists?(response)
-            self.info("Preseeding %s to debconf-set-selections" % response)
-
-            preseed response
-        else
-            self.info "No responsefile specified or non existant, not preseeding anything"
-        end
+      preseed response
+    else
+      self.info "No responsefile specified or non existant, not preseeding anything"
     end
+  end
 
-    def update
-        self.install
-    end
+  def update
+    self.install
+  end
 
-    def uninstall
-        finkcmd "-y", "-q", :remove, @model[:name]
-    end
+  def uninstall
+    finkcmd "-y", "-q", :remove, @model[:name]
+  end
 
-    def purge
-        aptget '-y', '-q', 'remove', '--purge', @resource[:name]
-     end
+  def purge
+    aptget '-y', '-q', 'remove', '--purge', @resource[:name]
+  end
 end