puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,127 @@
+require 'puppet/provider/package'
+require 'uri'
+
+# Ruby gems support.
+Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package do
+  desc "Ruby Gem support.  If a URL is passed via `source`, then that URL is used as the
+    remote gem repository; if a source is present but is not a valid URL, it will be
+    interpreted as the path to a local gem file.  If source is not present at all,
+    the gem will be installed from the default gem repositories."
+
+  has_feature :versionable
+
+  commands :gemcmd => "gem"
+
+  def self.gemlist(options)
+    gem_list_command = [command(:gemcmd), "list"]
+
+    if options[:local]
+      gem_list_command << "--local"
+    else
+      gem_list_command << "--remote"
+    end
+    if options[:source]
+      gem_list_command << "--source" << options[:source]
+    end
+    if name = options[:justme]
+      gem_list_command << name + "$"
+    end
+
+    begin
+      list = execute(gem_list_command).lines.
+        map {|set| gemsplit(set) }.
+        reject {|x| x.nil? }
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not list gems: #{detail}"
+    end
+
+    if options[:justme]
+      return list.shift
+    else
+      return list
+    end
+  end
+
+  def self.gemsplit(desc)
+    # `gem list` when output console has a line like:
+    # *** LOCAL GEMS ***
+    # but when it's not to the console that line
+    # and all blank lines are stripped
+    # so we don't need to check for them
+
+    if desc =~ /^(\S+)\s+\((.+)\)/
+      name = $1
+      versions = $2.split(/,\s*/)
+      {
+        :name     => name,
+        :ensure   => versions,
+        :provider => :gem
+      }
+    else
+      Puppet.warning "Could not match #{desc}"
+      nil
+    end
+  end
+
+  def self.instances(justme = false)
+    gemlist(:local => true).collect do |hash|
+      new(hash)
+    end
+  end
+
+  def install(useversion = true)
+    command = [command(:gemcmd), "install"]
+    command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
+    # Always include dependencies
+    command << "--include-dependencies"
+
+    if source = resource[:source]
+      begin
+        uri = URI.parse(source)
+      rescue => detail
+        fail "Invalid source '#{uri}': #{detail}"
+      end
+
+      case uri.scheme
+      when nil
+        # no URI scheme => interpret the source as a local file
+        command << source
+      when /file/i
+        command << uri.path
+      when 'puppet'
+        # we don't support puppet:// URLs (yet)
+        raise Puppet::Error.new("puppet:// URLs are not supported as gem sources")
+      else
+        # interpret it as a gem repository
+        command << "--source" << "#{source}" << resource[:name]
+      end
+    else
+      command << "--no-rdoc" << "--no-ri" << resource[:name]
+    end
+
+    output = execute(command)
+    # Apparently some stupid gem versions don't exit non-0 on failure
+    self.fail "Could not install: #{output.chomp}" if output.include?("ERROR")
+  end
+
+  def latest
+    # This always gets the latest version available.
+    gemlist_options = {:justme => resource[:name]}
+    gemlist_options.merge!({:source => resource[:source]}) unless resource[:source].nil?
+    hash = self.class.gemlist(gemlist_options)
+
+    hash[:ensure][0]
+  end
+
+  def query
+    self.class.gemlist(:justme => resource[:name], :local => true)
+  end
+
+  def uninstall
+    gemcmd "uninstall", "-x", "-a", resource[:name]
+  end
+
+  def update
+    self.install(false)
+  end
+end

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

