puppet-retrospec 1.5.0 → 1.6.0

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

@@ -0,0 +1,179 @@
+# Puppet package provider for Python's `pip` package management frontend.
+# <http://pip.pypa.io/>
+
+require 'puppet/provider/package'
+require 'puppet/util/http_proxy'
+
+Puppet::Type.type(:package).provide :pip,
+  :parent => ::Puppet::Provider::Package do
+
+  desc "Python packages via `pip`.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip.
+  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 :installable, :uninstallable, :upgradeable, :versionable, :install_options
+
+  # 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 = self.pip_cmd
+    return [] unless pip_cmd
+    execpipe "#{pip_cmd} freeze" do |process|
+      process.collect do |line|
+        next unless options = parse(line)
+        packages << new(options)
+      end
+    end
+
+    # Pip can also upgrade pip, but it's not listed in freeze so need to special case it
+    # Pip list would also show pip installed version, but "pip list" doesn't exist for older versions of pip (E.G v1.0)
+    if version = self.pip_version
+      packages << new({:ensure => version, :name => File.basename(pip_cmd), :provider => name})
+    end
+
+    packages
+  end
+
+  def self.cmd
+    ["pip", "pip-python"]
+  end
+
+  def self.pip_cmd
+    self.cmd.map { |c| which(c) }.find { |c| c != nil }
+  end
+
+  def self.pip_version
+    pip_cmd = self.pip_cmd
+    return nil unless pip_cmd
+
+    execpipe [pip_cmd, '--version'] do |process|
+      process.collect do |line|
+        return line.strip.match(/^pip (\d+\.\d+\.?\d*).*$/)[1]
+      end
+    end
+  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].downcase == provider_pip.name.downcase
+    end
+    return nil
+  end
+
+  # Use pip CLI to look up versions from PyPI repositories, honoring local pip config such as custom repositories
+  def latest
+    return nil unless self.class.pip_cmd
+    if Puppet::Util::Package.versioncmp(self.class.pip_version, '1.5.4') == -1 # a < b
+      return latest_with_old_pip
+    end
+    latest_with_new_pip
+  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}
+    args +=  install_options if @resource[:install_options]
+    if @resource[:source]
+      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
+    # Ensure pip can upgrade pip, which usually puts pip into a new path /usr/local/bin/pip (compared to /usr/bin/pip)
+    # The path to pip needs to be looked up again in the subsequent request. Using the preferred approach as noted
+    # in provider.rb ensures this (copied below for reference)
+    #
+    # @note From provider.rb; It is preferred if the commands are not entered with absolute paths as this allows puppet
+    # to search for them using the PATH variable.
+    if pathname = self.class.cmd.map { |c| which(c) }.find { |c| c != nil }
+      self.class.commands :pip => File.basename(pathname)
+      pip *args
+    else
+      raise e, "Could not locate command #{self.class.cmd.join(' and ')}.", e.backtrace
+    end
+  end
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+  def latest_with_new_pip
+    # Less resource intensive approach for pip version 1.5.4 and above
+    execpipe ["#{self.class.pip_cmd}", "install", "#{@resource[:name]}==versionplease"] do |process|
+      process.collect do |line|
+        # PIP OUTPUT: Could not find a version that satisfies the requirement Django==versionplease (from versions: 1.1.3, 1.8rc1)
+        if line =~ /from versions: /
+          textAfterLastMatch = $'.chomp(")\n")
+          versionList = textAfterLastMatch.split(', ').sort do |x,y|
+            Puppet::Util::Package.versioncmp(x, y)
+          end
+          return versionList.last
+        end
+      end
+      return nil
+    end
+  end
+
+  def latest_with_old_pip
+    Dir.mktmpdir("puppet_pip") do |dir|
+      execpipe ["#{self.class.pip_cmd}", "install", "#{@resource[:name]}", "-d", "#{dir}", "-v"] do |process|
+        process.collect do |line|
+          # PIP OUTPUT: Using version 0.10.1 (newest of versions: 0.10.1, 0.10, 0.9, 0.8.1, 0.8, 0.7.2, 0.7.1, 0.7, 0.6.1, 0.6, 0.5.2, 0.5.1, 0.5, 0.4, 0.3.1, 0.3, 0.2, 0.1)
+          if line =~ /Using version (.+?) \(newest of versions/
+            return $1
+          end
+        end
+        return nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# Puppet package provider for Python's `pip3` package management frontend.
+# <http://pip.pypa.io/>
+
+require 'puppet/provider/package/pip'
+
+Puppet::Type.type(:package).provide :pip3,
+  :parent => :pip do
+
+  desc "Python packages via `pip3`.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip3.
+  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 :installable, :uninstallable, :upgradeable, :versionable, :install_options
+
+  def self.cmd
+    ["pip3"]
+  end
+end

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

@@ -0,0 +1,249 @@
+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."
+  # https://docs.oracle.com/cd/E19963-01/html/820-6572/managepkgs.html
+  # A few notes before we start:
+  # Opensolaris pkg has two slightly different formats (as of now.)
+  # The first one is what is distributed with the Solaris 11 Express 11/10 dvd
+  # The latest one is what you get when you update package.
+  # To make things more interesting, pkg version just returns a sha sum.
+  # dvd:     pkg version => 052adf36c3f4
+  # updated: pkg version => 630e1ffc7a19
+  # Thankfully, Solaris has not changed the commands to be used.
+  # TODO: We still have to allow packages to specify a preferred publisher.
+
+  has_feature :versionable
+
+  has_feature :upgradable
+
+  has_feature :holdable
+
+  commands :pkg => "/usr/bin/pkg"
+
+  confine :osfamily => :solaris
+
+  defaultfor :osfamily => :solaris, :kernelrelease => ['5.11', '5.12']
+
+  def self.instances
+    pkg(:list, '-Hv').split("\n").map{|l| new(parse_line(l))}
+  end
+
+  # The IFO flag field is just what it names, the first field can have either
+  # i_nstalled or -, and second field f_rozen or -, and last
+  # o_bsolate or r_rename or -
+  # so this checks if the installed field is present, and also verifies that
+  # if not the field is -, else we don't know what we are doing and exit with
+  # out doing more damage.
+  def self.ifo_flag(flags)
+    (
+      case flags[0..0]
+      when 'i'
+        {:status => 'installed'}
+      when '-'
+        {:status => 'known'}
+      else
+        raise ArgumentError, 'Unknown format %s: %s[%s]' % [self.name, flags, flags[0..0]]
+      end
+    ).merge(
+      case flags[1..1]
+      when 'f'
+        {:ensure => 'held'}
+      when '-'
+        {}
+      else
+        raise ArgumentError, 'Unknown format %s: %s[%s]' % [self.name, flags, flags[1..1]]
+      end
+    )
+  end
+
+  # The UFOXI field is the field present in the older pkg
+  # (solaris 2009.06 - snv151a)
+  # similar to IFO, UFOXI is also an either letter or -
+  # u_pdate indicates that an update for the package is available.
+  # f_rozen(n/i) o_bsolete x_cluded(n/i) i_constrained(n/i)
+  # note that u_pdate flag may not be trustable due to constraints.
+  # so we dont rely on it
+  # Frozen was never implemented in UFOXI so skipping frozen here.
+  def self.ufoxi_flag(flags)
+    {}
+  end
+
+  # pkg state was present in the older version of pkg (with UFOXI) but is
+  # no longer available with the IFO field version. When it was present,
+  # it was used to indicate that a particular version was present (installed)
+  # and later versions were known. Note that according to the pkg man page,
+  # known never lists older versions of the package. So we can rely on this
+  # field to make sure that if a known is present, then the pkg is upgradable.
+  def self.pkg_state(state)
+    case state
+    when /installed/
+      {:status => 'installed'}
+    when /known/
+      {:status => 'known'}
+    else
+      raise ArgumentError, 'Unknown format %s: %s' % [self.name, state]
+    end
+  end
+
+  # Here is (hopefully) the only place we will have to deal with multiple
+  # formats of output for different pkg versions.
+  def self.parse_line(line)
+    (case line.chomp
+    # FMRI                                                                         IFO
+    # pkg://omnios/SUNWcs@0.5.11,5.11-0.151008:20131204T022241Z                    ---
+    when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(...)$'
+      {:publisher => $1, :name => $2, :ensure => $3}.merge ifo_flag($4)
+
+    # FMRI                                                             STATE      UFOXI
+    # pkg://solaris/SUNWcs@0.5.11,5.11-0.151.0.1:20101105T001108Z      installed  u----
+    when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(\S+) +(.....)$'
+      {:publisher => $1, :name => $2, :ensure => $3}.merge pkg_state($4).merge(ufoxi_flag($5))
+
+    else
+      raise ArgumentError, 'Unknown line format %s: %s' % [self.name, line]
+    end).merge({:provider => self.name})
+  end
+
+  def hold
+    pkg(:freeze, @resource[:name])
+  end
+
+  def unhold
+    r = exec_cmd(command(:pkg), 'unfreeze', @resource[:name])
+    raise Puppet::Error, "Unable to unfreeze #{r[:out]}" unless [0,4].include? r[:exit]
+  end
+
+  def insync?(is)
+    # this is called after the generic version matching logic (insync? for the
+    # type), so we only get here if should != is, and 'should' is a version
+    # number. 'is' might not be, though.
+    should = @resource[:ensure]
+    # NB: it is apparently possible for repository administrators to publish
+    # packages which do not include build or branch versions, but component
+    # version must always be present, and the timestamp is added by pkgsend
+    # publish.
+    if /^[0-9.]+(,[0-9.]+)?(-[0-9.]+)?:[0-9]+T[0-9]+Z$/ !~ should
+      # We have a less-than-explicit version string, which we must accept for
+      # backward compatibility. We can find the real version this would match
+      # by asking pkg for the all matching versions, and selecting the first
+      # installable one [0]; this can change over time when remote repositories
+      # are updated, but the principle of least astonishment should still hold:
+      # if we allow users to specify less-than-explicit versions, the
+      # functionality should match that of the package manager.
+      #
+      # [0]: we could simply get the newest matching version with 'pkg list
+      # -n', but that isn't always correct, since it might not be installable.
+      # If that were the case we could potentially end up returning false for
+      # insync? here but not actually changing the package version in install
+      # (ie. if the currently installed version is the latest matching version
+      # that is installable, we would falsely conclude here that since the
+      # installed version is not the latest matching version, we're not in
+      # sync).  'pkg list -a' instead of '-n' would solve this, but
+      # unfortunately it doesn't consider downgrades 'available' (eg. with
+      # installed foo@1.0, list -a foo@0.9 would fail).
+      name = @resource[:name]
+      potential_matches = pkg(:list, '-Hvfa', "#{name}@#{should}").split("\n").map{|l|self.class.parse_line(l)}
+      n = potential_matches.length
+      if n > 1
+        warning("Implicit version #{should} has #{n} possible matches")
+      end
+      potential_matches.each{ |p|
+        command = is == :absent ? 'install' : 'update'
+        status = exec_cmd(command(:pkg), command, '-n', "#{name}@#{p[:ensure]}")[:exit]
+        case status
+        when 4
+          # if the first installable match would cause no changes, we're in sync
+          return true
+        when 0
+          warning("Selecting version '#{p[:ensure]}' for implicit '#{should}'")
+          @resource[:ensure] = p[:ensure]
+          return false
+        end
+      }
+      raise Puppet::DevError, "No version of #{name} matching #{should} is installable, even though the package is currently installed"
+    end
+
+    false
+  end
+
+  # Return the version of the package. Note that the bug
+  # http://defect.opensolaris.org/bz/show_bug.cgi?id=19159%
+  # notes that we can't use -Ha for the same even though the manual page reads that way.
+  def latest
+    lines = pkg(:list, "-Hvn", @resource[:name]).split("\n")
+
+    # remove certificate expiration warnings from the output, but report them
+    cert_warnings = lines.select { |line| line =~ /^Certificate/ }
+    unless cert_warnings.empty?
+      Puppet.warning("pkg warning: #{cert_warnings.join(', ')}")
+    end
+
+    lst = lines.select { |line| line !~ /^Certificate/ }.map { |line| self.class.parse_line(line) }
+
+    # Now we know there is a newer version. But is that installable? (i.e are there any constraints?)
+    # return the first known we find. The only way that is currently available is to do a dry run of
+    # pkg update and see if could get installed (`pkg update -n res`).
+    known = lst.find {|p| p[:status] == 'known' }
+    return known[:ensure] if known and exec_cmd(command(:pkg), 'update', '-n', @resource[:name])[:exit].zero?
+
+    # If not, then return the installed, else nil
+    (lst.find {|p| p[:status] == 'installed' } || {})[:ensure]
+  end
+
+  # install the package and accept all licenses.
+  def install(nofail = false)
+    name = @resource[:name]
+    should = @resource[:ensure]
+    # always unhold if explicitly told to install/update
+    self.unhold
+    is = self.query
+    if is[:ensure].to_sym == :absent
+      command = 'install'
+    else
+      command = 'update'
+    end
+    args = ['--accept']
+    if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemrelease), '11.2') >= 0
+      args.push('--sync-actuators-timeout', '900')
+    end
+    unless should.is_a? Symbol
+      name += "@#{should}"
+    end
+    r = exec_cmd(command(:pkg), command, *args, name)
+    return r if nofail
+    raise Puppet::Error, "Unable to update #{r[:out]}" if r[:exit] != 0
+  end
+
+  # uninstall the package. The complication comes from the -r_ecursive flag which is no longer
+  # present in newer package version.
+  def uninstall
+    cmd = [:uninstall]
+    case (pkg :version).chomp
+    when /052adf36c3f4/
+      cmd << '-r'
+    end
+    cmd << @resource[:name]
+    pkg cmd
+  end
+
+  # update the package to the latest version available
+  def update
+    r = install(true)
+    # 4 == /No updates available for this image./
+    return if [0,4].include? r[:exit]
+    raise Puppet::Error, "Unable to update #{r[:out]}"
+  end
+
+  # list a specific package
+  def query
+    r = exec_cmd(command(:pkg), 'list', '-Hv', @resource[:name])
+    return {:ensure => :absent, :name => @resource[:name]} if r[:exit] != 0
+    self.class.parse_line(r[:out])
+  end
+
+  def exec_cmd(*cmd)
+    output = Puppet::Util::Execution.execute(cmd, :failonfail => false, :combine => true)
+    {:out => output, :exit => $CHILD_STATUS.exitstatus}
+  end
+end

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

