puppet-retrospec 1.5.0 → 1.6.0

data/vendor/gems/puppet-4.5.2/lib/puppet/provider/package/aix.rb

@@ -1,152 +0,0 @@
-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
-
-    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/gems/puppet-4.5.2/lib/puppet/provider/package/appdmg.rb

@@ -1,110 +0,0 @@
-# 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's 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}"
-    File.open("/var/db/.puppet_appdmg_installed_#{name}", "w") 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 DMG's must specify a package source."
-    end
-    unless name = @resource[:name]
-      self.fail "Mac OS X PKG DMG's must specify a package name."
-    end
-    self.class.installpkgdmg(source,name)
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/provider/package/apple.rb

@@ -1,47 +0,0 @@
-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 builtin 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/gems/puppet-4.5.2/lib/puppet/provider/package/dnf.rb

@@ -1,41 +0,0 @@
-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']
-
-  # 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/gems/puppet-4.5.2/lib/puppet/provider/package/gem.rb

@@ -1,169 +0,0 @@
-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"]
-    command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
-
-    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