openvox 7.37.1

data/lib/puppet/provider/package/rpm.rb

@@ -0,0 +1,250 @@
+require_relative '../../../puppet/provider/package'
+require_relative '../../../puppet/util/rpm_compare'
+
+# RPM packaging.  Should work anywhere that has rpm installed.
+Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Provider::Package do
+  # provides Rpm parsing and comparison
+  include Puppet::Util::RpmCompare
+
+  desc "RPM packaging support; should work anywhere with a working `rpm`
+    binary.
+
+    This provider supports the `install_options` and `uninstall_options`
+    attributes, which allow command-line flags to be passed to rpm.
+    These options should be specified as an array where each element is either a string or a hash."
+
+  has_feature :versionable
+  has_feature :install_options
+  has_feature :uninstall_options
+  has_feature :virtual_packages
+  has_feature :install_only
+
+  # Note: self:: is required here to keep these constants in the context of what will
+  # eventually become this Puppet::Type::Package::ProviderRpm class.
+  # The query format by which we identify installed packages
+  self::NEVRA_FORMAT = %Q{%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n}
+  self::NEVRA_REGEX  = %r{^'?(\S+) (\S+) (\S+) (\S+) (\S+)$}
+  self::NEVRA_FIELDS = [:name, :epoch, :version, :release, :arch]
+  self::MULTIVERSION_SEPARATOR = "; "
+
+  commands :rpm => "rpm"
+
+  if command('rpm')
+    confine :true => begin
+      rpm('--version')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  def self.current_version
+    return @current_version unless @current_version.nil?
+    output = rpm "--version"
+    @current_version = output.gsub('RPM version ', '').strip
+  end
+
+  # rpm < 4.1 does not support --nosignature
+  def self.nosignature
+    '--nosignature' unless Puppet::Util::Package.versioncmp(current_version, '4.1') < 0
+  end
+
+  # rpm < 4.0.2 does not support --nodigest
+  def self.nodigest
+    '--nodigest' unless Puppet::Util::Package.versioncmp(current_version, '4.0.2') < 0
+  end
+
+  def self.instances
+    packages = []
+
+    # list out all of the packages
+    begin
+      execpipe("#{command(:rpm)} -qa #{nosignature} #{nodigest} --qf '#{self::NEVRA_FORMAT}' | sort") { |process|
+        # now turn each returned line into a package object
+        nevra_to_multiversion_hash(process).each { |hash| packages << new(hash) }
+      }
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error, _("Failed to list packages"), $!.backtrace
+    end
+
+    packages
+  end
+
+  # Find the fully versioned package name and the version alone. Returns
+  # a hash with entries :instance => fully versioned package name, and
+  # :ensure => version-release
+  def query
+    #NOTE: Prior to a fix for issue 1243, this method potentially returned a cached value
+    #IF YOU CALL THIS METHOD, IT WILL CALL RPM
+    #Use get(:property) to check if cached values are available
+    cmd = ["-q",  @resource[:name], "#{self.class.nosignature}", "#{self.class.nodigest}", "--qf", "#{self.class::NEVRA_FORMAT}"]
+
+    begin
+      output = rpm(*cmd)
+    rescue Puppet::ExecutionFailure
+      return nil unless @resource.allow_virtual?
+
+      # rpm -q exits 1 if package not found
+      # retry the query for virtual packages
+      cmd << '--whatprovides'
+      begin
+        output = rpm(*cmd)
+      rescue Puppet::ExecutionFailure
+        # couldn't find a virtual package either
+        return nil
+      end
+    end
+    @property_hash.update(self.class.nevra_to_multiversion_hash(output))
+
+    @property_hash.dup
+  end
+
+  # Here we just retrieve the version from the file specified in the source.
+  def latest
+    source = @resource[:source]
+    unless source
+      @resource.fail _("RPMs must specify a package source")
+    end
+
+    cmd = [command(:rpm), "-q", "--qf", "#{self.class::NEVRA_FORMAT}", "-p", source]
+    h = self.class.nevra_to_multiversion_hash(execute(cmd))
+    h[:ensure]
+  rescue Puppet::ExecutionFailure => e
+    raise Puppet::Error, e.message, e.backtrace
+  end
+
+  def install
+    source = @resource[:source]
+    unless source
+      @resource.fail _("RPMs must specify a package source")
+    end
+
+    version =  @property_hash[:ensure]
+
+    # RPM gets upset if you try to install an already installed package
+    return if @resource.should(:ensure) == version || (@resource.should(:ensure) == :latest && version == latest)
+
+    flag = ["-i"]
+    flag = ["-U", "--oldpackage"] if version && (version != :absent && version != :purged)
+    flag += install_options if resource[:install_options]
+    rpm flag, source
+  end
+
+  def uninstall
+    query
+    # If version and release (or only version) is specified in the resource,
+    # uninstall using them, otherwise uninstall using only the name of the package.
+    name    = get(:name)
+    version = get(:version)
+    release = get(:release)
+    nav = "#{name}-#{version}"
+    nvr = "#{nav}-#{release}"
+    if @resource[:name].start_with? nvr
+      identifier = nvr
+    else
+      if @resource[:name].start_with? nav
+        identifier = nav
+      else
+        if @resource[:install_only]
+          identifier = get(:ensure).split(self.class::MULTIVERSION_SEPARATOR).map { |ver| "#{name}-#{ver}" }
+        else
+          identifier = name
+        end
+      end
+    end
+    # If an arch is specified in the resource, uninstall that arch,
+    # otherwise uninstall the arch returned by query.
+    # If multiple arches are installed and arch is not specified,
+    # this will uninstall all of them after successive runs.
+    #
+    # rpm prior to 4.2.1 cannot accept architecture as part of the package name.
+    unless Puppet::Util::Package.versioncmp(self.class.current_version, '4.2.1') < 0
+      arch = ".#{get(:arch)}"
+      if @resource[:name].end_with? arch
+        identifier += arch
+      end
+    end
+
+    flag = ['-e']
+    flag += uninstall_options if resource[:uninstall_options]
+    rpm flag, identifier
+  end
+
+  def update
+    self.install
+  end
+
+  def install_options
+    join_options(resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(resource[:uninstall_options])
+  end
+
+  def insync?(is)
+    return false if [:purged, :absent].include?(is)
+    return false if is.include?(self.class::MULTIVERSION_SEPARATOR) && !@resource[:install_only]
+
+    should = resource[:ensure]
+    is.split(self.class::MULTIVERSION_SEPARATOR).any? do |version|
+      0 == rpm_compareEVR(should, version)
+    end
+  end
+
+  private
+  # @param line [String] one line of rpm package query information
+  # @return [Hash] of NEVRA_FIELDS strings parsed from package info
+  # or an empty hash if we failed to parse
+  # @api private
+  def self.nevra_to_hash(line)
+    line.strip!
+    hash = {}
+
+    match = self::NEVRA_REGEX.match(line)
+    if match
+      self::NEVRA_FIELDS.zip(match.captures) { |f, v| hash[f] = v }
+      hash[:provider] = self.name
+      hash[:ensure] = "#{hash[:version]}-#{hash[:release]}"
+      hash[:ensure].prepend("#{hash[:epoch]}:") if hash[:epoch] != '0'
+    else
+      Puppet.debug("Failed to match rpm line #{line}")
+    end
+
+    return hash
+  end
+
+  # @param line [String] multiple lines of rpm package query information
+  # @return list of [Hash] of NEVRA_FIELDS strings parsed from package info
+  # or an empty list if we failed to parse
+  # @api private
+  def self.nevra_to_multiversion_hash(multiline)
+    list = []
+    multiversion_hash = {}
+    multiline.each_line do |line|
+      hash = self.nevra_to_hash(line)
+      if !hash.empty?
+        if multiversion_hash.empty?
+          multiversion_hash = hash.dup
+          next
+        end
+
+        if multiversion_hash[:name] != hash[:name]
+          list << multiversion_hash
+          multiversion_hash = hash.dup
+          next
+        end
+
+        if !multiversion_hash[:ensure].include?(hash[:ensure])
+          multiversion_hash[:ensure].concat("#{self::MULTIVERSION_SEPARATOR}#{hash[:ensure]}")
+        end
+      end
+    end
+    list << multiversion_hash if multiversion_hash
+    if list.size == 1
+      return list[0]
+    end
+    return list
+  end
+end

data/lib/puppet/provider/package/rug.rb

@@ -0,0 +1,51 @@
+Puppet::Type.type(:package).provide :rug, :parent => :rpm do
+  desc "Support for suse `rug` package manager."
+
+  has_feature :versionable
+
+  commands :rug => "/usr/bin/rug"
+  commands :rpm => "rpm"
+  confine    :operatingsystem => [:suse, :sles]
+
+  # Install a package using 'rug'.
+  def install
+    should = @resource.should(:ensure)
+    self.debug "Ensuring => #{should}"
+    wanted = @resource[:name]
+
+    # XXX: We don't actually deal with epochs here.
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      wanted += "-#{should}"
+    end
+    rug "--quiet", :install, "-y", wanted
+
+    unless self.query
+      raise Puppet::ExecutionFailure.new(
+        _("Could not find package %{name}") % { name: self.name }
+      )
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    #rug can only get a list of *all* available packages?
+    output = rug "list-updates"
+
+    if output =~ /#{Regexp.escape @resource[:name]}\s*\|\s*([^\s\|]+)/
+      return $1
+    else
+      # rug didn't find updates, pretend the current
+      # version is the latest
+      return @property_hash[:ensure]
+    end
+  end
+
+  def update
+    # rug install can be used for update, too
+    self.install
+  end
+end

data/lib/puppet/provider/package/sun.rb

@@ -0,0 +1,133 @@
+# Sun packaging.
+
+require_relative '../../../puppet/provider/package'
+
+Puppet::Type.type(:package).provide :sun, :parent => Puppet::Provider::Package do
+  desc "Sun's packaging system.  Requires that you specify the source for
+    the packages you're managing.
+
+    This provider supports the `install_options` attribute, which allows command-line flags to be passed to pkgadd.
+    These options should be specified as an array where each element is either a string
+     or a hash."
+
+  commands :pkginfo => "/usr/bin/pkginfo",
+    :pkgadd => "/usr/sbin/pkgadd",
+    :pkgrm => "/usr/sbin/pkgrm"
+
+  confine :osfamily => :solaris
+  defaultfor :osfamily => :solaris
+
+  has_feature :install_options
+
+  self::Namemap = {
+    "PKGINST"  => :name,
+    "CATEGORY" => :category,
+    "ARCH"     => :platform,
+    "VERSION"  => :ensure,
+    "BASEDIR"  => :root,
+    "VENDOR"   => :vendor,
+    "DESC"     => :description,
+  }
+
+  def self.namemap(hash)
+    self::Namemap.keys.inject({}) do |hsh,k|
+      hsh.merge(self::Namemap[k] => hash[k])
+    end
+  end
+
+  def self.parse_pkginfo(out)
+    # collect all the lines with : in them, and separate them out by ^$
+    pkgs = []
+    pkg = {}
+    out.each_line do |line|
+      case line.chomp
+      when /^\s*$/
+        pkgs << pkg unless pkg.empty?
+        pkg = {}
+      when /^\s*([^:]+):\s+(.+)$/
+        pkg[$1] = $2
+      end
+    end
+    pkgs << pkg unless pkg.empty?
+    pkgs
+  end
+
+  def self.instances
+    parse_pkginfo(pkginfo('-l')).collect do |p|
+      hash = namemap(p)
+      hash[:provider] = :sun
+      new(hash)
+    end
+  end
+
+  # Get info on a package, optionally specifying a device.
+  def info2hash(device = nil)
+    args = ['-l']
+    args << '-d' << device if device
+    args << @resource[:name]
+    begin
+      pkgs = self.class.parse_pkginfo(pkginfo(*args))
+      errmsg = case pkgs.size
+        when 0
+          'No message'
+        when 1
+           pkgs[0]['ERROR']
+      end
+      return self.class.namemap(pkgs[0]) if errmsg.nil?
+      # according to commit 41356a7 some errors do not raise an exception
+      # so even though pkginfo passed, we have to check the actual output
+      raise Puppet::Error, _("Unable to get information about package %{name} because of: %{errmsg}") % { name: @resource[:name], errmsg: errmsg }
+    rescue Puppet::ExecutionFailure
+      return {:ensure => :absent}
+    end
+  end
+
+  # Retrieve the version from the current package file.
+  def latest
+    info2hash(@resource[:source])[:ensure]
+  end
+
+  def query
+    info2hash
+  end
+
+  # only looking for -G now
+  def install
+    #TRANSLATORS Sun refers to the company name, do not translate
+    raise Puppet::Error, _("Sun packages must specify a package source") unless @resource[:source]
+    options = {
+      :adminfile    => @resource[:adminfile],
+      :responsefile => @resource[:responsefile],
+      :source       => @resource[:source],
+      :cmd_options  => @resource[:install_options]
+    }
+    pkgadd prepare_cmd(options)
+  end
+
+  def uninstall
+    pkgrm prepare_cmd(:adminfile => @resource[:adminfile])
+  end
+
+  # Remove the old package, and install the new one.  This will probably
+  # often fail.
+  def update
+    self.uninstall if (@property_hash[:ensure] || info2hash[:ensure]) != :absent
+    self.install
+  end
+
+  def prepare_cmd(opt)
+    [if_have_value('-a', opt[:adminfile]),
+     if_have_value('-r', opt[:responsefile]),
+     if_have_value('-d', opt[:source]),
+     opt[:cmd_options] || [],
+     ['-n', @resource[:name]]].flatten
+  end
+
+  def if_have_value(prefix, value)
+    if value
+      [prefix, value]
+    else
+      []
+    end
+  end
+end

data/lib/puppet/provider/package/sunfreeware.rb

@@ -0,0 +1,9 @@
+# At this point, it's an exact copy of the Blastwave stuff.
+Puppet::Type.type(:package).provide :sunfreeware, :parent => :blastwave, :source => :sun do
+  desc "Package management using sunfreeware.com's `pkg-get` command on Solaris.
+    At this point, support is exactly the same as `blastwave` support and
+    has not actually been tested."
+  commands :pkgget => "pkg-get"
+
+  confine :osfamily => :solaris
+end

data/lib/puppet/provider/package/tdnf.rb

@@ -0,0 +1,28 @@
+Puppet::Type.type(:package).provide :tdnf, :parent => :dnf do
+  desc "Support via `tdnf`.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to tdnf.
+  These options should be spcified 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 => "tdnf", :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 => "PhotonOS" 
+end

data/lib/puppet/provider/package/up2date.rb

@@ -0,0 +1,40 @@
+Puppet::Type.type(:package).provide :up2date, :parent => :rpm, :source => :rpm do
+  desc "Support for Red Hat's proprietary `up2date` package update
+    mechanism."
+
+  commands :up2date => "/usr/sbin/up2date-nox"
+
+  defaultfor :osfamily => :redhat, :lsbdistrelease => ["2.1", "3", "4"]
+
+  confine    :osfamily => :redhat
+
+  # Install a package using 'up2date'.
+  def install
+    up2date "-u", @resource[:name]
+
+    unless self.query
+      raise Puppet::ExecutionFailure.new(
+        _("Could not find package %{name}") % { name: self.name }
+      )
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    #up2date can only get a list of *all* available packages?
+    output = up2date "--showall"
+
+    if output =~ /^#{Regexp.escape @resource[:name]}-(\d+.*)\.\w+/
+      return $1
+    else
+      # up2date didn't find updates, pretend the current
+      # version is the latest
+      return @property_hash[:ensure]
+    end
+  end
+
+  def update
+    # Install in up2date can be used for update, too
+    self.install
+  end
+end

data/lib/puppet/provider/package/urpmi.rb

@@ -0,0 +1,55 @@
+Puppet::Type.type(:package).provide :urpmi, :parent => :rpm, :source => :rpm do
+  desc "Support via `urpmi`."
+  commands :urpmi => "urpmi", :urpmq => "urpmq", :rpm => "rpm", :urpme => "urpme"
+
+  defaultfor :operatingsystem => [:mandriva, :mandrake]
+
+  has_feature :versionable
+
+  def install
+    should = @resource.should(:ensure)
+    self.debug "Ensuring => #{should}"
+    wanted = @resource[:name]
+
+    # XXX: We don't actually deal with epochs here.
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      wanted += "-#{should}"
+    end
+
+    urpmi "--auto", wanted
+
+    unless self.query
+      raise Puppet::Error, _("Package %{name} was not present after trying to install it") % { name: self.name }
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    output = urpmq "-S", @resource[:name]
+
+    if output =~ /^#{Regexp.escape @resource[:name]}\s+:\s+.*\(\s+(\S+)\s+\)/
+      return $1
+    else
+      # urpmi didn't find updates, pretend the current
+      # version is the latest
+      return @resource[:ensure]
+    end
+  end
+
+  def update
+    # Install in urpmi can be used for update, too
+    self.install
+  end
+
+  # For normal package removal the urpmi provider will delegate to the RPM
+  # provider. If the package to remove has dependencies then uninstalling via
+  # rpm will fail, but `urpme` can be used to remove a package and its
+  # dependencies.
+  def purge
+    urpme '--auto', @resource[:name]
+  end
+end

data/lib/puppet/provider/package/windows/exe_package.rb

@@ -0,0 +1,106 @@
+require_relative '../../../../puppet/provider/package/windows/package'
+
+class Puppet::Provider::Package::Windows
+  class ExePackage < Puppet::Provider::Package::Windows::Package
+    attr_reader :uninstall_string
+
+    # registry values to load under each product entry in
+    # HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall
+    # for this provider
+    REG_VALUE_NAMES = [
+      'DisplayVersion',
+      'UninstallString',
+      'ParentKeyName',
+      'Security Update',
+      'Update Rollup',
+      'Hotfix',
+      'WindowsInstaller',
+    ]
+
+    def self.register(path)
+      Puppet::Type::Package::ProviderWindows.paths ||= []
+      Puppet::Type::Package::ProviderWindows.paths << path
+    end
+
+    # Return an instance of the package from the registry, or nil
+    def self.from_registry(name, values)
+      if valid?(name, values)
+        ExePackage.new(
+          get_display_name(values),
+          values['DisplayVersion'],
+          values['UninstallString']
+        )
+      end
+    end
+
+    # Is this a valid executable package we should manage?
+    def self.valid?(name, values)
+      # See http://community.spiceworks.com/how_to/show/2238
+      displayName = get_display_name(values)
+      !!(displayName && displayName.length > 0 &&
+         values['UninstallString'] &&
+         values['UninstallString'].length > 0 &&
+         values['WindowsInstaller'] != 1 && # DWORD
+         name !~ /^KB[0-9]{6}/ &&
+         values['ParentKeyName'] == nil &&
+         values['Security Update'] == nil &&
+         values['Update Rollup'] == nil &&
+         values['Hotfix'] == nil)
+    end
+
+    def initialize(name, version, uninstall_string)
+      super(name, version)
+
+      @uninstall_string = uninstall_string
+    end
+
+    # Does this package match the resource?
+    def match?(resource)
+      resource[:name] == name
+    end
+
+    def self.install_command(resource)
+      file_location = resource[:source]
+      if file_location.start_with?('http://', 'https://')
+        tempfile = Tempfile.new(['','.exe'])
+        begin
+          uri = URI(Puppet::Util.uri_encode(file_location))
+          client = Puppet.runtime[:http]
+          client.get(uri, options: { include_system_store: true }) do |response|
+            raise Puppet::HTTP::ResponseError.new(response) unless response.success?
+
+            File.open(tempfile.path, 'wb') do |file|
+              response.read_body do |data|
+                file.write(data)
+              end
+            end
+          end
+        rescue => detail
+          raise Puppet::Error.new(_("Error when installing %{package}: %{detail}") % { package: resource[:name] ,detail: detail.message}, detail)
+        ensure
+          self.register(tempfile.path)
+          tempfile.close()
+          file_location = tempfile.path
+        end
+      end
+
+      munge(file_location)
+    end
+
+    def uninstall_command
+      # Only quote bare uninstall strings, e.g.
+      #   C:\Program Files (x86)\Notepad++\uninstall.exe
+      # Don't quote uninstall strings that are already quoted, e.g.
+      #   "c:\ruby187\unins000.exe"
+      # Don't quote uninstall strings that contain arguments:
+      #   "C:\Program Files (x86)\Git\unins000.exe" /SILENT
+      if uninstall_string =~ /\A[^"]*.exe\Z/i
+        command = "\"#{uninstall_string}\""
+      else
+        command = uninstall_string
+      end
+
+      command
+    end
+  end
+end