@@ -0,0 +1,44 @@
+# HP-UX packaging.
+
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :hpux, :parent => Puppet::Provider::Package do
+
+  desc "HP-UX's packaging system."
+
+  commands :swinstall => "/usr/sbin/swinstall",
+    :swlist => "/usr/sbin/swlist",
+    :swremove => "/usr/sbin/swremove"
+
+  confine :operatingsystem => "hp-ux"
+
+  defaultfor :operatingsystem => "hp-ux"
+
+  def self.instances
+    # TODO:  This is very hard on HP-UX!
+    []
+  end
+
+  # source and name are required
+  def install
+    raise ArgumentError, "source must be provided to install HP-UX packages" unless resource[:source]
+    args = standard_args + ["-s", resource[:source], resource[:name]]
+    swinstall(*args)
+  end
+
+  def query
+    swlist resource[:name]
+    {:ensure => :present}
+  rescue
+    {:ensure => :absent}
+  end
+
+  def uninstall
+    args = standard_args + [resource[:name]]
+    swremove(*args)
+  end
+
+  def standard_args
+    ["-x", "mount_all_filesystems=false"]
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Package do
+  desc "Package management using MacPorts on OS X.
+
+    Supports MacPorts versions and revisions, but not variants.
+    Variant preferences may be specified using
+    [the MacPorts variants.conf file](http://guide.macports.org/chunked/internals.configuration-files.html#internals.configuration-files.variants-conf).
+
+    When specifying a version in the Puppet DSL, only specify the version, not the revision.
+    Revisions are only used internally for ensuring the latest version/revision of a port.
+  "
+
+  confine :operatingsystem => :darwin
+  commands :port => "/opt/local/bin/port"
+
+  has_feature :installable
+  has_feature :uninstallable
+  has_feature :upgradeable
+  has_feature :versionable
+
+
+  def self.parse_installed_query_line(line)
+    regex = /(\S+)\s+@(\S+)_(\S+)\s+\(active\)/
+    fields = [:name, :ensure, :revision]
+    hash_from_line(line, regex, fields)
+  end
+
+  def self.parse_info_query_line(line)
+    regex = /(\S+)\s+(\S+)/
+    fields = [:version, :revision]
+    hash_from_line(line, regex, fields)
+  end
+
+  def self.hash_from_line(line, regex, fields)
+    hash = {}
+    if match = regex.match(line)
+      fields.zip(match.captures) { |field, value|
+        hash[field] = value
+      }
+      hash[:provider] = self.name
+      return hash
+    end
+    nil
+  end
+
+  def self.instances
+    packages = []
+    port("-q", :installed).each_line do |line|
+      if hash = parse_installed_query_line(line)
+        packages << new(hash)
+      end
+    end
+    packages
+  end
+
+  def install
+    should = @resource.should(:ensure)
+    if [:latest, :installed, :present].include?(should)
+      output = port("-q", :install, @resource[:name])
+    else
+      output = port("-q", :install, @resource[:name], "@#{should}")
+    end
+    # MacPorts now correctly exits non-zero with appropriate errors in
+    # situations where a port cannot be found or installed.
+  end
+
+  def query
+    return self.class.parse_installed_query_line(port("-q", :installed, @resource[:name]))
+  end
+
+  def latest
+    # We need both the version and the revision to be confident
+    # we've got the latest revision of a specific version
+    # Note we're still not doing anything with variants here.
+    info_line = port("-q", :info, "--line", "--version", "--revision", @resource[:name])
+    return nil if info_line == ""
+
+    if newest = self.class.parse_info_query_line(info_line)
+      current = query
+      # We're doing some fiddling behind the scenes here to cope with updated revisions.
+      # If we're already at the latest version/revision, then just return the version
+      # so the current and desired values match. Otherwise return version and revision
+      # to trigger an upgrade to the latest revision.
+      if newest[:version] == current[:ensure] and newest[:revision] == current[:revision]
+        return current[:ensure]
+      else
+        return "#{newest[:version]}_#{newest[:revision]}"
+      end
+    end
+    nil
+  end
+
+  def uninstall
+    port("-q", :uninstall, @resource[:name])
+  end
+
+  def update
+    if query[:name] == @resource[:name]  # 'port upgrade' cannot install new ports
+      port("-q", :upgrade, @resource[:name])
+    else
+      install
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide(:msi, :parent => Puppet::Provider::Package) do
+  desc "Windows package management by installing and removing MSIs.
+
+    This provider requires a `source` attribute, and will accept paths to local
+    files, mapped drives, or UNC paths."
+
+  confine    :operatingsystem => :windows
+  defaultfor :operatingsystem => :windows
+
+  has_feature :installable
+  has_feature :uninstallable
+  has_feature :install_options
+
+  class MsiPackage
+    extend Enumerable
+
+    # From msi.h
+    INSTALLSTATE_DEFAULT = 5 # product is installed for the current user
+    INSTALLUILEVEL_NONE  = 2 # completely silent installation
+
+    def self.installer
+      require 'win32ole'
+      WIN32OLE.new("WindowsInstaller.Installer")
+    end
+
+    def self.each(&block)
+      inst = installer
+      inst.UILevel = INSTALLUILEVEL_NONE
+
+      inst.Products.each do |guid|
+        # products may be advertised, installed in a different user
+        # context, etc, we only want to know about products currently
+        # installed in our context.
+        next unless inst.ProductState(guid) == INSTALLSTATE_DEFAULT
+
+        package = {
+          :name        => inst.ProductInfo(guid, 'ProductName'),
+          # although packages have a version, the provider isn't versionable,
+          # so we can't return a version
+          # :ensure      => inst.ProductInfo(guid, 'VersionString'),
+          :ensure      => :installed,
+          :provider    => :msi,
+          :productcode => guid,
+          :packagecode => inst.ProductInfo(guid, 'PackageCode')
+        }
+
+        yield package
+      end
+    end
+  end
+
+  # Get an array of provider instances for currently installed packages
+  def self.instances
+    MsiPackage.enum_for.map { |package| new(package) }
+  end
+
+  # Find first package whose PackageCode, e.g. {B2BE95D2-CD2C-46D6-8D27-35D150E58EC9},
+  # matches the resource name (case-insensitively due to hex) or the ProductName matches
+  # the resource name. The ProductName is not guaranteed to be unique, but the PackageCode
+  # should be if the package is authored correctly.
+  def query
+    MsiPackage.enum_for.find do |package|
+      resource[:name].casecmp(package[:packagecode]) == 0 || resource[:name] == package[:name]
+    end
+  end
+
+  def install
+    fail("The source parameter is required when using the MSI provider.") unless resource[:source]
+
+    # Unfortunately, we can't use the msiexec method defined earlier,
+    # because of the special quoting we need to do around the MSI
+    # properties to use.
+    command = ['msiexec.exe', '/qn', '/norestart', '/i', shell_quote(resource[:source]), install_options].flatten.compact.join(' ')
+    execute(command, :combine => true)
+
+    check_result(exit_status)
+  end
+
+  def uninstall
+    fail("The productcode property is missing.") unless properties[:productcode]
+
+    command = ['msiexec.exe', '/qn', '/norestart', '/x', properties[:productcode]].flatten.compact.join(' ')
+    execute(command, :combine => true)
+
+    check_result(exit_status)
+  end
+
+  def exit_status
+    $CHILD_STATUS.exitstatus
+  end
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa368542(v=vs.85).aspx
+  ERROR_SUCCESS                  = 0
+  ERROR_SUCCESS_REBOOT_INITIATED = 1641
+  ERROR_SUCCESS_REBOOT_REQUIRED  = 3010
+
+  # (Un)install may "fail" because the package requested a reboot, the system requested a
+  # reboot, or something else entirely. Reboot requests mean the package was installed
+  # successfully, but we warn since we don't have a good reboot strategy.
+  def check_result(hr)
+    operation = resource[:ensure] == :absent ? 'uninstall' : 'install'
+
+    case hr
+    when ERROR_SUCCESS
+      # yeah
+    when 194
+      warning("The package requested a reboot to finish the operation.")
+    when ERROR_SUCCESS_REBOOT_INITIATED
+      warning("The package #{operation}ed successfully and the system is rebooting now.")
+    when ERROR_SUCCESS_REBOOT_REQUIRED
+      warning("The package #{operation}ed successfully, but the system must be rebooted.")
+    else
+      raise Puppet::Util::Windows::Error.new("Failed to #{operation}", hr)
+    end
+  end
+
+  def validate_source(value)
+    fail("The source parameter cannot be empty when using the MSI provider.") if value.empty?
+  end
+
+  def install_options
+    # properties is a string delimited by spaces, so each key value must be quoted
+    properties_for_command = nil
+    if resource[:install_options]
+      properties_for_command = resource[:install_options].collect do |k,v|
+        property = shell_quote k
+        value    = shell_quote v
+
+        "#{property}=#{value}"
+      end
+    end
+
+    properties_for_command
+  end
+
+  def shell_quote(value)
+    value.include?(' ') ? %Q["#{value.gsub(/"/, '\"')}"] : value
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'puppet/provider/package'
+require 'puppet/util/package'
+
+Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
+  desc "Installation from NIM LPP source."
+
+  # The commands we are using on an AIX box are installed standard
+  # (except nimclient) nimclient needs the bos.sysmgt.nim.client fileset.
+  commands    :nimclient => "/usr/sbin/nimclient"
+
+  # If NIM has not been configured, /etc/niminfo will not be present.
+  # However, we have no way of knowing if the NIM server is not configured
+  # properly.
+  confine  :exists => "/etc/niminfo"
+
+  has_feature :versionable
+
+  attr_accessor :latest_info
+
+  def self.srclistcmd(source)
+    [ command(:nimclient), "-o", "showres", "-a", "installp_flags=L", "-a", "resource=#{source}" ]
+  end
+
+  def install(useversion = true)
+    unless source = @resource[:source]
+      self.fail "An LPP source location is required in 'source'"
+    end
+
+    pkg = @resource[:name]
+
+    pkg << " " << @resource.should(:ensure) if (! @resource.should(:ensure).is_a? Symbol) and useversion
+
+    nimclient "-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=#{source}", "-a", "filesets='#{pkg}'"
+  end
+end

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

