puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,94 @@
+Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :freebsd do
+  desc "Support for FreeBSD's ports.  Note that this, too, mixes packages and ports."
+
+  commands :portupgrade => "/usr/local/sbin/portupgrade",
+    :portversion => "/usr/local/sbin/portversion",
+    :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
+
+  def install
+    # -N: install if the package is missing, otherwise upgrade
+    # -M: yes, we're a batch, so don't ask any questions
+    cmd = %w{-N -M BATCH=yes} << @resource[:name]
+
+    output = portupgrade(*cmd)
+    if output =~ /\*\* No such /
+      raise Puppet::ExecutionFailure, "Could not find package #{@resource[:name]}"
+    end
+  end
+
+  # If there are multiple packages, we only use the last one
+  def latest
+    cmd = ["-v", @resource[:name]]
+
+    begin
+      output = portversion(*cmd)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output)
+    end
+    line = output.split("\n").pop
+
+    unless line =~ /^(\S+)\s+(\S)\s+(.+)$/
+      # There's no "latest" version, so just return a placeholder
+      return :latest
+    end
+
+    pkgstuff = $1
+    match = $2
+    info = $3
+
+    unless pkgstuff =~ /^(\S+)-([^-\s]+)$/
+      raise Puppet::Error,
+        "Could not match package info '#{pkgstuff}'"
+    end
+
+    name, version = $1, $2
+
+    if match == "=" or match == ">"
+      # we're up to date or more recent
+      return version
+    end
+
+    # Else, we need to be updated; we need to pull out the new version
+
+    unless info =~ /\((\w+) has (.+)\)/
+      raise Puppet::Error,
+        "Could not match version info '#{info}'"
+    end
+
+    source, newversion = $1, $2
+
+    debug "Newer version in #{source}"
+    newversion
+  end
+
+  def query
+    # support portorigin_glob such as "mail/postfix"
+    name = self.name
+    if name =~ /\//
+      name = self.name.split(/\//).slice(1)
+    end
+    self.class.instances.each do |instance|
+      if instance.name == name
+        return instance.properties
+      end
+    end
+
+    nil
+  end
+
+  def uninstall
+    portuninstall @resource[:name]
+  end
+
+  def update
+    install
+  end
+end

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

@@ -0,0 +1,241 @@
+# Whole new package, so include pack stuff
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::Package do
+  include Puppet::Util::Execution
+
+  desc "Support for FreeBSD's ports using the portupgrade ports management software.
+    Use the port's full origin as the resource name. eg (ports-mgmt/portupgrade)
+    for the portupgrade port."
+
+  ## has_features is usually autodetected based on defs below.
+  # has_features :installable, :uninstallable, :upgradeable
+
+  commands :portupgrade   => "/usr/local/sbin/portupgrade",
+  :portinstall   => "/usr/local/sbin/portinstall",
+  :portversion   => "/usr/local/sbin/portversion",
+  :portuninstall => "/usr/local/sbin/pkg_deinstall",
+  :portinfo      => "/usr/sbin/pkg_info"
+
+  ## Activate this only once approved by someone important.
+  # defaultfor :operatingsystem => :freebsd
+
+  # Remove unwanted environment variables.
+  %w{INTERACTIVE UNAME}.each do |var|
+    if ENV.include?(var)
+      ENV.delete(var)
+    end
+  end
+
+  ######## instances sub command (builds the installed packages list)
+
+  def self.instances
+    Puppet.debug "portupgrade.rb Building packages list from installed ports"
+
+    # regex to match output from pkg_info
+    regex = %r{^(\S+)-([^-\s]+):(\S+)$}
+    # Corresponding field names
+    fields = [:portname, :ensure, :portorigin]
+    # define Temporary hash used, packages array of hashes
+    hash = Hash.new
+    packages = []
+
+    # exec command
+    cmdline = ["-aoQ"]
+    begin
+      output = portinfo(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output)
+      return nil
+    end
+
+    # split output and match it and populate temp hash
+    output.split("\n").each { |data|
+      # reset hash to nil for each line
+      hash.clear
+      if match = regex.match(data)
+        # Output matched regex
+        fields.zip(match.captures) { |field, value|
+          hash[field] = value
+        }
+
+        # populate the actual :name field from the :portorigin
+        # Set :provider to this object name
+        hash[:name] = hash[:portorigin]
+        hash[:provider] = self.name
+
+        # Add to the full packages listing
+        packages << new(hash)
+      else
+        # unrecognised output from pkg_info
+        Puppet.debug "portupgrade.Instances() - unable to match output: #{data}"
+      end
+    }
+
+    # return the packages array of hashes
+    return packages
+  end
+
+  ######## Installation sub command
+
+  def install
+    Puppet.debug "portupgrade.install() - Installation call on #{@resource[:name]}"
+    # -M: yes, we're a batch, so don't ask any questions
+    cmdline = ["-M BATCH=yes", @resource[:name]]
+
+    # FIXME: it's possible that portinstall prompts for data so locks up.
+    begin
+      output = portinstall(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output)
+    end
+
+    if output =~ /\*\* No such /
+      raise Puppet::ExecutionFailure, "Could not find package #{@resource[:name]}"
+    end
+
+    # No return code required, so do nil to be clean
+    return nil
+  end
+
+  ######## Latest subcommand (returns the latest version available, or current version if installed is latest)
+
+  def latest
+    Puppet.debug "portupgrade.latest() - Latest check called on #{@resource[:name]}"
+    # search for latest version available, or return current version.
+    # cmdline = "portversion -v <portorigin>", returns "<portname> <code> <stuff>"
+    # or "** No matching package found: <portname>"
+    cmdline = ["-v", @resource[:name]]
+
+    begin
+      output = portversion(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output)
+    end
+
+    # Check: output format.
+    if output =~ /^\S+-([^-\s]+)\s+(\S)\s+(.*)/
+      installedversion = $1
+      comparison = $2
+      otherdata = $3
+
+      # Only return a new version number when it's clear that there is a new version
+      # all others return the current version so no unexpected 'upgrades' occur.
+      case comparison
+      when "=", ">"
+        Puppet.debug "portupgrade.latest() - Installed package is latest (#{installedversion})"
+        return installedversion
+      when "<"
+        # "portpkg-1.7_5 < needs updating (port has 1.14)"
+        # "portpkg-1.7_5 < needs updating (port has 1.14) (=> 'newport/pkg')
+        if otherdata =~ /\(port has (\S+)\)/
+          newversion = $1
+          Puppet.debug "portupgrade.latest() - Installed version needs updating to (#{newversion})"
+          return newversion
+        else
+          Puppet.debug "portupgrade.latest() - Unable to determine new version from (#{otherdata})"
+          return installedversion
+        end
+      when "?", "!", "#"
+        Puppet.debug "portupgrade.latest() - Comparison Error reported from portversion (#{output})"
+        return installedversion
+      else
+        Puppet.debug "portupgrade.latest() - Unknown code from portversion output (#{output})"
+        return installedversion
+      end
+
+    else
+      # error: output not parsed correctly, error out with nil.
+      # Seriously - this section should never be called in a perfect world.
+      # as verification that the port is installed has already happened in query.
+      if output =~ /^\*\* No matching package /
+        raise Puppet::ExecutionFailure, "Could not find package #{@resource[:name]}"
+      else
+        # Any other error (dump output to log)
+        raise Puppet::ExecutionFailure, "Unexpected output from portversion: #{output}"
+      end
+
+      # Just in case we still are running, return nil
+      return nil
+    end
+
+    # At this point normal operation has finished and we shouldn't have been called.
+    # Error out and let the admin deal with it.
+    raise Puppet::Error, "portversion.latest() - fatal error with portversion: #{output}"
+    return nil
+  end
+
+  ###### Query subcommand - return a hash of details if exists, or nil if it doesn't.
+  # Used to make sure the package is installed
+
+  def query
+    Puppet.debug "portupgrade.query() - Called on #{@resource[:name]}"
+
+    cmdline = ["-qO", @resource[:name]]
+    begin
+      output = portinfo(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output)
+    end
+
+    # Check: if output isn't in the right format, return nil
+    if output =~ /^(\S+)-([^-\s]+)/
+      # Fill in the details
+      hash = Hash.new
+      hash[:portorigin] = self.name
+      hash[:portname]   = $1
+      hash[:ensure]     = $2
+
+      # If more details are required, then we can do another pkg_info
+      # query here and parse out that output and add to the hash
+      # return the hash to the caller
+      return hash
+    else
+      Puppet.debug "portupgrade.query() - package (#{@resource[:name]}) not installed"
+      return nil
+    end
+  end
+
+  ####### Uninstall command
+
+  def uninstall
+    Puppet.debug "portupgrade.uninstall() - called on #{@resource[:name]}"
+    # Get full package name from port origin to uninstall with
+    cmdline = ["-qO", @resource[:name]]
+    begin
+      output = portinfo(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output)
+    end
+
+    if output =~ /^(\S+)/
+      # output matches, so uninstall it
+      portuninstall $1
+    end
+  end
+
+  ######## Update/upgrade command
+
+  def update
+    Puppet.debug "portupgrade.update() - called on (#{@resource[:name]})"
+
+    cmdline = ["-qO", @resource[:name]]
+    begin
+      output = portinfo(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output)
+    end
+
+    if output =~ /^(\S+)/
+      # output matches, so upgrade the software
+      cmdline = ["-M BATCH=yes", $1]
+      begin
+        output = portupgrade(*cmdline)
+      rescue Puppet::ExecutionFailure
+        raise Puppet::Error.new(output)
+      end
+    end
+  end
+
+  ## EOF
+end

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

@@ -0,0 +1,132 @@
+require 'puppet/provider/package'
+
+# RPM packaging.  Should work anywhere that has rpm installed.
+Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Provider::Package do
+  desc "RPM packaging support; should work anywhere with a working `rpm`
+    binary."
+
+  has_feature :versionable
+
+  # The query format by which we identify installed packages
+  NEVRAFORMAT = "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}"
+  NEVRA_FIELDS = [:name, :epoch, :version, :release, :arch]
+
+  commands :rpm => "rpm"
+
+  if command('rpm')
+    confine :true => begin
+      rpm('--version')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  def self.instances
+    packages = []
+
+    # rpm < 4.1 don't support --nosignature
+    output = rpm "--version"
+    sig = "--nosignature"
+    if output =~ /RPM version (([123].*)|(4\.0.*))/
+      sig = ""
+    end
+
+    # list out all of the packages
+    begin
+      execpipe("#{command(:rpm)} -qa #{sig} --nodigest --qf '#{NEVRAFORMAT}\n'") { |process|
+        # now turn each returned line into a package object
+        process.each_line { |line|
+          hash = nevra_to_hash(line)
+          packages << new(hash)
+        }
+      }
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error, "Failed to list packages"
+    end
+
+    packages
+  end
+
+  # Find the fully versioned package name and the version alone. Returns
+  # a hash with entries :instance => fully versioned package name, and
+  # :ensure => version-release
+  def query
+    #NOTE: Prior to a fix for issue 1243, this method potentially returned a cached value
+    #IF YOU CALL THIS METHOD, IT WILL CALL RPM
+    #Use get(:property) to check if cached values are available
+    cmd = ["-q", @resource[:name], "--nosignature", "--nodigest", "--qf", "#{NEVRAFORMAT}\n"]
+
+    begin
+      output = rpm(*cmd)
+    rescue Puppet::ExecutionFailure
+      return nil
+    end
+
+    # FIXME: We could actually be getting back multiple packages
+    # for multilib
+    @property_hash.update(self.class.nevra_to_hash(output))
+
+    @property_hash.dup
+  end
+
+  # Here we just retrieve the version from the file specified in the source.
+  def latest
+    unless source = @resource[:source]
+      @resource.fail "RPMs must specify a package source"
+    end
+
+    cmd = [command(:rpm), "-q", "--qf", "#{NEVRAFORMAT}\n", "-p", "#{@resource[:source]}"]
+    h = self.class.nevra_to_hash(execfail(cmd, Puppet::Error))
+    h[:ensure]
+  end
+
+  def install
+    source = nil
+    unless source = @resource[:source]
+      @resource.fail "RPMs must specify a package source"
+    end
+    # RPM gets pissy if you try to install an already
+    # installed package
+    if @resource.should(:ensure) == @property_hash[:ensure] or
+      @resource.should(:ensure) == :latest && @property_hash[:ensure] == latest
+      return
+    end
+
+    flag = "-i"
+    flag = "-U" if @property_hash[:ensure] and @property_hash[:ensure] != :absent
+
+    rpm flag, "--oldpackage", source
+  end
+
+  def uninstall
+    query unless get(:arch)
+    nvr = "#{get(:name)}-#{get(:version)}-#{get(:release)}"
+    arch = ".#{get(:arch)}"
+    # If they specified an arch in the manifest, erase that Otherwise,
+    # erase the arch we got back from the query. If multiple arches are
+    # installed and only the package name is specified (without the
+    # arch), this will uninstall all of them on successive runs of the
+    # client, one after the other
+    if @resource[:name][-arch.size, arch.size] == arch
+      nvr += arch
+    else
+      nvr += ".#{get(:arch)}"
+    end
+    rpm "-e", nvr
+  end
+
+  def update
+    self.install
+  end
+
+  def self.nevra_to_hash(line)
+    line.chomp!
+    hash = {}
+    NEVRA_FIELDS.zip(line.split) { |f, v| hash[f] = v }
+    hash[:provider] = self.name
+    hash[:ensure] = "#{hash[:version]}-#{hash[:release]}"
+    hash
+  end
+end

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

@@ -0,0 +1,52 @@
+Puppet::Type.type(:package).provide :rug, :parent => :rpm do
+  desc "Support for suse `rug` package manager."
+
+  has_feature :versionable
+
+  commands :rug => "/usr/bin/rug"
+  commands :rpm => "rpm"
+  defaultfor :operatingsystem => [:suse, :sles]
+  confine    :operatingsystem => [:suse, :sles]
+
+  # Install a package using 'rug'.
+  def install
+    should = @resource.should(:ensure)
+    self.debug "Ensuring => #{should}"
+    wanted = @resource[:name]
+
+    # XXX: We don't actually deal with epochs here.
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      wanted += "-#{should}"
+    end
+    output = rug "--quiet", :install, "-y", wanted
+
+    unless self.query
+      raise Puppet::ExecutionFailure.new(
+        "Could not find package #{self.name}"
+      )
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    #rug can only get a list of *all* available packages?
+    output = rug "list-updates"
+
+    if output =~ /#{Regexp.escape @resource[:name]}\s*\|\s*([^\s\|]+)/
+      return $1
+    else
+      # rug didn't find updates, pretend the current
+      # version is the latest
+      return @property_hash[:ensure]
+    end
+  end
+
+  def update
+    # rug install can be used for update, too
+    self.install
+  end
+end

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

@@ -0,0 +1,154 @@
+# Sun packaging.
+
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :sun, :parent => Puppet::Provider::Package do
+  desc "Sun's packaging system.  Requires that you specify the source for
+    the packages you're managing."
+  commands :pkginfo => "/usr/bin/pkginfo",
+    :pkgadd => "/usr/sbin/pkgadd",
+    :pkgrm => "/usr/sbin/pkgrm"
+
+  confine :operatingsystem => :solaris
+
+  defaultfor :operatingsystem => :solaris
+
+  def self.instances
+    packages = []
+    hash = {}
+    names = {
+      "PKGINST" => :name,
+      "NAME" => nil,
+      "CATEGORY" => :category,
+      "ARCH" => :platform,
+      "VERSION" => :ensure,
+      "BASEDIR" => :root,
+      "HOTLINE" => nil,
+      "EMAIL" => nil,
+      "VENDOR" => :vendor,
+      "DESC" => :description,
+      "PSTAMP" => nil,
+      "INSTDATE" => nil,
+      "STATUS" => nil,
+      "FILES" => nil
+    }
+
+    cmd = "#{command(:pkginfo)} -l"
+
+    # list out all of the packages
+    execpipe(cmd) { |process|
+      # we're using the long listing, so each line is a separate
+      # piece of information
+      process.each_line { |line|
+        case line
+        when /^$/
+          hash[:provider] = :sun
+
+          packages << new(hash)
+          hash = {}
+        when /\s*(\w+):\s+(.+)/
+          name = $1
+          value = $2
+          if names.include?(name)
+            hash[names[name]] = value unless names[name].nil?
+          end
+        when /\s+\d+.+/
+          # nothing; we're ignoring the FILES info
+        end
+      }
+    }
+    packages
+  end
+
+  # Get info on a package, optionally specifying a device.
+  def info2hash(device = nil)
+    names = {
+      "PKGINST" => :name,
+      "NAME" => nil,
+      "CATEGORY" => :category,
+      "ARCH" => :platform,
+      "VERSION" => :ensure,
+      "BASEDIR" => :root,
+      "HOTLINE" => nil,
+      "EMAIL" => nil,
+      "VSTOCK" => nil,
+      "VENDOR" => :vendor,
+      "DESC" => :description,
+      "PSTAMP" => nil,
+      "INSTDATE" => nil,
+      "STATUS" => nil,
+      "FILES" => nil
+    }
+
+    hash = {}
+    cmd = "#{command(:pkginfo)} -l"
+    cmd += " -d #{device}" if device
+    cmd += " #{@resource[:name]}"
+
+    begin
+      # list out all of the packages
+      execpipe(cmd) { |process|
+        # we're using the long listing, so each line is a separate
+        # piece of information
+        process.readlines.each { |line|
+          case line
+          when /^$/  # ignore
+          when /\s*([A-Z]+):\s+(.+)/
+            name = $1
+            value = $2
+            if names.include?(name)
+              hash[names[name]] = value unless names[name].nil?
+            end
+          when /\s+\d+.+/
+            # nothing; we're ignoring the FILES info
+          end
+        }
+      }
+      return hash
+    rescue Puppet::ExecutionFailure => detail
+      return {:ensure => :absent} if detail.message =~ /information for "#{Regexp.escape(@resource[:name])}" was not found/
+      puts detail.backtrace if Puppet[:trace]
+      raise Puppet::Error, "Unable to get information about package #{@resource[:name]} because of: #{detail}"
+    end
+  end
+
+  def install
+    raise Puppet::Error, "Sun packages must specify a package source" unless @resource[:source]
+    cmd = []
+
+    cmd << "-a" << @resource[:adminfile] if @resource[:adminfile]
+
+    cmd << "-r" << @resource[:responsefile] if @resource[:responsefile]
+
+    cmd << "-d" << @resource[:source]
+    cmd << "-n" << @resource[:name]
+
+    pkgadd cmd
+  end
+
+  # Retrieve the version from the current package file.
+  def latest
+    hash = info2hash(@resource[:source])
+    hash[:ensure]
+  end
+
+  def query
+    info2hash()
+  end
+
+  def uninstall
+    command  = ["-n"]
+
+    command << "-a" << @resource[:adminfile] if @resource[:adminfile]
+
+    command << @resource[:name]
+    pkgrm command
+  end
+
+  # Remove the old package, and install the new one.  This will probably
+  # often fail.
+  def update
+    self.uninstall if (@property_hash[:ensure] || info2hash()[:ensure]) != :absent
+    self.install
+  end
+end

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

@@ -0,0 +1,9 @@
+# At this point, it's an exact copy of the Blastwave stuff.
+Puppet::Type.type(:package).provide :sunfreeware, :parent => :blastwave, :source => :sun do
+  desc "Package management using sunfreeware.com's `pkg-get` command on Solaris.
+    At this point, support is exactly the same as `blastwave` support and
+    has not actually been tested."
+  commands :pkgget => "pkg-get"
+
+  confine :operatingsystem => :solaris
+end