puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,111 @@
+# Puppet package provider for Python's `pip` package management frontend.
+# <http://pip.openplans.org/>
+
+require 'puppet/provider/package'
+require 'xmlrpc/client'
+
+Puppet::Type.type(:package).provide :pip,
+  :parent => ::Puppet::Provider::Package do
+
+  desc "Python packages via `pip`."
+
+  has_feature :installable, :uninstallable, :upgradeable, :versionable
+
+  # 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
+
+  # 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 = which('pip') or return []
+    execpipe "#{pip_cmd} freeze" do |process|
+      process.collect do |line|
+        next unless options = parse(line)
+        packages << new(options)
+      end
+    end
+    packages
+  end
+
+  # 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] == provider_pip.name
+    end
+    return nil
+  end
+
+  # Ask the PyPI API for the latest version number.  There is no local
+  # cache of PyPI's package list so this operation will always have to
+  # ask the web service.
+  def latest
+    client = XMLRPC::Client.new2("http://pypi.python.org/pypi")
+    client.http_header_extra = {"Content-Type" => "text/xml"}
+    client.timeout = 10
+    result = client.call("package_releases", @resource[:name])
+    result.first
+  rescue Timeout::Error => detail
+    raise Puppet::Error, "Timeout while contacting pypi.python.org: #{detail}";
+  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
+    args = %w{install -q}
+    if @resource[:source]
+      args << "-e"
+      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
+    lazy_pip *args
+  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
+    lazy_pip "uninstall", "-y", "-q", @resource[:name]
+  end
+
+  def update
+    install
+  end
+
+  # 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
+    if pathname = which('pip')
+      self.class.commands :pip => pathname
+      pip *args
+    else
+      raise e, 'Could not locate the pip command.'
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package do
+  desc "OpenSolaris image packaging system. See pkg(5) for more information"
+
+  commands :pkg => "/usr/bin/pkg"
+
+  confine :operatingsystem => :solaris
+
+  #defaultfor [:operatingsystem => :solaris, :kernelrelease => "5.11"]
+
+  def self.instances
+    packages = []
+
+    pkg(:list, '-H').each_line do |line|
+      # now turn each returned line into a package object
+      if hash = parse_line(line.chomp)
+        packages << new(hash)
+      end
+    end
+
+    packages
+  end
+
+  self::REGEX = /^(\S+)(?:\s+\(.*?\))?\s+(\S+)\s+(\S+)?\s+(\S+)$/
+  self::FIELDS = [:name, :version, :status, :flags]
+
+  def self.parse_line(line)
+    hash = {}
+    if match = self::REGEX.match(line)
+
+      self::FIELDS.zip(match.captures) { |field,value|
+        hash[field] = value
+      }
+
+      hash[:provider] = self.name
+
+      # on solaris 11 we do not have a status field because the status
+      # seems to be merged in the flags field. Simulate old behaviour on
+      # solaris 11
+      flags = hash.delete(:flags)
+      unless hash[:status]
+        hash[:status] = case flags
+          when /^i/
+            'installed'
+          when /^-/
+            'known'
+          else
+            warning "unknown package state for #{hash[:name]}: #{flags}"
+            'unknown'
+        end
+      end
+
+      if hash[:status] == "installed"
+        hash[:ensure] = :present
+      else
+        hash[:ensure] = :absent
+      end
+    else
+      warning "Failed to match 'pkg list' line #{line.inspect}"
+      return nil
+    end
+
+    hash
+  end
+
+  # return the version of the package
+  # TODO deal with multiple publishers
+  def latest
+    version = nil
+    pkg(:list, "-Ha", @resource[:name]).each_line do |line|
+      v = parse_line(line.chomp)[:status]
+      case v
+      when "known"
+        return v
+      when "installed"
+        version = v
+      else
+        Puppet.warn "unknown package state for #{@resource[:name]}: #{v}"
+      end
+    end
+    version
+  end
+
+  # install the package
+  def install
+    pkg :install, @resource[:name]
+  end
+
+  # uninstall the package
+  def uninstall
+    pkg :uninstall, '-r', @resource[:name]
+  end
+
+  # update the package to the latest version available
+  def update
+    self.install
+  end
+
+  # list a specific package
+  def query
+    begin
+      output = pkg(:list, "-H", @resource[:name])
+    rescue Puppet::ExecutionFailure
+      # pkg returns 1 if the package is not found.
+      return {:ensure => :absent, :name => @resource[:name]}
+    end
+
+    hash = self.class.parse_line(output.chomp) || {:ensure => :absent, :name => @resource[:name]}
+    hash
+  end
+end

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

