puppet 3.1.1 → 3.2.0.rc1

data/lib/puppet/provider/group/groupadd.rb

@@ -1,4 +1,5 @@
 require 'puppet/provider/nameservice/objectadd'
+require 'puppet/util/libuser'
 
 Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameService::ObjectAdd do
   desc "Group management via `groupadd` and its ilk. The default for most platforms.
@@ -13,17 +14,72 @@ Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameSe
     value.is_a? Integer
   end
 
+  optional_commands :localadd => "lgroupadd"
+  has_feature :libuser if Puppet.features.libuser?
+
+  def exists?
+    return !!localgid if @resource.forcelocal?
+    super
+  end
+
+  def gid
+    return localgid if @resource.forcelocal?
+    get(:gid)
+  end
+
+  def findgroup(key, value)
+    group_file = "/etc/group"
+    group_keys = ['group_name', 'password', 'gid', 'user_list']
+    index = group_keys.index(key)
+    File.open(group_file) do |f|
+      f.each_line do |line|
+         group = line.split(":")
+         if group[index] == value
+             f.close
+             return group
+         end
+      end
+    end
+    false
+  end
+
+  def localgid
+    group = findgroup('group_name', resource[:name])
+    return group[2] if group
+    false
+  end
+
+  def check_allow_dup
+    # We have to manually check for duplicates when using libuser
+    # because by default duplicates are allowed.  This check is
+    # to ensure consistent behaviour of the useradd provider when
+    # using both useradd and luseradd
+    if not @resource.allowdupe? and @resource.forcelocal?
+       if @resource.should(:gid) and findgroup('gid', @resource.should(:gid).to_s)
+           raise(Puppet::Error, "GID #{@resource.should(:gid).to_s} already exists, use allowdupe to force group creation")
+       end
+    elsif @resource.allowdupe? and not @resource.forcelocal?
+       return ["-o"]
+    end
+    []
+  end
+
   def addcmd
-    cmd = [command(:add)]
+    if @resource.forcelocal?
+      cmd = [command(:localadd)]
+      @custom_environment = Puppet::Util::Libuser.getenv
+    else
+      cmd = [command(:add)]
+    end
+
     if gid = @resource.should(:gid)
       unless gid == :absent
         cmd << flag(:gid) << gid
       end
     end
-    cmd << "-o" if @resource.allowdupe?
+    cmd += check_allow_dup
     cmd << "-r" if @resource.system? and self.class.system_groups?
     cmd << @resource[:name]
-
     cmd
   end
 end

data/lib/puppet/provider/interface/cisco.rb

@@ -8,8 +8,8 @@ Puppet::Type.type(:interface).provide :cisco, :parent => Puppet::Provider::Cisco
 
   def self.lookup(device, name)
     interface = nil
-    device.command do |ng|
-      interface = device.interface(name)
+    device.command do |dev|
+      interface = dev.interface(name)
     end
     interface
   end
@@ -19,8 +19,8 @@ Puppet::Type.type(:interface).provide :cisco, :parent => Puppet::Provider::Cisco
   end
 
   def flush
-    device.command do |device|
-      device.new_interface(name).update(former_properties, properties)
+    device.command do |dev|
+      dev.new_interface(name).update(former_properties, properties)
     end
     super
   end

data/lib/puppet/provider/mount/parsed.rb