@@ -0,0 +1,152 @@
+#
+# 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 'puppet/util/plist'
+require 'puppet/util/http_proxy'
+
+Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Package do
+  desc "Package management based on Apple's Installer.app and DiskUtility.app.
+
+    This provider 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, and Puppet will install all of them. Subdirectories
+    are not checked for packages.
+
+    This provider can also accept plain .pkg (but not .mpkg) files in addition
+    to .dmg files.
+
+    Notes:
+
+    * The `source` attribute is mandatory. It must be either a local disk path
+      or an HTTP, HTTPS, or FTP URL to the package.
+    * The `name` of the resource must be the filename (without path) of the DMG file.
+    * When installing the packages from a DMG, this provider writes a file to
+      disk at `/var/db/.puppet_pkgdmg_installed_NAME`. If that file is present,
+      Puppet assumes all packages from that DMG are already installed.
+    * This provider is not versionable and uses DMG filenames to determine
+      whether a package has been installed. Thus, to install new a version of a
+      package, you must create a new DMG with a different filename."
+
+  confine :operatingsystem => :darwin
+  confine :feature         => :cfpropertylist
+  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.
+    Puppet::FileSystem.open("/var/db/.puppet_pkgdmg_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)
+    unless Puppet::Util::HttpProxy.no_proxy?(source)
+      http_proxy_host = Puppet::Util::HttpProxy.http_proxy_host
+      http_proxy_port = Puppet::Util::HttpProxy.http_proxy_port
+    end
+
+    unless source =~ /\.dmg$/i || source =~ /\.pkg$/i
+      raise Puppet::Error.new("Mac OS X PKG DMGs must specify a source string ending in .dmg or flat .pkg file")
+    end
+    require 'open-uri' # Dead code; this is never used. The File.open call 20-ish lines south of here used to be Kernel.open but changed in '09. -NF
+    cached_source = source
+    tmpdir = Dir.mktmpdir
+    ext = /(\.dmg|\.pkg)$/i.match(source)[0]
+    begin
+      if %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ cached_source
+        cached_source = File.join(tmpdir, "#{name}#{ext}")
+        args = [ "-o", cached_source, "-C", "-", "-L", "-s", "--fail", "--url", source ]
+        if http_proxy_host and http_proxy_port
+          args << "--proxy" << "#{http_proxy_host}:#{http_proxy_port}"
+        elsif http_proxy_host and not http_proxy_port
+          args << "--proxy" << http_proxy_host
+        end
+      begin
+        curl *args
+          Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(" ")})"
+        rescue Puppet::ExecutionFailure
+          Puppet.debug "curl #{args.join(" ")} did not transfer [#{name}].  Falling back to local file." # This used to fall back to open-uri. -NF
+          cached_source = source
+        end
+      end
+
+      if source =~ /\.dmg$/i
+        # If you fix this to use open-uri again, you must update the docs above. -NF
+        File.open(cached_source) do |dmg|
+          xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-noidme", "-mountrandom", "/tmp", dmg.path
+          hdiutil_info = Puppet::Util::Plist.parse_plist(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, true)
+    end
+  end
+
+  def query
+    if Puppet::FileSystem.exist?("/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 DMGs must specify a package source.")
+    end
+    unless name = @resource[:name]
+      raise Puppet::Error.new("Mac OS X PKG DMGs must specify a package name.")
+    end
+    self.class.installpkgdmg(source,name)
+  end
+end