puppet 0.25.5 → 2.6.0

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

@@ -1,117 +1,108 @@
 Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
-    # Provide sorting functionality
-    include Puppet::Util::Package
-
-    desc "Package management via ``apt-get``."
-
-    has_feature :versionable
-
-    commands :aptget => "/usr/bin/apt-get"
-    commands :aptcache => "/usr/bin/apt-cache"
-    commands :preseed => "/usr/bin/debconf-set-selections"
-
-    defaultfor :operatingsystem => [:debian, :ubuntu]
-
-    ENV['DEBIAN_FRONTEND'] = "noninteractive"
-
-    # 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 checkforcdrom
-        unless defined? @@checkedforcdrom
-            if FileTest.exists? "/etc/apt/sources.list"
-                if File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/
-                    @@checkedforcdrom = true
-                else
-                    @@checkedforcdrom = false
-                end
-            else
-                # This is basically a pathalogical case, but we'll just
-                # ignore it
-                @@checkedforcdrom = false
-            end
-        end
-
-        if @@checkedforcdrom and @resource[:allowcdrom] != :true
-            raise Puppet::Error,
-                "/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure."
-        end
-    end
+  # Provide sorting functionality
+  include Puppet::Util::Package
 
-    # 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[:ensure]
-
-        checkforcdrom()
-        cmd = %w{-q -y}
-
-        keep = ""
-        if config = @resource[:configfiles]
-            if config == :keep
-                cmd << "-o" << 'DPkg::Options::=--force-confold'
-            else
-                cmd << "-o" << 'DPkg::Options::=--force-confnew'
-            end
-        end
-
-        str = @resource[:name]
-        case should
-        when true, false, Symbol
-            # pass
-        else
-            # Add the package version
-            str += "=%s" % should
-        end
-
-        cmd << :install << str
-
-        aptget(*cmd)
-    end
+  desc "Package management via ``apt-get``."
+
+  has_feature :versionable
+
+  commands :aptget => "/usr/bin/apt-get"
+  commands :aptcache => "/usr/bin/apt-cache"
+  commands :preseed => "/usr/bin/debconf-set-selections"
+
+  defaultfor :operatingsystem => [:debian, :ubuntu]
+
+  ENV['DEBIAN_FRONTEND'] = "noninteractive"
 
-    # What's the latest package version available?
-    def latest
-        output = aptcache :policy,  @resource[:name]
+  # 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.
 
-        if output =~ /Candidate:\s+(\S+)\s/
-            return $1
-        else
-            self.err "Could not find latest version"
-            return nil
-        end
+  def checkforcdrom
+    unless defined?(@@checkedforcdrom)
+      if FileTest.exists? "/etc/apt/sources.list"
+        @@checkedforcdrom = !!(File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/)
+      else
+        # This is basically a pathalogical case, but we'll just
+        # ignore it
+        @@checkedforcdrom = false
+      end
     end
 
