puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,111 @@
+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"
+
+  # disable common apt helpers to allow non-interactive package installs
+  ENV['APT_LISTBUGS_FRONTEND'] = "none"
+  ENV['APT_LISTCHANGES_FRONTEND'] = "none"
+
+  # 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"
+        @@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
+
+    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
+
+    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
+
+    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/vendor/puppet/provider/package/aptitude.rb

@@ -0,0 +1,29 @@
+Puppet::Type.type(:package).provide :aptitude, :parent => :apt, :source => :dpkg do
+  desc "Package management via `aptitude`."
+
+  has_feature :versionable
+
+  commands :aptitude => "/usr/bin/aptitude"
+  commands :aptcache => "/usr/bin/apt-cache"
+
+  ENV['DEBIAN_FRONTEND'] = "noninteractive"
+
+  def aptget(*args)
+    args.flatten!
+    # Apparently aptitude hasn't always supported a -q flag.
+    args.delete("-q") if args.include?("-q")
+    args.delete("--force-yes") if args.include?("--force-yes")
+    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 #{self.name}"
+      )
+    end
+  end
+
+  def purge
+    aptitude '-y', 'purge', @resource[:name]
+  end
+end

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

@@ -0,0 +1,83 @@
+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
+  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}
+
+    cmd << 'install' << str
+
+    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 '#{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 uninstall
+    aptget "-y", "-q", 'remove', @resource[:name]
+  end
+
+  def purge
+    aptget '-y', '-q', 'remove', '--purge', @resource[:name]
+  end
+end

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

@@ -0,0 +1,111 @@
+# 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"
+  pkgget = "/opt/csw/bin/pkg-get" if FileTest.executable?("/opt/csw/bin/pkg-get")
+
+  confine :operatingsystem => :solaris
+
+  commands :pkgget => pkgget
+
+  def pkgget_with_cat(*args)
+    Puppet::Util::Execution::withenv(:PAGER => "/usr/bin/cat") { pkgget(*args) }
+  end
+
+  def self.extended(mod)
+    unless command(:pkgget) != "pkg-get"
+      raise Puppet::Error,
+        "The pkg-get command is missing; blastwave packaging unavailable"
+    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
+
+  def self.instances(hash = {})
+    blastlist(hash).collect do |bhash|
+      bhash.delete(:avail)
+      new(bhash)
+    end
+  end
+
+  # Turn our blastwave listing into a bunch of hashes.
+  def self.blastlist(hash)
+    command = ["-c"]
+
+    command << hash[:justme] if hash[:justme]
+
+    output = Puppet::Util::Execution::withenv(:PAGER => "/usr/bin/cat") { pkgget command }
+
+    list = output.split("\n").collect do |line|
+      next if line =~ /^#/
+      next if line =~ /^WARNING/
+      next if line =~ /localrev\s+remoterev/
+
+      blastsplit(line)
+    end.reject { |h| h.nil? }
+
+    if hash[:justme]
+      return list[0]
+    else
+      list.reject! { |h|
+        h[:ensure] == :absent
+      }
+      return list
+    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
+  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
+
+  # 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
+end

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

@@ -0,0 +1,155 @@
+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."
+
+  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 { |line|
+        if hash = parse_line(line)
+          packages << new(hash)
+        end
+      }
+    end
+
+    packages
+  end
+
+  self::REGEX = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
+  self::FIELDS = [:desired, :error, :status, :name, :ensure]
+
+  def self.parse_line(line)
+    if match = self::REGEX.match(line)
+      hash = {}
+
+      self::FIELDS.zip(match.captures) { |field,value|
+        hash[field] = value
+      }
+
+      hash[:provider] = self.name
+
+      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
+
+    hash
+  end
+
+  def install
+    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.
+    self.unhold
+
+    if @resource[:configfiles] == :keep
+      args << '--force-confold'
+    else
+      args << '--force-confnew'
+    end
+    args << '-i' << file
+
+    dpkg(*args)
+  end
+
+  def update
+    self.install
+  end
+
+  # 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
+
+  def query
+    packages = []
+
+    fields = [:desired, :error, :status, :name, :ensure]
+
+    hash = {}
+
+    # 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'}
+    end
+
+    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
+
+    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/vendor/puppet/provider/package/fink.rb

@@ -0,0 +1,81 @@
+Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
+  # 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}
+
+    keep = ""
+
+    cmd << :install << str
+
+    finkcmd(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.exists?(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 update
+    self.install
+  end
+
+  def uninstall
+    finkcmd "-y", "-q", :remove, @model[:name]
+  end
+
+  def purge
+    aptget '-y', '-q', 'remove', '--purge', @resource[:name]
+  end
+end

data/lib/vendor/puppet/provider/package/freebsd.rb

@@ -0,0 +1,49 @@
+Puppet::Type.type(:package).provide :freebsd, :parent => :openbsd do
+  desc "The specific form of package management on FreeBSD.  This is an
+    extremely quirky packaging system, in that it freely mixes between
+    ports and packages.  Apparently all of the tools are written in Ruby,
+    so there are plans to rewrite this support to directly use those
+    libraries."
+
+  commands :pkginfo => "/usr/sbin/pkg_info",
+    :pkgadd => "/usr/sbin/pkg_add",
+    :pkgdelete => "/usr/sbin/pkg_delete"
+
+  confine :operatingsystem => :freebsd
+
+  def self.listcmd
+    command(:pkginfo)
+  end
+
+  def install
+    should = @resource.should(:ensure)
+
+    if @resource[:source] =~ /\/$/
+      if @resource[:source] =~ /^(ftp|https?):/
+        Puppet::Util::Execution::withenv :PACKAGESITE => @resource[:source] do
+          pkgadd "-r", @resource[:name]
+        end
+      else
+        Puppet::Util::Execution::withenv :PKG_PATH => @resource[:source] do
+          pkgadd @resource[:name]
+        end
+      end
+    else
+      Puppet.warning "source is defined but does not have trailing slash, ignoring #{@resource[:source]}" if @resource[:source]
+      pkgadd "-r", @resource[:name]
+    end
+  end
+
+  def query
+    self.class.instances.each do |provider|
+      if provider.name == @resource.name
+        return provider.properties
+      end
+    end
+    nil
+  end
+
+  def uninstall
+    pkgdelete "#{@resource[:name]}-#{@resource.should(:ensure)}"
+  end
+end