@@ -88,7 +88,7 @@ Puppet::Type.type(:mount).provide(
 
   def self.mountinstances
     # XXX: Will not work for mount points that have spaces in path (does fstab support this anyways?)
-    regex = case Facter.value(:osfamily) 
+    regex = case Facter.value(:osfamily)
       when "Darwin"
         / on (?:\/private\/var\/automount)?(\S*)/
       when "Solaris", "HP-UX"

data/lib/puppet/provider/nameservice.rb

@@ -18,6 +18,7 @@ class Puppet::Provider::NameService < Puppet::Provider
 
     def initvars
       @checks = {}
+      @options = {}
       super
     end
 
@@ -76,10 +77,9 @@ class Puppet::Provider::NameService < Puppet::Provider
     # This is annoying, but there really aren't that many options,
     # and this *is* built into Ruby.
     def section
-      unless defined?(@resource_type)
+      unless resource_type
         raise Puppet::DevError,
           "Cannot determine Etc section without a resource type"
-
       end
 
       if @resource_type.name == :group
@@ -164,7 +164,7 @@ class Puppet::Provider::NameService < Puppet::Provider
     end
 
     begin
-      execute(self.addcmd)
+      execute(self.addcmd, {:failonfail => true, :combine => true, :custom_environment => @custom_environment})
       if feature?(:manages_password_age) && (cmd = passcmd)
         execute(cmd)
       end
@@ -202,7 +202,23 @@ class Puppet::Provider::NameService < Puppet::Provider
 
   # Retrieve a specific value by name.
   def get(param)
-    (hash = getinfo(false)) ? hash[param] : nil
+    (hash = getinfo(false)) ? unmunge(param, hash[param]) : nil
+  end
+
+  def munge(name, value)
+    if block = self.class.option(name, :munge) and block.is_a? Proc
+      block.call(value)
+    else
+      value
+    end
+  end
+
+  def unmunge(name, value)
+    if block = self.class.option(name, :unmunge) and block.is_a? Proc
+      block.call(value)
+    else
+      value
+    end
   end
 
   # Retrieve what we can about our object
@@ -258,13 +274,13 @@ class Puppet::Provider::NameService < Puppet::Provider
 
   def initialize(resource)
     super
-
+    @custom_environment = {}
     @objectinfo = nil
   end
 
   def set(param, value)
     self.class.validate(param, value)
-    cmd = modifycmd(param, value)
+    cmd = modifycmd(param, munge(param, value))
     raise Puppet::DevError, "Nameservice command must be an array" unless cmd.is_a?(Array)
     begin
       execute(cmd)

data/lib/puppet/provider/nameservice/pw.rb

@@ -12,7 +12,7 @@ class PW < ObjectAdd
       "#{@resource.class.name.to_s}mod",
       @resource[:name],
       flag(param),
-      value
+      munge(param, value)
     ]
     cmd
   end

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

@@ -2,12 +2,24 @@ require 'puppet/provider/package'
 require 'puppet/util/package'
 
 Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package do
-  desc "Installation from the AIX software directory."
+  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"
+              :installp => "/usr/sbin/installp"
 
   # AIX supports versionable packages with and without a NIM server
   has_feature :versionable
@@ -60,6 +72,12 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
     # 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)
@@ -69,9 +87,15 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
 
     pkg = @resource[:name]
 
-    pkg << " #{@resource.should(:ensure)}" if (! @resource.should(:ensure).is_a? Symbol) and useversion
+    pkg += " #{@resource.should(:ensure)}" if (! @resource.should(:ensure).is_a? Symbol) and useversion
+
+    output = installp "-acgwXY", "-d", source, pkg
 
-    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 = {})

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

@@ -72,8 +72,6 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
   def install(useversion = true)
     command = [command(:gemcmd), "install"]
     command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
-    # Always include dependencies
-    command << "--include-dependencies"
 
     if source = resource[:source]
       begin

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

@@ -14,7 +14,7 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
 
   confine :operatingsystem => :darwin
 
-  has_command(:port, "/opt/local/bin/port") do 
+  has_command(:port, "/opt/local/bin/port") do
     environment :HOME => "/opt/local"
   end
 

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

@@ -2,11 +2,20 @@ require 'puppet/provider/package'
 require 'puppet/util/package'
 
 Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
-  desc "Installation from NIM LPP source."
+  desc "Installation from an AIX NIM LPP source.  The `source` parameter is required
+      for this provider, and should specify the name of a NIM `lpp_source` resource
+      that is visible to the puppet agent machine.  This provider supports the
+      management of both BFF/installp and RPM packages.
+
+      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    :nimclient => "/usr/sbin/nimclient"
+  commands    :nimclient  => "/usr/sbin/nimclient",
+              :lslpp      => "/usr/bin/lslpp",
+              :rpm        => "rpm"
 
   # If NIM has not been configured, /etc/niminfo will not be present.
   # However, we have no way of knowing if the NIM server is not configured
@@ -17,10 +26,34 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
 
   attr_accessor :latest_info
 
+
+
   def self.srclistcmd(source)
     [ command(:nimclient), "-o", "showres", "-a", "installp_flags=L", "-a", "resource=#{source}" ]
   end
 
+  def uninstall
+    output = lslpp("-qLc", @resource[:name]).split(':')
+    # the 6th index in the colon-delimited output contains a " " for installp/BFF
+    # packages, and an "R" for RPMS.  (duh.)
+    pkg_type = output[6]
+
+    case pkg_type
+    when " "
+      installp "-gu", @resource[:name]
+    when "R"
+      rpm "-e", @resource[:name]
+    else
+      self.fail("Unrecognized AIX package type identifier: '#{pkg_type}'")
+    end
+
+    # 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 "An LPP source location is required in 'source'"
@@ -28,8 +61,220 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
 
     pkg = @resource[:name]
 