-    #
-    # preseeds answers to dpkg-set-selection from the "responsefile"
-    #
-    def run_preseed
-        if response = @resource[:responsefile] and FileTest.exist?(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
+    if @@checkedforcdrom and @resource[:allowcdrom] != :true
+      raise Puppet::Error,
+        "/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure."
+    end
+  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[:ensure]
+
+    checkforcdrom
+    cmd = %w{-q -y}
+
+    keep = ""
+    if config = @resource[:configfiles]
+      if config == :keep
+        cmd << "-o" << 'DPkg::Options::=--force-confold'
+      else
+        cmd << "-o" << 'DPkg::Options::=--force-confnew'
+      end
     end
 
-    def uninstall
-        if @resource[:responsefile]
-            self.run_preseed
-        end
-        aptget "-y", "-q", :remove, @resource[:name]
+    str = @resource[:name]
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version and --force-yes option
+      str += "=#{should}"
+      cmd << "--force-yes"
     end
 
-    def purge
-        if @resource[:responsefile]
-            self.run_preseed
-        end
-        aptget '-y', '-q', :remove, '--purge', @resource[:name]
-        # workaround a "bug" in apt, that already removed packages are not purged
-        super
+    cmd << :install << str
+
+    aptget(*cmd)
+  end
+
+  # 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.exist?(response)
+      self.info("Preseeding #{response} to debconf-set-selections")
+
+      preseed response
+    else
+      self.info "No responsefile specified or non existant, not preseeding anything"
     end
+  end
+
+  def uninstall
+    self.run_preseed if @resource[:responsefile]
+    aptget "-y", "-q", :remove, @resource[:name]
+  end
+
+  def purge
+    self.run_preseed if @resource[:responsefile]
+    aptget '-y', '-q', :remove, '--purge', @resource[:name]
+    # workaround a "bug" in apt, that already removed packages are not purged
+    super
+  end
 end
 

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

@@ -1,31 +1,29 @@
 Puppet::Type.type(:package).provide :aptitude, :parent => :apt, :source => :dpkg do
-    desc "Package management via ``aptitude``."
+  desc "Package management via ``aptitude``."
 
-    has_feature :versionable
+  has_feature :versionable
 
-    commands :aptitude => "/usr/bin/aptitude"
-    commands :aptcache => "/usr/bin/apt-cache"
+  commands :aptitude => "/usr/bin/aptitude"
+  commands :aptcache => "/usr/bin/apt-cache"
 
-    ENV['DEBIAN_FRONTEND'] = "noninteractive"
+  ENV['DEBIAN_FRONTEND'] = "noninteractive"
 
-    def aptget(*args)
-        args.flatten!
-        # Apparently aptitude hasn't always supported a -q flag.
-        if args.include?("-q")
-            args.delete("-q")
-        end
-        output = aptitude(*args)
+  def aptget(*args)
+    args.flatten!
+    # Apparently aptitude hasn't always supported a -q flag.
+    args.delete("-q") if args.include?("-q")
+    output = aptitude(*args)
 
-        # Yay, stupid aptitude doesn't throw an error when the package is missing.
-        if args.include?(:install) and output =~ /Couldn't find any package/
-            raise Puppet::Error.new(
-                "Could not find package %s" % self.name
-            )
-        end
+    # Yay, stupid aptitude doesn't throw an error when the package is missing.
+    if args.include?(:install) and output =~ /Couldn't find any package/
+      raise Puppet::Error.new(
+        "Could not find package #{self.name}"
+      )
     end
+  end
 
-    def purge
-        aptitude '-y', 'purge', @resource[:name]
-    end
+  def purge
+    aptitude '-y', 'purge', @resource[:name]
+  end
 end
 

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

@@ -1,86 +1,84 @@
 Puppet::Type.type(:package).provide :aptrpm, :parent => :rpm, :source => :rpm do
-    # Provide sorting functionality
-    include Puppet::Util::Package
-
-    desc "Package management via ``apt-get`` ported to ``rpm``."
-
-    has_feature :versionable
-
-    commands :aptget => "apt-get"
-    commands :aptcache => "apt-cache"
-    commands :rpm => "rpm"
-
-    if command('rpm')
-        confine :true => begin
-                rpm('-ql', 'rpm')
-           rescue Puppet::ExecutionFailure
-               false
-           else
-               true
-           end
+  # Provide sorting functionality
+  include Puppet::Util::Package
+
+  desc "Package management via ``apt-get`` ported to ``rpm``."
+
+  has_feature :versionable
+
+  commands :aptget => "apt-get"
+  commands :aptcache => "apt-cache"
+  commands :rpm => "rpm"
+
+  if command('rpm')
+    confine :true => begin
+      rpm('-ql', 'rpm')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  # Install a package using 'apt-get'.  This function needs to support
+  # installing a specific version.
+  def install
+    should = @resource.should(:ensure)
+
+    str = @resource[:name]
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      str += "=#{should}"
     end
+    cmd = %w{-q -y}
 
-    # Install a package using 'apt-get'.  This function needs to support
-    # installing a specific version.
-    def install
-        should = @resource.should(:ensure)
+    cmd << 'install' << str
 
-        str = @resource[:name]
-        case should
-        when true, false, Symbol
-            # pass
-        else
-            # Add the package version
-            str += "=%s" % should
-        end
-        cmd = %w{-q -y}
+    aptget(*cmd)
+  end
 
-        cmd << 'install' << str
+  # What's the latest package version available?
+  def latest
+    output = aptcache :showpkg,  @resource[:name]
 
-        aptget(*cmd)
-    end
-
-    # What's the latest package version available?
-    def latest
-        output = aptcache :showpkg,  @resource[:name]
-
-        if output =~ /Versions:\s*\n((\n|.)+)^$/
-            versions = $1
-            available_versions = versions.split(/\n/).collect { |version|
-                if version =~ /^([^\(]+)\(/
-                    $1
-                else
-                    self.warning "Could not match version '%s'" % version
-                    nil
-                end
-            }.reject { |vers| vers.nil? }.sort { |a,b|
-                versioncmp(a,b)
-            }
-
-            if available_versions.length == 0
-                self.debug "No latest version"
-                if Puppet[:debug]
-                    print output
-                end
-            end
-
-            # Get the latest and greatest version number
-            return available_versions.pop
+    if output =~ /Versions:\s*\n((\n|.)+)^$/
+      versions = $1
+      available_versions = versions.split(/\n/).collect { |version|
+        if version =~ /^([^\(]+)\(/
+          $1
         else
-            self.err "Could not match string"
+          self.warning "Could not match version '#{version}'"
+          nil
         end
+      }.reject { |vers| vers.nil? }.sort { |a,b|
+        versioncmp(a,b)
+      }
+
+      if available_versions.length == 0
+        self.debug "No latest version"
+        print output if Puppet[:debug]
+      end
+
+      # Get the latest and greatest version number
+      return available_versions.pop
+    else
+      self.err "Could not match string"
     end
+  end
 
-    def update
-        self.install
-    end
+  def update
+    self.install
+  end
 
-    def uninstall
-        aptget "-y", "-q", 'remove', @resource[:name]
-    end
+  def uninstall
+    aptget "-y", "-q", 'remove', @resource[:name]
+  end
 
-    def purge
-        aptget '-y', '-q', 'remove', '--purge', @resource[:name]
-    end
+  def purge
+    aptget '-y', '-q', 'remove', '--purge', @resource[:name]
+  end
 end
 

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

@@ -1,118 +1,112 @@
 # Packaging using Blastwave's pkg-get program.
 Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun do
-    desc "Package management using Blastwave.org's ``pkg-get`` command on Solaris."
-    pkgget = "pkg-get"
-    if FileTest.executable?("/opt/csw/bin/pkg-get")
-        pkgget = "/opt/csw/bin/pkg-get"
-    end
-
-    confine :operatingsystem => :solaris
+  desc "Package management using Blastwave.org's ``pkg-get`` command on Solaris."
+  pkgget = "pkg-get"
+  pkgget = "/opt/csw/bin/pkg-get" if FileTest.executable?("/opt/csw/bin/pkg-get")
 
-    commands :pkgget => pkgget
+  confine :operatingsystem => :solaris
 
-    def pkgget_with_cat(*args)
-        Puppet::Util::Execution::withenv(:PAGER => "/usr/bin/cat") { pkgget(*args) }
-    end
+  commands :pkgget => pkgget
 
-    def self.extended(mod)
-        unless command(:pkgget) != "pkg-get"
-            raise Puppet::Error,
-                "The pkg-get command is missing; blastwave packaging unavailable"
-        end
+  def pkgget_with_cat(*args)
+    Puppet::Util::Execution::withenv(:PAGER => "/usr/bin/cat") { pkgget(*args) }
+  end
 
-        unless FileTest.exists?("/var/pkg-get/admin")
-            Puppet.notice "It is highly recommended you create '/var/pkg-get/admin'."
-            Puppet.notice "See /var/pkg-get/admin-fullauto"
-        end
+  def self.extended(mod)
+    unless command(:pkgget) != "pkg-get"
+      raise Puppet::Error,
+        "The pkg-get command is missing; blastwave packaging unavailable"
     end
 
-    def self.instances(hash = {})
-        blastlist(hash).collect do |bhash|
-            bhash.delete(:avail)
-            new(bhash)
-        end
+    unless FileTest.exists?("/var/pkg-get/admin")
+      Puppet.notice "It is highly recommended you create '/var/pkg-get/admin'."
+      Puppet.notice "See /var/pkg-get/admin-fullauto"
     end
+  end
 
-    # Turn our blastwave listing into a bunch of hashes.
-    def self.blastlist(hash)
-        command = ["-c"]
+  def self.instances(hash = {})
+    blastlist(hash).collect do |bhash|
+      bhash.delete(:avail)
+      new(bhash)
+    end
+  end
 
-        if hash[:justme]
-            command << hash[:justme]
-        end
+  # Turn our blastwave listing into a bunch of hashes.
+  def self.blastlist(hash)
+    command = ["-c"]
 
-        output = Puppet::Util::Execution::withenv(:PAGER => "/usr/bin/cat") { pkgget command }
+    command << hash[:justme] if hash[:justme]
 
-        list = output.split("\n").collect do |line|
-            next if line =~ /^#/
-            next if line =~ /^WARNING/
-            next if line =~ /localrev\s+remoterev/
+    output = Puppet::Util::Execution::withenv(:PAGER => "/usr/bin/cat") { pkgget command }
 
-            blastsplit(line)
-        end.reject { |h| h.nil? }
+    list = output.split("\n").collect do |line|
+      next if line =~ /^#/
+      next if line =~ /^WARNING/
+      next if line =~ /localrev\s+remoterev/
 
-        if hash[:justme]
-            return list[0]
-        else
-            list.reject! { |h|
-                h[:ensure] == :absent
-            }
-            return list
-        end
+      blastsplit(line)
+    end.reject { |h| h.nil? }
 
+    if hash[:justme]
+      return list[0]
+    else
+      list.reject! { |h|
+        h[:ensure] == :absent
+      }
+      return list
     end
 
-    # Split the different lines into hashes.
-    def self.blastsplit(line)
-        if line =~ /\s*(\S+)\s+((\[Not installed\])|(\S+))\s+(\S+)/
-            hash = {}
-            hash[:name] = $1
-            hash[:ensure] = if $2 == "[Not installed]"
-                :absent
-            else
-                $2
-            end
-            hash[:avail] = $5
-
-            if hash[:avail] == "SAME"
-                hash[:avail] = hash[:ensure]
-            end
-
-            # Use the name method, so it works with subclasses.
-            hash[:provider] = self.name
-
-            return hash
-        else
-            Puppet.warning "Cannot match %s" % line
-            return nil
-        end
+  end
+
+  # Split the different lines into hashes.
+  def self.blastsplit(line)
+    if line =~ /\s*(\S+)\s+((\[Not installed\])|(\S+))\s+(\S+)/
+      hash = {}
+      hash[:name] = $1
+      hash[:ensure] = if $2 == "[Not installed]"
+        :absent
+      else
+        $2
+      end
+      hash[:avail] = $5
+
+      hash[:avail] = hash[:ensure] if hash[:avail] == "SAME"
+
+      # Use the name method, so it works with subclasses.
+      hash[:provider] = self.name
+
+      return hash
+    else
+      Puppet.warning "Cannot match #{line}"
+      return nil
     end
-
-    def install
-        pkgget_with_cat "-f", :install, @resource[:name]
+  end
+
+  def install
+    pkgget_with_cat "-f", :install, @resource[:name]
+  end
+
+  # Retrieve the version from the current package file.
+  def latest
+    hash = self.class.blastlist(:justme => @resource[:name])
+    hash[:avail]
+  end
+
+  def query
+    if hash = self.class.blastlist(:justme => @resource[:name])
+      hash
+    else
+      {:ensure => :absent}
     end
+  end
 
-    # Retrieve the version from the current package file.
-    def latest
-        hash = self.class.blastlist(:justme => @resource[:name])
-        hash[:avail]
-    end
+  # Remove the old package, and install the new one
+  def update
+    pkgget_with_cat "-f", :upgrade, @resource[:name]
+  end
 
-    def query
-        if hash = self.class.blastlist(:justme => @resource[:name])
-            hash
-        else
-            {:ensure => :absent}
-        end
-    end
-
-    # Remove the old package, and install the new one
-    def update
-        pkgget_with_cat "-f", :upgrade, @resource[:name]
-    end
-
-    def uninstall
-        pkgget_with_cat "-f", :remove, @resource[:name]
-    end
+  def uninstall
+    pkgget_with_cat "-f", :remove, @resource[:name]
+  end
 end