@@ -0,0 +1,112 @@
+require 'puppet/provider/package'
+
+# Packaging on OpenBSD.  Doesn't work anywhere else that I know of.
+Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Package do
+  desc "OpenBSD's form of `pkg_add` support."
+
+  commands :pkginfo => "pkg_info", :pkgadd => "pkg_add", :pkgdelete => "pkg_delete"
+
+  defaultfor :operatingsystem => :openbsd
+  confine :operatingsystem => :openbsd
+
+  has_feature :versionable
+
+  def self.instances
+    packages = []
+
+    begin
+      execpipe(listcmd) do |process|
+        # our regex for matching pkg_info output
+        regex = /^(.*)-(\d[^-]*)[-]?(\D*)(.*)$/
+        fields = [:name, :ensure, :flavor ]
+        hash = {}
+
+        # now turn each returned line into a package object
+        process.each_line { |line|
+          if match = regex.match(line.split[0])
+            fields.zip(match.captures) { |field,value|
+              hash[field] = value
+            }
+            yup = nil
+            name = hash[:name]
+
+            hash[:provider] = self.name
+
+            packages << new(hash)
+            hash = {}
+          else
+            # Print a warning on lines we can't match, but move
+            # on, since it should be non-fatal
+            warning("Failed to match line #{line}")
+          end
+        }
+      end
+
+      return packages
+    rescue Puppet::ExecutionFailure
+      return nil
+    end
+  end
+
+  def self.listcmd
+    [command(:pkginfo), "-a"]
+  end
+
+  def install
+    should = @resource.should(:ensure)
+
+    unless @resource[:source]
+      raise Puppet::Error,
+      "You must specify a package source for BSD packages"
+    end
+
+    if @resource[:source][-1,1] == ::File::SEPARATOR
+      e_vars = { 'PKG_PATH' => @resource[:source] }
+      full_name = [ @resource[:name], get_version || @resource[:ensure], @resource[:flavor] ].join('-').chomp('-').chomp('-')
+    else
+      e_vars = {}
+      full_name = @resource[:source]
+    end
+
+    Puppet::Util::Execution::withenv(e_vars) { pkgadd full_name }
+  end
+
+  def get_version
+    execpipe([command(:pkginfo), "-I", @resource[:name]]) do |process|
+      # our regex for matching pkg_info output
+      regex = /^(.*)-(\d[^-]*)[-]?(\D*)(.*)$/
+      fields = [ :name, :version, :flavor ]
+      master_version = 0
+      version = -1
+
+      process.each_line do |line|
+        if match = regex.match(line.split[0])
+          # now we return the first version, unless ensure is latest
+          version = match.captures[1]
+          return version unless @resource[:ensure] == "latest"
+
+          master_version = version unless master_version > version
+        end
+      end
+
+      return master_version unless master_version == 0
+      return '' if version == -1
+      raise Puppet::Error, "#{version} is not available for this package"
+    end
+  rescue Puppet::ExecutionFailure
+    return nil
+  end
+
+  def query
+    # Search for the version info
+    if pkginfo(@resource[:name]) =~ /Information for (inst:)?#{@resource[:name]}-(\S+)/
+      return { :ensure => $2 }
+    else
+      return nil
+    end
+  end
+
+  def uninstall
+    pkgdelete @resource[:name]
+  end
+end

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