-    pkg << " " << @resource.should(:ensure) if (! @resource.should(:ensure).is_a? Symbol) and useversion
+    version_specified = (useversion and (! @resource.should(:ensure).is_a? Symbol))
+
+    # This is unfortunate for a couple of reasons.  First, because of a subtle
+    # difference in the command-line syntax for installing an RPM vs an
+    # installp/BFF package, we need to know ahead of time which type of
+    # package we're trying to install.  This means we have to execute an
+    # extra command.
+    #
+    # Second, the command is easiest to deal with and runs fastest if we
+    # pipe it through grep on the shell.  Unfortunately, the way that
+    # the provider `make_command_methods` metaprogramming works, we can't
+    # use that code path to execute the command (because it treats the arguments
+    # as an array of args that all apply to `nimclient`, which fails when you
+    # hit the `|grep`.)  So here we just call straight through to P::U.execute
+    # with a single string argument for the full command, rather than going
+    # through the metaprogrammed layer.  We could get rid of the grep and
+    # switch back to the metaprogrammed stuff, and just parse all of the output
+    # in Ruby... but we'd be doing an awful lot of unnecessary work.
+    showres_command = "/usr/sbin/nimclient -o showres -a resource=#{source} |/usr/bin/grep -p -E "
+    if (version_specified)
+      version = @resource.should(:ensure)
+      showres_command << "'#{Regexp.escape(pkg)}( |-)#{Regexp.escape(version)}'"
+    else
+      version = nil
+      showres_command << "'#{Regexp.escape(pkg)}'"
+    end
+    output = Puppet::Util.execute(showres_command)
+
+
+    if (version_specified)
+      package_type = determine_package_type(output, pkg, version)
+    else
+      package_type, version = determine_latest_version(output, pkg)
+    end
+
+    if (package_type == nil)
+      errmsg = "Unable to find package '#{pkg}' "
+      if (version_specified)
+        errmsg << "with version '#{version}' "
+      end
+      errmsg << "on lpp_source '#{source}'"
+      self.fail errmsg
+    end
+
+    # This part is a bit tricky.  If there are multiple versions of the
+    # package available, then `version` will be set to a value, and we'll need
+    # to add that value to our installation command.  However, if there is only
+    # one version of the package available, `version` will be set to `nil`, and
+    # we don't need to add the version string to the command.
+    if (version)
+      # Now we know if the package type is RPM or not, and we can adjust our
+      # `pkg` string for passing to the install command accordingly.
+      if (package_type == :rpm)
+        # RPM's expect a hyphen between the package name and the version number
+        version_separator = "-"
+      else
+        # installp/BFF packages expect a space between the package name and the
+        # version number.
+        version_separator = " "
+      end
+
+      pkg += version_separator + version
+    end
+
+    # NOTE: the installp flags here are ignored (but harmless) for RPMs
+    output = nimclient "-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=#{source}", "-a", "filesets=#{pkg}"
+
+    # If the package is superseded, it means we're trying to downgrade and we
+    # can't do that.
+    case package_type
+    when :installp
+      if output =~ /^#{Regexp.escape(@resource[:name])}\s+.*\s+Already superseded by.*$/
+        self.fail "NIM package provider is unable to downgrade packages"
+      end
+    when :rpm
+      if output =~ /^#{Regexp.escape(@resource[:name])}.* is superseded by.*$/
+        self.fail "NIM package provider is unable to downgrade packages"
+      end
+    end
+  end
+
+
+  private
+
+  ## UTILITY METHODS FOR PARSING `nimclient -o showres` output
+
+  # This makes me very sad.  These regexes seem pretty fragile, but
+  # I spent a lot of time trying to figure out a solution that didn't
+  # require parsing the `nimclient -o showres` output and was unable to
+  # do so.
+  HEADER_LINE_REGEX      = /^([^\s]+)\s+[^@]+@@(I|R):(\1)\s+[^\s]+$/
+  PACKAGE_LINE_REGEX     = /^.*@@(I|R):(.*)$/
+  RPM_PACKAGE_REGEX      = /^(.*)-(.*-\d+) \2$/
+  INSTALLP_PACKAGE_REGEX = /^(.*) (.*)$/
 
