openvox 8.19.0

data/lib/puppet/provider/nameservice.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet'
+
+# This is the parent class of all NSS classes.  They're very different in
+# their backend, but they're pretty similar on the front-end.  This class
+# provides a way for them all to be as similar as possible.
+class Puppet::Provider::NameService < Puppet::Provider
+  class << self
+    def autogen_default(param)
+      defined?(@autogen_defaults) ? @autogen_defaults[param.intern] : nil
+    end
+
+    def autogen_defaults(hash)
+      @autogen_defaults ||= {}
+      hash.each do |param, value|
+        @autogen_defaults[param.intern] = value
+      end
+    end
+
+    def initvars
+      @checks = {}
+      @options = {}
+      super
+    end
+
+    def instances
+      objects = []
+      begin
+        method = Puppet::Etc.method(:"get#{section}ent")
+        while ent = method.call # rubocop:disable Lint/AssignmentInCondition
+          objects << new(:name => ent.name, :canonical_name => ent.canonical_name, :ensure => :present)
+        end
+      ensure
+        Puppet::Etc.send("end#{section}ent")
+      end
+      objects
+    end
+
+    def option(name, option)
+      name = name.intern if name.is_a? String
+      (defined?(@options) and @options.include? name and @options[name].include? option) ? @options[name][option] : nil
+    end
+
+    def options(name, hash)
+      unless resource_type.valid_parameter?(name)
+        raise Puppet::DevError, _("%{name} is not a valid attribute for %{resource_type}") % { name: name, resource_type: resource_type.name }
+      end
+
+      @options ||= {}
+      @options[name] ||= {}
+
+      # Set options individually, so we can call the options method
+      # multiple times.
+      hash.each do |param, value|
+        @options[name][param] = value
+      end
+    end
+
+    def resource_type=(resource_type)
+      super
+      @resource_type.validproperties.each do |prop|
+        next if prop == :ensure
+
+        define_method(prop) { get(prop) || :absent } unless public_method_defined?(prop)
+        define_method(prop.to_s + "=") { |*vals| set(prop, *vals) } unless public_method_defined?(prop.to_s + "=")
+      end
+    end
+
+    # This is annoying, but there really aren't that many options,
+    # and this *is* built into Ruby.
+    def section
+      unless resource_type
+        raise Puppet::DevError,
+              "Cannot determine Etc section without a resource type"
+      end
+
+      if @resource_type.name == :group
+        "gr"
+      else
+        "pw"
+      end
+    end
+
+    def validate(name, value)
+      name = name.intern if name.is_a? String
+      if @checks.include? name
+        block = @checks[name][:block]
+        raise ArgumentError, _("Invalid value %{value}: %{error}") % { value: value, error: @checks[name][:error] } unless block.call(value)
+      end
+    end
+
+    def verify(name, error, &block)
+      name = name.intern if name.is_a? String
+      @checks[name] = { :error => error, :block => block }
+    end
+
+    private
+
+    def op(property)
+      @ops[property.name] || "-#{property.name}"
+    end
+  end
+
+  # Autogenerate a value.  Mostly used for uid/gid, but also used heavily
+  # with DirectoryServices
+  def autogen(field)
+    field = field.intern
+    id_generators = { :user => :uid, :group => :gid }
+    if id_generators[@resource.class.name] == field
+      self.class.autogen_id(field, @resource.class.name)
+    else
+      value = self.class.autogen_default(field)
+      if value
+        value
+      elsif respond_to?("autogen_#{field}")
+        send("autogen_#{field}")
+      else
+        nil
+      end
+    end
+  end
+
+  # Autogenerate either a uid or a gid.  This is not very flexible: we can
+  # only generate one field type per class, and get kind of confused if asked
+  # for both.
+  def self.autogen_id(field, resource_type)
+    # Figure out what sort of value we want to generate.
+    case resource_type
+    when :user;   database = :passwd;  method = :uid
+    when :group;  database = :group;   method = :gid
+    else
+      # TRANSLATORS "autogen_id()" is a method name and should not be translated
+      raise Puppet::DevError, _("autogen_id() does not support auto generation of id for resource type %{resource_type}") % { resource_type: resource_type }
+    end
+
+    # Initialize from the data set, if needed.
+    unless @prevauto
+      # Sadly, Etc doesn't return an enumerator, it just invokes the block
+      # given, or returns the first record from the database.  There is no
+      # other, more convenient enumerator for these, so we fake one with this
+      # loop.  Thanks, Ruby, for your awesome abstractions. --daniel 2012-03-23
+      highest = []
+      Puppet::Etc.send(database) { |entry| highest << entry.send(method) }
+      highest = highest.reject { |x| x > 65_000 }.max
+
+      @prevauto = highest || 1000
+    end
+
+    # ...and finally increment and return the next value.
+    @prevauto += 1
+  end
+
+  def create
+    if exists?
+      info _("already exists")
+      # The object already exists
+      return nil
+    end
+
+    begin
+      sensitive = has_sensitive_data?
+      execute(addcmd, { :failonfail => true, :combine => true, :custom_environment => @custom_environment, :sensitive => sensitive })
+      if feature?(:manages_password_age) && (cmd = passcmd)
+        execute(cmd, { :failonfail => true, :combine => true, :custom_environment => @custom_environment, :sensitive => sensitive })
+      end
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, _("Could not create %{resource} %{name}: %{detail}") % { resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
+    end
+  end
+
+  def delete
+    unless exists?
+      info _("already absent")
+      # the object already doesn't exist
+      return nil
+    end
+
+    begin
+      execute(deletecmd, { :failonfail => true, :combine => true, :custom_environment => @custom_environment })
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, _("Could not delete %{resource} %{name}: %{detail}") % { resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
+    end
+  end
+
+  def ensure
+    if exists?
+      :present
+    else
+      :absent
+    end
+  end
+
+  # Does our object exist?
+  def exists?
+    !!getinfo(true)
+  end
+
+  # Retrieve a specific value by name.
+  def get(param)
+    (hash = getinfo(false)) ? unmunge(param, hash[param]) : nil
+  end
+
+  def munge(name, value)
+    block = self.class.option(name, :munge)
+    if block and block.is_a? Proc
+      block.call(value)
+    else
+      value
+    end
+  end
+
+  def unmunge(name, value)
+    block = self.class.option(name, :unmunge)
+    if block and block.is_a? Proc
+      block.call(value)
+    else
+      value
+    end
+  end
+
+  # Retrieve what we can about our object
+  def getinfo(refresh)
+    if @objectinfo.nil? or refresh == true
+      @etcmethod ||= ("get" + self.class.section.to_s + "nam").intern
+      begin
+        @objectinfo = Puppet::Etc.send(@etcmethod, @canonical_name)
+      rescue ArgumentError
+        @objectinfo = nil
+      end
+    end
+
+    # Now convert our Etc struct into a hash.
+    @objectinfo ? info2hash(@objectinfo) : nil
+  end
+
+  # The list of all groups the user is a member of.  Different
+  # user mgmt systems will need to override this method.
+  def groups
+    Puppet::Util::POSIX.groups_of(@resource[:name]).join(',')
+  end
+
+  # Convert the Etc struct into a hash.
+  def info2hash(info)
+    hash = {}
+    self.class.resource_type.validproperties.each do |param|
+      method = posixmethod(param)
+      hash[param] = info.send(posixmethod(param)) if info.respond_to? method
+    end
+
+    hash
+  end
+
+  def initialize(resource)
+    super
+    @custom_environment = {}
+    @objectinfo = nil
+    if resource.is_a?(Hash) && !resource[:canonical_name].nil?
+      @canonical_name = resource[:canonical_name]
+    else
+      @canonical_name = resource[:name]
+    end
+  end
+
+  def set(param, value)
+    self.class.validate(param, value)
+    cmd = modifycmd(param, munge(param, value))
+    raise Puppet::DevError, _("Nameservice command must be an array") unless cmd.is_a?(Array)
+
+    sensitive = has_sensitive_data?(param)
+    begin
+      execute(cmd, { :failonfail => true, :combine => true, :custom_environment => @custom_environment, :sensitive => sensitive })
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, _("Could not set %{param} on %{resource}[%{name}]: %{detail}") % { param: param, resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
+    end
+  end
+
+  # Derived classes can override to declare sensitive data so a flag can be passed to execute
+  def has_sensitive_data?(property = nil)
+    false
+  end
+
+  # From overriding Puppet::Property#insync? Ruby Etc::getpwnam < 2.1.0 always
+  # returns a struct with binary encoded string values, and >= 2.1.0 will return
+  # binary encoded strings for values incompatible with current locale charset,
+  # or Encoding.default_external if compatible. Compare a "should" value with
+  # encoding of "current" value, to avoid unnecessary property syncs and
+  # comparison of strings with different encodings. (PUP-6777)
+  #
+  # return basic string comparison after re-encoding (same as
+  # Puppet::Property#property_matches)
+  def comments_insync?(current, should)
+    # we're only doing comparison here so don't mutate the string
+    desired = should[0].to_s.dup
+    current == desired.force_encoding(current.encoding)
+  end
+end

data/lib/puppet/provider/network_device.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# This is the base class of all prefetched network device provider
+class Puppet::Provider::NetworkDevice < Puppet::Provider
+  def self.device(url)
+    raise "This provider doesn't implement the necessary device method"
+  end
+
+  def self.lookup(device, name)
+    raise "This provider doesn't implement the necessary lookup method"
+  end
+
+  def self.prefetch(resources)
+    resources.each do |name, resource|
+      device = Puppet::Util::NetworkDevice.current || device(resource[:device_url])
+      result = lookup(device, name)
+      if result
+        result[:ensure] = :present
+        resource.provider = new(device, result)
+      else
+        resource.provider = new(device, :ensure => :absent)
+      end
+    end
+  rescue => detail
+    # Preserving behavior introduced in #6907
+    # TRANSLATORS "prefetch" is a program name and should not be translated
+    Puppet.log_exception(detail, _("Could not perform network device prefetch: %{detail}") % { detail: detail })
+  end
+
+  def exists?
+    @property_hash[:ensure] != :absent
+  end
+
+  attr_accessor :device
+
+  def initialize(device, *args)
+    super(*args)
+
+    @device = device
+
+    # Make a duplicate, so that we have a copy for comparison
+    # at the end.
+    @properties = @property_hash.dup
+  end
+
+  def create
+    @property_hash[:ensure] = :present
+    self.class.resource_type.validproperties.each do |property|
+      val = resource.should(property)
+      if val
+        @property_hash[property] = val
+      end
+    end
+  end
+
+  def destroy
+    @property_hash[:ensure] = :absent
+  end
+
+  def flush
+    @property_hash.clear
+  end
+
+  def self.instances
+  end
+
+  def former_properties
+    @properties.dup
+  end
+
+  def properties
+    @property_hash.dup
+  end
+end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/provider/package'
+require_relative '../../../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 'os.name' => [:aix]
+  defaultfor 'os.name' => :aix
+
+  attr_accessor :latest_info
+
+  STATE_CODE = {
+    'A' => :applied,
+    'B' => :broken,
+    'C' => :committed,
+    'E' => :efix_locked,
+    'O' => :obsolete,
+    '?' => :inconsistent,
+  }.freeze
+
+  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(srclistcmd(source)).each_line do |line|
+        next unless line =~ /^[^#][^:]*:([^:]*):([^:]*)/
+
+        current = {}
+        current[:name]    = Regexp.last_match(1)
+        current[:version] = Regexp.last_match(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
+
+    packages.each do |name, package|
+      if updates.key?(name)
+        package.provider.latest_info = updates[name]
+      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 '%{name}'") % { name: @resource[:name] }
+    end
+  end
+
+  def install(useversion = true)
+    source = @resource[:source]
+    unless 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
+
+    pkg_info = query
+    if pkg_info && [:broken, :inconsistent].include?(pkg_info[:status])
+      self.fail _("Package '%{name}' is in a %{status} state and requires manual intervention") % { name: @resource[:name], status: pkg_info[:status] }
+    end
+  end
+
+  def self.pkglist(hash = {})
+    cmd = [command(:lslpp), "-qLc"]
+
+    name = hash[:pkgname]
+    if name
+      cmd << name
+    end
+
+    begin
+      list = execute(cmd).scan(/^[^#][^:]*:([^:]*):([^:]*):[^:]*:[^:]*:([^:])/).collect { |n, e, s|
+        e = :absent if [:broken, :inconsistent].include?(STATE_CODE[s])
+        { :name => n, :ensure => e, :status => STATE_CODE[s], :provider => self.name }
+      }
+    rescue Puppet::ExecutionFailure => detail
+      if hash[:pkgname]
+        return nil
+      else
+        raise Puppet::Error, _("Could not list installed Packages: %{detail}") % { detail: detail }, detail.backtrace
+      end
+    end
+
+    if hash[:pkgname]
+      list.shift
+    else
+      list
+    end
+  end
+
+  def self.instances
+    pkglist.collect do |hash|
+      new(hash)
+    end
+  end
+
+  def latest
+    upd = latest_info
+
+    if upd.nil?
+      raise Puppet::DevError, _("Tried to get latest on a missing package") if properties[:ensure] == :absent
+
+      properties[:ensure]
+    else
+      (upd[:version]).to_s
+    end
+  end
+
+  def query
+    self.class.pkglist(:pkgname => @resource[:name])
+  end
+
+  def update
+    install(false)
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# 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_relative '../../../puppet/provider/package'
+require_relative '../../../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 'os.name' => :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
+
+      File.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." unless 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 = @resource[:source]
+    unless source
+      self.fail _("Mac OS X PKG DMGs must specify a package source.")
+    end
+    name = @resource[:name]
+    unless name
+      self.fail _("Mac OS X PKG DMGs must specify a package name.")
+    end
+    self.class.installpkgdmg(source, name)
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../../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 'os.name' => :darwin
+  commands :installer => "/usr/sbin/installer"
+
+  def self.instances
+    instance_by_name.collect do |name|
+      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 = @resource[:source]
+    unless source
+      self.fail _("Mac OS X packages must specify a package source")
+    end
+
+    installer "-pkg", source, "-target", "/"
+  end
+end