@@ -0,0 +1,94 @@
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Package do
+  desc "Support for the Package Manager Utility (pacman) used in Archlinux."
+
+  commands :pacman => "/usr/bin/pacman"
+  defaultfor :operatingsystem => :archlinux
+  confine    :operatingsystem => :archlinux
+  has_feature :upgradeable
+
+  # Install a package using 'pacman'.
+  # Installs quietly, without confirmation or progressbar, updates package
+  # list from servers defined in pacman.conf.
+  def install
+    pacman "--noconfirm", "--noprogressbar", "-Sy", @resource[:name]
+
+    unless self.query
+      raise Puppet::ExecutionFailure.new("Could not find package %s" % self.name)
+    end
+  end
+
+  def self.listcmd
+    [command(:pacman), "-Q"]
+  end
+
+  # Fetch the list of packages currently installed on the system.
+  def self.instances
+    packages = []
+    begin
+      execpipe(listcmd()) do |process|
+        # pacman -Q output is 'packagename version-rel'
+        regex = %r{^(\S+)\s(\S+)}
+        fields = [:name, :ensure]
+        hash = {}
+
+        process.each_line { |line|
+          if match = regex.match(line)
+            fields.zip(match.captures) { |field,value|
+              hash[field] = value
+            }
+
+            name = hash[:name]
+            hash[:provider] = self.name
+
+            packages << new(hash)
+            hash = {}
+          else
+            warning("Failed to match line %s" % line)
+          end
+        }
+      end
+    rescue Puppet::ExecutionFailure
+      return nil
+    end
+    packages
+  end
+
+  # Because Archlinux is a rolling release based distro, installing a package
+  # should always result in the newest release.
+  def update
+    # Install in pacman can be used for update, too
+    self.install
+  end
+
+  def latest
+    pacman "-Sy"
+    output = pacman "-Sp", "--print-format", "%v", @resource[:name]
+    output.chomp
+  end
+
+  # Querys the pacman master list for information about the package.
+  def query
+    begin
+      output = pacman("-Qi", @resource[:name])
+
+      if output =~ /Version.*:\s(.+)/
+        return { :ensure => $1 }
+      end
+    rescue Puppet::ExecutionFailure
+      return {
+        :ensure => :purged,
+        :status => 'missing',
+        :name => @resource[:name],
+        :error => 'ok',
+      }
+    end
+    nil
+  end
+
+  # Removes a package from the system.
+  def uninstall
+    pacman "--noconfirm", "--noprogressbar", "-R", @resource[:name]
+  end
+end