puppet-retrospec 1.5.0 → 1.6.0

data/vendor/pup410/lib/puppet/provider/package/aix.rb

@@ -0,0 +1,152 @@
+require 'puppet/provider/package'
+require 'puppet/util/package'
+
+Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package do
+  desc "Installation from an AIX software directory, using the AIX `installp`
+       command.  The `source` parameter is required for this provider, and should
+       be set to the absolute path (on the puppet agent machine) of a directory
+       containing one or more BFF package files.
+
+       The `installp` command will generate a table of contents file (named `.toc`)
+       in this directory, and the `name` parameter (or resource title) that you
+       specify for your `package` resource must match a package name that exists
+       in the `.toc` file.
+
+       Note that package downgrades are *not* supported; if your resource specifies
+       a specific version number and there is already a newer version of the package
+       installed on the machine, the resource will fail with an error message."
+
+  # The commands we are using on an AIX box are installed standard
+  # (except nimclient) nimclient needs the bos.sysmgt.nim.client fileset.
+  commands    :lslpp => "/usr/bin/lslpp",
+              :installp => "/usr/sbin/installp"
+
+  # AIX supports versionable packages with and without a NIM server
+  has_feature :versionable
+
+  confine  :operatingsystem => [ :aix ]
+  defaultfor :operatingsystem => :aix
+
+  attr_accessor   :latest_info
+
+  def self.srclistcmd(source)
+    [ command(:installp), "-L", "-d", source ]
+  end
+
+  def self.prefetch(packages)
+    raise Puppet::Error, "The aix provider can only be used by root" if Process.euid != 0
+
+    return unless packages.detect { |name, package| package.should(:ensure) == :latest }
+
+    sources = packages.collect { |name, package| package[:source] }.uniq.compact
+
+    updates = {}
+    sources.each do |source|
+      execute(self.srclistcmd(source)).each_line do |line|
+        if line =~ /^[^#][^:]*:([^:]*):([^:]*)/
+          current = {}
+          current[:name]    = $1
+          current[:version] = $2
+          current[:source]  = source
+
+          if updates.key?(current[:name])
+            previous = updates[current[:name]]
+
+            updates[ current[:name] ] = current unless Puppet::Util::Package.versioncmp(previous[:version], current[:version]) == 1
+
+          else
+            updates[current[:name]] = current
+          end
+        end
+      end
+    end
+
+    packages.each do |name, package|
+      if info = updates[package[:name]]
+        package.provider.latest_info = info[0]
+      end
+    end
+  end
+
+  def uninstall
+    # Automatically process dependencies when installing/uninstalling
+    # with the -g option to installp.
+    installp "-gu", @resource[:name]
+
+    # installp will return an exit code of zero even if it didn't uninstall
+    # anything... so let's make sure it worked.
+    unless query().nil?
+      self.fail "Failed to uninstall package '#{@resource[:name]}'"
+    end
+  end
+
+  def install(useversion = true)
+    unless source = @resource[:source]
+      self.fail "A directory is required which will be used to find packages"
+    end
+
+    pkg = @resource[:name]
+
+    pkg += " #{@resource.should(:ensure)}" if (! @resource.should(:ensure).is_a? Symbol) and useversion
+
+    output = installp "-acgwXY", "-d", source, pkg
+
+    # If the package is superseded, it means we're trying to downgrade and we
+    # can't do that.
+    if output =~ /^#{Regexp.escape(@resource[:name])}\s+.*\s+Already superseded by.*$/
+      self.fail "aix package provider is unable to downgrade packages"
+    end
+  end
+
+  def self.pkglist(hash = {})
+    cmd = [command(:lslpp), "-qLc"]
+
+    if name = hash[:pkgname]
+      cmd << name
+    end
+
+    begin
+      list = execute(cmd).scan(/^[^#][^:]*:([^:]*):([^:]*)/).collect { |n,e|
+        { :name => n, :ensure => e, :provider => self.name }
+      }
+    rescue Puppet::ExecutionFailure => detail
+      if hash[:pkgname]
+        return nil
+      else
+        raise Puppet::Error, "Could not list installed Packages: #{detail}", detail.backtrace
+      end
+    end
+
+    if hash[:pkgname]
+      return list.shift
+    else
+      return list
+    end
+  end
+
+  def self.instances
+    pkglist.collect do |hash|
+      new(hash)
+    end
+  end
+
+  def latest
+    upd = latest_info
+
+    unless upd.nil?
+      return "#{upd[:version]}"
+    else
+      raise Puppet::DevError, "Tried to get latest on a missing package" if properties[:ensure] == :absent
+
+      return properties[:ensure]
+    end
+  end
+
+  def query
+    self.class.pkglist(:pkgname => @resource[:name])
+  end
+
+  def update
+    self.install(false)
+  end
+end

data/vendor/pup410/lib/puppet/provider/package/appdmg.rb

@@ -0,0 +1,110 @@
+# Jeff McCune <mccune.jeff@gmail.com>
+# Changed to app.dmg by: Udo Waechter <root@zoide.net>
+# Mac OS X Package Installer which handles application (.app)
+# bundles inside an Apple Disk Image.
+#
+# Motivation: DMG files provide a true HFS file system
+# and are easier to manage.
+#
+# Note: the 'apple' Provider checks for the package name
+# in /L/Receipts.  Since we possibly install multiple apps from
+# a single source, we treat the source .app.dmg file as the package name.
+# As a result, we store installed .app.dmg file names
+# in /var/db/.puppet_appdmg_installed_<name>
+
+require 'puppet/provider/package'
+require 'puppet/util/plist' if Puppet.features.cfpropertylist?
+Puppet::Type.type(:package).provide(:appdmg, :parent => Puppet::Provider::Package) do
+  desc "Package management which copies application bundles to a target."
+
+  confine :operatingsystem => :darwin
+  confine :feature         => :cfpropertylist
+
+  commands :hdiutil => "/usr/bin/hdiutil"
+  commands :curl => "/usr/bin/curl"
+  commands :ditto => "/usr/bin/ditto"
+
+  # JJM We store a cookie for each installed .app.dmg in /var/db
+  def self.instances_by_name
+    Dir.entries("/var/db").find_all { |f|
+      f =~ /^\.puppet_appdmg_installed_/
+    }.collect do |f|
+      name = f.sub(/^\.puppet_appdmg_installed_/, '')
+      yield name if block_given?
+      name
+    end
+  end
+
+  def self.instances
+    instances_by_name.collect do |name|
+      new(:name => name, :provider => :appdmg, :ensure => :installed)
+    end
+  end
+
+  def self.installapp(source, name, orig_source)
+    appname = File.basename(source);
+    ditto "--rsrc", source, "/Applications/#{appname}"
+    Puppet::FileSystem.open("/var/db/.puppet_appdmg_installed_#{name}", nil, "w:UTF-8") do |t|
+      t.print "name: '#{name}'\n"
+      t.print "source: '#{orig_source}'\n"
+    end
+  end
+
+  def self.installpkgdmg(source, name)
+    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", "-", "-L", "-s", "--url", source
+          Puppet.debug "Success: curl transferred [#{name}]"
+        rescue Puppet::ExecutionFailure
+          Puppet.debug "curl did not transfer [#{name}].  Falling back to slower open-uri transfer methods."
+          cached_source = source
+        end
+      end
+
+      open(cached_source) do |dmg|
+        xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", dmg.path
+          ptable = Puppet::Util::Plist::parse_plist(xml_str)
+          # JJM Filter out all mount-paths into a single array, discard the rest.
+          mounts = ptable['system-entities'].collect { |entity|
+            entity['mount-point']
+          }.select { |mountloc|; mountloc }
+          begin
+            found_app = false
+            mounts.each do |fspath|
+              Dir.entries(fspath).select { |f|
+                f =~ /\.app$/i
+              }.each do |pkg|
+                found_app = true
+                installapp("#{fspath}/#{pkg}", name, source)
+              end
+            end
+            Puppet.debug "Unable to find .app in .appdmg. #{name} will not be installed." if !found_app
+          ensure
+            hdiutil "eject", mounts[0]
+          end
+      end
+    ensure
+      FileUtils.remove_entry_secure(tmpdir, true)
+    end
+  end
+
+  def query
+    Puppet::FileSystem.exist?("/var/db/.puppet_appdmg_installed_#{@resource[:name]}") ? {:name => @resource[:name], :ensure => :present} : nil
+  end
+
+  def install
+    source = nil
+    unless source = @resource[:source]
+      self.fail "Mac OS X PKG DMGs must specify a package source."
+    end
+    unless name = @resource[:name]
+      self.fail "Mac OS X PKG DMGs must specify a package name."
+    end
+    self.class.installpkgdmg(source,name)
+  end
+end

data/vendor/pup410/lib/puppet/provider/package/apple.rb

@@ -0,0 +1,47 @@
+require 'puppet/provider/package'
+
+# OS X Packaging sucks.  We can install packages, but that's about it.
+Puppet::Type.type(:package).provide :apple, :parent => Puppet::Provider::Package do
+  desc "Package management based on OS X's built-in packaging system.  This is
+    essentially the simplest and least functional package system in existence --
+    it only supports installation; no deletion or upgrades.  The provider will
+    automatically add the `.pkg` extension, so leave that off when specifying
+    the package name."
+
+  confine :operatingsystem => :darwin
+  commands :installer => "/usr/sbin/installer"
+
+  def self.instances
+    instance_by_name.collect do |name|
+      self.new(
+        :name     => name,
+        :provider => :apple,
+        :ensure   => :installed
+      )
+    end
+  end
+
+  def self.instance_by_name
+    Dir.entries("/Library/Receipts").find_all { |f|
+      f =~ /\.pkg$/
+    }.collect { |f|
+      name = f.sub(/\.pkg/, '')
+      yield name if block_given?
+
+      name
+    }
+  end
+
+  def query
+    Puppet::FileSystem.exist?("/Library/Receipts/#{@resource[:name]}.pkg") ? {:name => @resource[:name], :ensure => :present} : nil
+  end
+
+  def install
+    source = nil
+    unless source = @resource[:source]
+      self.fail "Mac OS X packages must specify a package source"
+    end
+
+    installer "-pkg", source, "-target", "/"
+  end
+end

data/vendor/pup410/lib/puppet/provider/package/dnf.rb

@@ -0,0 +1,46 @@
+Puppet::Type.type(:package).provide :dnf, :parent => :yum do
+  desc "Support via `dnf`.
+
+  Using this provider's `uninstallable` feature will not remove dependent packages. To
+  remove dependent packages with this provider use the `purgeable` feature, but note this
+  feature is destructive and should be used with the utmost care.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to dnf.
+  These options should be specified as a string (e.g. '--flag'), a hash (e.g. {'--flag' => 'value'}),
+  or an array where each element is either a string or a hash."
+
+  has_feature :install_options, :versionable, :virtual_packages
+
+  commands :cmd => "dnf", :rpm => "rpm"
+
+  # Note: this confine was borrowed from the Yum provider. The
+  # original purpose (from way back in 2007) was to make sure we
+  # never try to use RPM on a machine without it. We think this
+  # has probably become obsolete with the way `commands` work, so
+  # we should investigate removing it at some point.
+  if command('rpm')
+    confine :true => begin
+      rpm('--version')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  defaultfor :operatingsystem => :fedora, :operatingsystemmajrelease => ['22', '23', '24', '25']
+
+  def self.update_command
+    # In DNF, update is deprecated for upgrade
+    'upgrade'
+  end
+
+  # The value to pass to DNF as its error output level.
+  # DNF differs from Yum slightly with regards to error outputting.
+  #
+  # @param None
+  # @return [String]
+  def self.error_level
+    '1'
+  end
+end

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

@@ -0,0 +1,174 @@
+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.
+
+    This provider supports the `install_options` and `uninstall_options` attributes,
+    which allow command-line flags to be passed to the gem command.
+    These options should be specified as a string (e.g. '--flag'), a hash (e.g. {'--flag' => 'value'}),
+    or an array where each element is either a string or a hash."
+
+  has_feature :versionable, :install_options, :uninstall_options
+
+  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}", detail.backtrace
+    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+\((.+)\)/
+      gem_name = $1
+      versions = $2.split(/,\s*/)
+      {
+        :name     => gem_name,
+        :ensure   => versions.map{|v| v.split[0]},
+        :provider => name
+      }
+    else
+      Puppet.warning "Could not match #{desc}" unless desc.chomp.empty?
+      nil
+    end
+  end
+
+  def self.instances(justme = false)
+    gemlist(:local => true).collect do |hash|
+      new(hash)
+    end
+  end
+
+  def insync?(is)
+    return false unless is && is != :absent
+
+    begin
+      dependency = Gem::Dependency.new('', resource[:ensure])
+    rescue ArgumentError
+      # Bad requirements will cause an error during gem command invocation, so just return not in sync
+      return false
+    end
+
+    is = [is] unless is.is_a? Array
+
+    # Check if any version matches the dependency
+    is.any? { |version| dependency.match?('', version) }
+  end
+
+  def install(useversion = true)
+    command = [command(:gemcmd), "install"]
+    if Puppet.features.microsoft_windows?
+      version = resource[:ensure]
+      command << "-v" << %Q["#{version}"] if (! resource[:ensure].is_a? Symbol) and useversion
+    else
+      command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
+    end
+
+    if source = resource[:source]
+      begin
+        uri = URI.parse(source)
+      rescue => detail
+        self.fail Puppet::Error, "Invalid source '#{uri}': #{detail}", 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
+        # check whether it's an absolute file path to help Windows out
+        if Puppet::Util.absolute_path?(source)
+          command << source
+        else
+          # interpret it as a gem repository
+          command << "--source" << "#{source}" << resource[:name]
+        end
+      end
+    else
+      command << "--no-rdoc" << "--no-ri" << resource[:name]
+    end
+
+    command += install_options if resource[:install_options]
+
+    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
+    command = [command(:gemcmd), "uninstall"]
+    command << "--executables" << "--all" << resource[:name]
+
+    command += uninstall_options if resource[:uninstall_options]
+
+    output = execute(command)
+
+    # Apparently some stupid gem versions don't exit non-0 on failure
+    self.fail "Could not uninstall: #{output.chomp}" if output.include?("ERROR")
+  end
+
+  def update
+    self.install(false)
+  end
+
+  def install_options
+    join_options(resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(resource[:uninstall_options])
+  end
+end