-    nimclient "-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=#{source}", "-a", "filesets='#{pkg}'"
+  # Here is some sample output that shows what the above regexes will be up
+  # against:
+  # FOR AN INSTALLP PACKAGE:
+  #
+  #    mypackage.foo                                                           ALL  @@I:mypackage.foo _all_filesets
+  #    @ 1.2.3.1  MyPackage Runtime Environment                       @@I:mypackage.foo 1.2.3.1
+  #    + 1.2.3.4  MyPackage Runtime Environment                       @@I:mypackage.foo 1.2.3.4
+  #    + 1.2.3.8  MyPackage Runtime Environment                       @@I:mypackage.foo 1.2.3.8
+  #
+  # FOR AN RPM PACKAGE:
+  #
+  # mypackage.foo                                                                ALL  @@R:mypackage.foo _all_filesets
+  #   @@R:mypackage.foo-1.2.3-1 1.2.3-1
+  #   @@R:mypackage.foo-1.2.3-4 1.2.3-4
+  #   @@R:mypackage.foo-1.2.3-8 1.2.3-8
+
+
+  # Parse the output of a `nimclient -o showres` command.  Returns a two-dimensional
+  # hash, where the first-level keys are package names, the second-level keys are
+  # version number strings for all of the available version numbers for a package,
+  # and the values indicate the package type (:rpm / :installp)
+  def parse_showres_output(showres_output)
+    paragraphs = split_into_paragraphs(showres_output)
+    packages = {}
+    paragraphs.each do |para|
+      lines = para.split(/$/)
+      parse_showres_header_line(lines.shift)
+      lines.each do |l|
+        package, version, type = parse_showres_package_line(l)
+        packages[package] ||= {}
+        packages[package][version] = type
+      end
+    end
+    packages
+  end
+
+  # This method basically just splits the multi-line input string into chunks
+  # based on lines that contain nothing but whitespace.  It also strips any
+  # leading or trailing whitespace (including newlines) from the resulting
+  # strings and then returns them as an array.
+  def split_into_paragraphs(showres_output)
+    showres_output.split(/^\s*$/).map { |p| p.strip! }
+  end
+
+  def parse_showres_header_line(line)
+    # This method doesn't produce any meaningful output; it's basically just
+    # meant to validate that the header line for the package listing output
+    # looks sane, so we know we're dealing with the kind of output that we
+    # are capable of handling.
+    unless line.match(HEADER_LINE_REGEX)
+      self.fail "Unable to parse output from nimclient showres: line does not match expected package header format:\n'#{line}'"
+    end
+  end
+
+  def parse_installp_package_string(package_string)
+    unless match = package_string.match(INSTALLP_PACKAGE_REGEX)
+      self.fail "Unable to parse output from nimclient showres: package string does not match expected installp package string format:\n'#{package_string}'"
+    end
+    package_name = match.captures[0]
+    version = match.captures[1]
+    [package_name, version, :installp]
+  end
+
+  def parse_rpm_package_string(package_string)
+    unless match = package_string.match(RPM_PACKAGE_REGEX)
+      self.fail "Unable to parse output from nimclient showres: package string does not match expected rpm package string format:\n'#{package_string}'"
+    end
+    package_name = match.captures[0]
+    version = match.captures[1]
+    [package_name, version, :rpm]
+  end
+
+  def parse_showres_package_line(line)
+    unless match = line.match(PACKAGE_LINE_REGEX)
+      self.fail "Unable to parse output from nimclient showres: line does not match expected package line format:\n'#{line}'"
+    end
+
+    package_type_flag = match.captures[0]
+    package_string = match.captures[1]
+
+    case package_type_flag
+      when "I"
+        parse_installp_package_string(package_string)
+      when "R"
+        parse_rpm_package_string(package_string)
+      else
+        self.fail "Unrecognized package type specifier: '#{package_type_flag}' in package line:\n'#{line}'"
+    end
+  end
+
+  # Given a blob of output from `nimclient -o showres` and a package name,
+  # this method checks to see if there are multiple versions of the package
+  # available on the lpp_source.  If there are, the method returns
+  # [package_type, latest_version] (where package_type is one of :installp or :rpm).
+  # If there is only one version of the package available, it returns
+  # [package_type, nil], because the caller doesn't need to pass the version
+  # string to the command-line command if there is only one version available.
+  # If the package is not available at all, the method simply returns nil (instead
+  # of a tuple).
+  def determine_latest_version(showres_output, package_name)
+    packages = parse_showres_output(showres_output)
+    unless packages.has_key?(package_name)
+      return nil
+    end
+    if (packages[package_name].count == 1)
+      version = packages[package_name].keys[0]
+      return packages[package_name][version], nil
+    else
+      versions = packages[package_name].keys
+      latest_version = (versions.sort { |a, b| Puppet::Util::Package.versioncmp(b, a) })[0]
+      return packages[package_name][latest_version], latest_version
+    end
+  end
+
+  def determine_package_type(showres_output, package_name, version)
+    packages = parse_showres_output(showres_output)
+    unless (packages.has_key?(package_name) and packages[package_name].has_key?(version))
+      return nil
+    end
+    packages[package_name][version]
   end
 end