@@ -0,0 +1,123 @@
+#
+# Motivation: DMG files provide a true HFS file system
+# and are easier to manage and .pkg bundles.
+#
+# Note: the 'apple' Provider checks for the package name
+# in /L/Receipts.  Since we install multiple pkg's from a single
+# source, we treat the source .pkg.dmg file as the package name.
+# As a result, we store installed .pkg.dmg file names
+# in /var/db/.puppet_pkgdmg_installed_<name>
+
+require 'puppet/provider/package'
+require 'facter/util/plist'
+
+Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Package do
+  desc "Package management based on Apple's Installer.app and
+    DiskUtility.app.  This package works by checking the contents of a
+    DMG image for Apple pkg or mpkg files. Any number of pkg or mpkg
+    files may exist in the root directory of the DMG file system.
+    Subdirectories are not checked for packages.  See
+    [the wiki docs on this provider](http://projects.puppetlabs.com/projects/puppet/wiki/Package_Management_With_Dmg_Patterns)
+    for more detail."
+
+  confine :operatingsystem => :darwin
+  defaultfor :operatingsystem => :darwin
+  commands :installer => "/usr/sbin/installer"
+  commands :hdiutil => "/usr/bin/hdiutil"
+  commands :curl => "/usr/bin/curl"
+
+  # JJM We store a cookie for each installed .pkg.dmg in /var/db
+  def self.instance_by_name
+    Dir.entries("/var/db").find_all { |f|
+      f =~ /^\.puppet_pkgdmg_installed_/
+    }.collect do |f|
+      name = f.sub(/^\.puppet_pkgdmg_installed_/, '')
+      yield name if block_given?
+      name
+    end
+  end
+
+  def self.instances
+    instance_by_name.collect do |name|
+      new(:name => name, :provider => :pkgdmg, :ensure => :installed)
+    end
+  end
+
+  def self.installpkg(source, name, orig_source)
+    installer "-pkg", source, "-target", "/"
+    # Non-zero exit status will throw an exception.
+    File.open("/var/db/.puppet_pkgdmg_installed_#{name}", "w") do |t|
+      t.print "name: '#{name}'\n"
+      t.print "source: '#{orig_source}'\n"
+    end
+  end
+
+  def self.installpkgdmg(source, name)
+    unless source =~ /\.dmg$/i || source =~ /\.pkg$/i
+      raise Puppet::Error.new("Mac OS X PKG DMG's must specify a source string ending in .dmg or flat .pkg file")
+    end
+    require 'open-uri'
+    cached_source = source
+    tmpdir = Dir.mktmpdir
+    begin
+      if %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ cached_source
+        cached_source = File.join(tmpdir, name)
+        begin
+          curl "-o", cached_source, "-C", "-", "-k", "-L", "-s", "--url", source
+          Puppet.debug "Success: curl transfered [#{name}]"
+        rescue Puppet::ExecutionFailure
+          Puppet.debug "curl did not transfer [#{name}].  Falling back to slower open-uri transfer methods."
+          cached_source = source
+        end
+      end
+
+      if source =~ /\.dmg$/i
+        File.open(cached_source) do |dmg|
+          xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-noidme", "-mountrandom", "/tmp", dmg.path
+          hdiutil_info = Plist::parse_xml(xml_str)
+          raise Puppet::Error.new("No disk entities returned by mount at #{dmg.path}") unless hdiutil_info.has_key?("system-entities")
+          mounts = hdiutil_info["system-entities"].collect { |entity|
+            entity["mount-point"]
+          }.compact
+          begin
+            mounts.each do |mountpoint|
+              Dir.entries(mountpoint).select { |f|
+                f =~ /\.m{0,1}pkg$/i
+              }.each do |pkg|
+                installpkg("#{mountpoint}/#{pkg}", name, source)
+              end
+            end
+          ensure
+            mounts.each do |mountpoint|
+              hdiutil "eject", mountpoint
+            end
+          end
+        end
+      else
+        installpkg(cached_source, name, source)
+      end
+    ensure
+      FileUtils.remove_entry_secure(tmpdir, force=true)
+    end
+  end
+
+  def query
+    if FileTest.exists?("/var/db/.puppet_pkgdmg_installed_#{@resource[:name]}")
+      Puppet.debug "/var/db/.puppet_pkgdmg_installed_#{@resource[:name]} found"
+      return {:name => @resource[:name], :ensure => :present}
+    else
+      return nil
+    end
+  end
+
+  def install
+    source = nil
+    unless source = @resource[:source]
+      raise Puppet::Error.new("Mac OS X PKG DMG's must specify a package source.")
+    end
+    unless name = @resource[:name]
+      raise Puppet::Error.new("Mac OS X PKG DMG's must specify a package name.")
+    end
+    self.class.installpkgdmg(source,name)
+  end
+end

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

@@ -0,0 +1,174 @@
+# Packaging using Peter Bonivart's pkgutil program.
+Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun do
+  desc "Package management using Peter Bonivart's ``pkgutil`` command on Solaris."
+
+  pkgutil_bin = "pkgutil"
+  if FileTest.executable?("/opt/csw/bin/pkgutil")
+    pkgutil_bin = "/opt/csw/bin/pkgutil"
+  end
+
+  confine :operatingsystem => :solaris
+
+  commands :pkguti => pkgutil_bin
+
+  def self.healthcheck()
+    unless FileTest.exists?("/var/opt/csw/pkgutil/admin")
+      Puppet.notice "It is highly recommended you create '/var/opt/csw/pkgutil/admin'."
+      Puppet.notice "See /var/opt/csw/pkgutil"
+    end
+
+    correct_wgetopts = false
+    [ "/opt/csw/etc/pkgutil.conf", "/etc/opt/csw/pkgutil.conf" ].each do |confpath|
+      File.open(confpath) do |conf|
+        conf.each_line {|line| correct_wgetopts = true if line =~ /^\s*wgetopts\s*=.*(-nv|-q|--no-verbose|--quiet)/ }
+      end
+    end
+    if ! correct_wgetopts
+      Puppet.notice "It is highly recommended that you set 'wgetopts=-nv' in your pkgutil.conf."
+    end
+  end
+
+  def self.instances(hash = {})
+    healthcheck
+
+    # Use the available pkg list (-a) to work out aliases
+    aliases = {}
+    availlist.each do |pkg|
+      aliases[pkg[:name]] = pkg[:alias]
+    end
+
+    # The -c pkglist lists installed packages
+    pkginsts = []
+    pkglist(hash).each do |pkg|
+      pkg.delete(:avail)
+      pkginsts << new(pkg)
+
+      # Create a second instance with the alias if it's different
+      pkgalias = aliases[pkg[:name]]
+      if pkgalias and pkg[:name] != pkgalias
+        apkg = pkg.dup
+        apkg[:name] = pkgalias
+        pkginsts << new(apkg)
+      end
+    end
+
+    pkginsts
+  end
+
+  # Turns a pkgutil -a listing into hashes with the common alias, full
+  # package name and available version
+  def self.availlist
+    output = pkguti ["-a"]
+
+    list = output.split("\n").collect do |line|
+      next if line =~ /^common\s+package/  # header of package list
+      next if noise?(line)
+
+      if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
+        { :alias => $1, :name => $2, :avail => $3 }
+      else
+        Puppet.warning "Cannot match %s" % line
+      end
+    end.reject { |h| h.nil? }
+  end
+
+  # Turn our pkgutil -c listing into a bunch of hashes.
+  # Supports :justme => packagename, which uses the optimised --single arg
+  def self.pkglist(hash)
+    command = ["-c"]
+
+    if hash[:justme]
+      # The --single option speeds up the execution, because it queries
+      # the package managament system for one package only.
+      command << "--single"
+      command << hash[:justme]
+    end
+
+    output = pkguti(command).split("\n")
+
+    if output[-1] == "Not in catalog"
+      Puppet.warning "Package not in pkgutil catalog: %s" % hash[:justme]
+      return nil
+    end
+
+    list = output.collect do |line|
+      next if line =~ /installed\s+catalog/  # header of package list
+      next if noise?(line)
+
+      pkgsplit(line)
+    end.reject { |h| h.nil? }
+
+    if hash[:justme]
+      # Single queries may have been for an alias so return the name requested
+      if list.any?
+        list[-1][:name] = hash[:justme]
+        return list[-1]
+      end
+    else
+      list.reject! { |h| h[:ensure] == :absent }
+      return list
+    end
+  end
+
+  # Identify common types of pkgutil noise as it downloads catalogs etc
+  def self.noise?(line)
+    true if line =~ /^#/
+    true if line =~ /^Checking integrity / # use_gpg
+    true if line =~ /^gpg: /               # gpg verification
+    true if line =~ /^=+> /                # catalog fetch
+    true if line =~ /\d+:\d+:\d+ URL:/     # wget without -q
+    false
+  end
+
+  # Split the different lines into hashes.
+  def self.pkgsplit(line)
+    if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
+      hash = {}
+      hash[:name] = $1
+      hash[:ensure] = if $2 == "notinst"
+        :absent
+      else
+        $2
+      end
+      hash[:avail] = $3
+
+      if hash[:avail] =~ /^SAME\s*$/
+        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
+
+  def install
+    pkguti "-y", "-i", @resource[:name]
+  end
+
+  # Retrieve the version from the current package file.
+  def latest
+    hash = self.class.pkglist(:justme => @resource[:name])
+    hash[:avail] if hash
+  end
+
+  def query
+    if hash = self.class.pkglist(:justme => @resource[:name])
+      hash
+    else
+      {:ensure => :absent}
+    end
+  end
+
+  def update
+    pkguti "-y", "-u", @resource[:name]
+  end
+
+  def uninstall
+    pkguti "-y", "-r", @resource[:name]
+  end
+end

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

@@ -0,0 +1,124 @@
+require 'puppet/provider/package'
+require 'fileutils'
+
+Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Package do
+  desc "Provides packaging support for Gentoo's portage system."
+
+  has_feature :versionable
+
+  commands :emerge => "/usr/bin/emerge", :eix => "/usr/bin/eix", :update_eix => "/usr/bin/eix-update"
+
+  confine :operatingsystem => :gentoo
+
+  defaultfor :operatingsystem => :gentoo
+
+  def self.instances
+    result_format = /^(\S+)\s+(\S+)\s+\[(\S+)\]\s+\[(\S+)\]\s+(\S+)\s+(.*)$/
+    result_fields = [:category, :name, :ensure, :version_available, :vendor, :description]
+
+    version_format = "{last}<version>{}"
+    search_format = "<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] <homepage> <description>\n"
+
+    begin
+      eix_file = File.directory?("/var/cache/eix") ? "/var/cache/eix/portage.eix" : "/var/cache/eix"
+      update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
+
+      search_output = nil
+      Puppet::Util::Execution.withenv :LASTVERSION => version_format do
+        search_output = eix "--nocolor", "--pure-packages", "--stable", "--installed", "--format", search_format
+      end
+
+      packages = []
+      search_output.each_line do |search_result|
+        match = result_format.match(search_result)
+
+        if match
+          package = {}
+          result_fields.zip(match.captures) do |field, value|
+            package[field] = value unless !value or value.empty?
+          end
+          package[:provider] = :portage
+          packages << new(package)
+        end
+      end
+
+      return packages
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error.new(detail)
+    end
+  end
+
+  def install
+    should = @resource.should(:ensure)
+    name = package_name
+    unless should == :present or should == :latest
+      # We must install a specific version
+      name = "=#{name}-#{should}"
+    end
+    emerge name
+  end
+
+  # The common package name format.
+  def package_name
+    @resource[:category] ? "#{@resource[:category]}/#{@resource[:name]}" : @resource[:name]
+  end
+
+  def uninstall
+    emerge "--unmerge", package_name
+  end
+
+  def update
+    self.install
+  end
+
+  def query
+    result_format = /^(\S+)\s+(\S+)\s+\[(\S*)\]\s+\[(\S+)\]\s+(\S+)\s+(.*)$/
+    result_fields = [:category, :name, :ensure, :version_available, :vendor, :description]
+
+    version_format = "{last}<version>{}"
+    search_format = "<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] <homepage> <description>\n"
+
+    search_field = package_name.count('/') > 0 ? "--category-name" : "--name"
+    search_value = package_name
+
+    begin
+      eix_file = File.directory?("/var/cache/eix") ? "/var/cache/eix/portage.eix" : "/var/cache/eix"
+      update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
+
+      search_output = nil
+      Puppet::Util::Execution.withenv :LASTVERSION => version_format do
+        search_output = eix "--nocolor", "--pure-packages", "--stable", "--format", search_format, "--exact", search_field, search_value
+      end
+
+      packages = []
+      search_output.each_line do |search_result|
+        match = result_format.match(search_result)
+
+        if match
+          package = {}
+          result_fields.zip(match.captures) do |field, value|
+            package[field] = value unless !value or value.empty?
+          end
+          package[:ensure] = package[:ensure] ? package[:ensure] : :absent
+          packages << package
+        end
+      end
+
+      case packages.size
+        when 0
+          not_found_value = "#{@resource[:category] ? @resource[:category] : "<unspecified category>"}/#{@resource[:name]}"
+          raise Puppet::Error.new("No package found with the specified name [#{not_found_value}]")
+        when 1
+          return packages[0]
+        else
+          raise Puppet::Error.new("More than one package with the specified name [#{search_value}], please use the category parameter to disambiguate")
+      end
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error.new(detail)
+    end
+  end
+
+  def latest
+    self.query[:version_available]
+  end
+end