puppet 0.25.5 → 2.6.0

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

@@ -1,52 +1,50 @@
 Puppet::Type.type(:package).provide :freebsd, :parent => :openbsd do
-    desc "The specific form of package management on FreeBSD.  This is an
-        extremely quirky packaging system, in that it freely mixes between
-        ports and packages.  Apparently all of the tools are written in Ruby,
-        so there are plans to rewrite this support to directly use those
-        libraries."
+  desc "The specific form of package management on FreeBSD.  This is an
+    extremely quirky packaging system, in that it freely mixes between
+    ports and packages.  Apparently all of the tools are written in Ruby,
+    so there are plans to rewrite this support to directly use those
+    libraries."
 
-    commands :pkginfo => "/usr/sbin/pkg_info",
-             :pkgadd => "/usr/sbin/pkg_add",
-             :pkgdelete => "/usr/sbin/pkg_delete"
+  commands :pkginfo => "/usr/sbin/pkg_info",
+    :pkgadd => "/usr/sbin/pkg_add",
+    :pkgdelete => "/usr/sbin/pkg_delete"
 
-    confine :operatingsystem => :freebsd
+  confine :operatingsystem => :freebsd
 
-    def self.listcmd
-        command(:pkginfo)
-    end
+  def self.listcmd
+    command(:pkginfo)
+  end
 
-    def install
-        should = @resource.should(:ensure)
-
-        if @resource[:source] =~ /\/$/
-            if @resource[:source] =~ /^(ftp|https?):/
-                withenv :PACKAGESITE => @resource[:source] do
-                    pkgadd "-r", @resource[:name]
-                end
-            else
-                withenv :PKG_PATH => @resource[:source] do
-                    pkgadd @resource[:name]
-                end
-            end
-        else
-            if @resource[:source]
-                Puppet.warning "source is defined but does not have trailing slash, ignoring %s" % @resource[:source]
-            end
-            pkgadd "-r", @resource[:name]
-        end
-    end
+  def install
+    should = @resource.should(:ensure)
 
-    def query
-        self.class.instances.each do |provider|
-            if provider.name == @resource.name
-                return provider.properties
-            end
+    if @resource[:source] =~ /\/$/
+      if @resource[:source] =~ /^(ftp|https?):/
+        withenv :PACKAGESITE => @resource[:source] do
+          pkgadd "-r", @resource[:name]
         end
-        return nil
+      else
+        withenv :PKG_PATH => @resource[:source] do
+          pkgadd @resource[:name]
+        end
+      end
+    else
+      Puppet.warning "source is defined but does not have trailing slash, ignoring #{@resource[:source]}" if @resource[:source]
+      pkgadd "-r", @resource[:name]
     end
+  end
 
-    def uninstall
-        pkgdelete "%s-%s" % [@resource[:name], @resource.should(:ensure)]
+  def query
+    self.class.instances.each do |provider|
+      if provider.name == @resource.name
+        return provider.properties
+      end
     end
+    nil
+  end
+
+  def uninstall
+    pkgdelete "#{@resource[:name]}-#{@resource.should(:ensure)}"
+  end
 end
 

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

@@ -3,126 +3,122 @@ 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."
+  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."
 
-    has_feature :versionable
+  has_feature :versionable
 
-    commands :gemcmd => "gem"
+  commands :gemcmd => "gem"
 
-    def self.gemlist(hash)
-        command = [command(:gemcmd), "list"]
+  def self.gemlist(hash)
+    command = [command(:gemcmd), "list"]
 
-        if hash[:local]
-            command << "--local"
-        else
-            command << "--remote"
-        end
-
-        if name = hash[:justme]
-            command << name
-        end
-
-        begin
-            list = execute(command).split("\n").collect do |set|
-                if gemhash = gemsplit(set)
-                    gemhash[:provider] = :gem
-                    gemhash
-                else
-                    nil
-                end
-            end.compact
-        rescue Puppet::ExecutionFailure => detail
-            raise Puppet::Error, "Could not list gems: %s" % detail
-        end
+    if hash[:local]
+      command << "--local"
+    else
+      command << "--remote"
+    end
 
-        if hash[:justme]
-            return list.shift
-        else
-            return list
-        end
+    if name = hash[:justme]
+      command << name
     end
 
-    def self.gemsplit(desc)
-        case desc
-        when /^\*\*\*/, /^\s*$/, /^\s+/; return nil
-        when /^(\S+)\s+\((.+)\)/
-            name = $1
-            version = $2.split(/,\s*/)[0]
-            return {
-                :name => name,
-                :ensure => version
-            }
+    begin
+      list = execute(command).split("\n").collect do |set|
+        if gemhash = gemsplit(set)
+          gemhash[:provider] = :gem
+          gemhash
         else
-            Puppet.warning "Could not match %s" % desc
-            nil
+          nil
         end
+      end.compact
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not list gems: #{detail}"
     end
 
-    def self.instances(justme = false)
-        gemlist(:local => true).collect do |hash|
-            new(hash)
-        end
+    if hash[:justme]
+      return list.shift
+    else
+      return list
     end
+  end
+
+  def self.gemsplit(desc)
+    case desc
+    when /^\*\*\*/, /^\s*$/, /^\s+/; return nil
+    when /^(\S+)\s+\((.+)\)/
+      name = $1
+      version = $2.split(/,\s*/)[0]
+      return {
+        :name => name,
+        :ensure => version
+      }
+    else
+      Puppet.warning "Could not match #{desc}"
+      nil
+    end
+  end
 
-    def install(useversion = true)
-        command = [command(:gemcmd), "install"]
-        if (! resource[:ensure].is_a? Symbol) and useversion
-            command << "-v" << resource[:ensure]
-        end
-        # Always include dependencies
-        command << "--include-dependencies"
-
-        if source = resource[:source]
-            begin
-                uri = URI.parse(source)
-            rescue => detail
-                fail "Invalid source '%s': %s" % [uri, 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
-                # interpret it as a gem repository
-                command << "--source" << "#{source}" << resource[:name]
-            end
-        else
-            command << resource[:name]
-        end
-
-        output = execute(command)
-        # Apparently some stupid gem versions don't exit non-0 on failure
-        if output.include?("ERROR")
-            self.fail "Could not install: %s" % output.chomp
-        end
+  def self.instances(justme = false)
+    gemlist(:local => true).collect do |hash|
+      new(hash)
+    end
+  end
+
+  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
+        uri = URI.parse(source)
+      rescue => detail
+        fail "Invalid source '#{uri}': #{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
+        # interpret it as a gem repository
+        command << "--source" << "#{source}" << resource[:name]
+      end
+    else
+      command << resource[:name]
     end
 
-    def latest
-        # This always gets the latest version available.
-        hash = self.class.gemlist(:justme => resource[:name])
+    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
 
-        return hash[:ensure]
-    end
+  def latest
+    # This always gets the latest version available.
+    hash = self.class.gemlist(:justme => resource[:name])
 
-    def query
-        self.class.gemlist(:justme => resource[:name], :local => true)
-    end
+    hash[:ensure]
+  end
 
-    def uninstall
-        gemcmd "uninstall", "-x", "-a", resource[:name]
-    end
+  def query
+    self.class.gemlist(:justme => resource[:name], :local => true)
+  end
 
-    def update
-        self.install(false)
-    end
+  def uninstall
+    gemcmd "uninstall", "-x", "-a", resource[:name]
+  end
+
+  def update
+    self.install(false)
+  end
 end
 

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

@@ -4,43 +4,41 @@ require 'puppet/provider/package'
 
 Puppet::Type.type(:package).provide :hpux, :parent => Puppet::Provider::Package do
 
-    desc "HP-UX's packaging system."
-
-    commands :swinstall => "/usr/sbin/swinstall",
-             :swlist => "/usr/sbin/swlist",
-             :swremove => "/usr/sbin/swremove"
-
-    confine :operatingsystem => "hp-ux"
-
-    defaultfor :operatingsystem => "hp-ux"
-
-    def self.instances
-        # TODO:  This is very hard on HP-UX!
-        []
-    end
-
-    # source and name are required
-    def install
-        raise ArgumentError, "source must be provided to install HP-UX packages" unless resource[:source]
-        args = standard_args + ["-s", resource[:source], resource[:name]]
-        swinstall(*args)
-    end
-
-    def query
-        begin
-            swlist resource[:name]
-            {:ensure => :present}
-        rescue
-            {:ensure => :absent}
-        end
-    end
-
-    def uninstall
-        args = standard_args + [resource[:name]]
-        swremove(*args)
-    end
-
-    def standard_args
-        return ["-x", "mount_all_filesystems=false"]
-    end
+  desc "HP-UX's packaging system."
+
+  commands :swinstall => "/usr/sbin/swinstall",
+    :swlist => "/usr/sbin/swlist",
+    :swremove => "/usr/sbin/swremove"
+
+  confine :operatingsystem => "hp-ux"
+
+  defaultfor :operatingsystem => "hp-ux"
+
+  def self.instances
+    # TODO:  This is very hard on HP-UX!
+    []
+  end
+
+  # source and name are required
+  def install
+    raise ArgumentError, "source must be provided to install HP-UX packages" unless resource[:source]
+    args = standard_args + ["-s", resource[:source], resource[:name]]
+    swinstall(*args)
+  end
+
+  def query
+      swlist resource[:name]
+      {:ensure => :present}
+  rescue
+      {:ensure => :absent}
+  end
+
+  def uninstall
+    args = standard_args + [resource[:name]]
+    swremove(*args)
+  end
+
+  def standard_args
+    ["-x", "mount_all_filesystems=false"]
+  end
 end

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

@@ -0,0 +1,35 @@
+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"
+
+  # 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"
+
+  # 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
+  # properly.
+  confine  :exists => "/etc/niminfo"
+
+  has_feature :versionable
+
+  attr_accessor :latest_info
+
+  def self.srclistcmd(source)
+    [ command(:nimclient), "-o", "showres", "-a", "installp_flags=L", "-a", "resource=#{source}" ]
+  end
+
+  def install(useversion = true)
+    unless source = @resource[:source]
+      self.fail "An LPP source location is required in 'source'"
+    end
+
+    pkg = @resource[:name]
+
+    pkg << " " << @resource.should(:ensure) if (! @resource.should(:ensure).is_a? Symbol) and useversion
+
+    nimclient "-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=#{source}", "-a", "filesets='#{pkg}'"
+  end
+end

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

@@ -2,94 +2,119 @@ require 'puppet/provider/package'
 
 # Packaging on OpenBSD.  Doesn't work anywhere else that I know of.
 Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Package do
-    include Puppet::Util::Execution
-    desc "OpenBSD's form of ``pkg_add`` support."
-
-    commands :pkginfo => "pkg_info", :pkgadd => "pkg_add", :pkgdelete => "pkg_delete"
-
-    defaultfor :operatingsystem => :openbsd
-    confine :operatingsystem => :openbsd
-
-    def self.instances
-        packages = []
-
-        begin
-            execpipe(listcmd()) do |process|
-                # our regex for matching pkg_info output
-                regex = %r{^(\S+)-([^-\s]+)\s+(.+)}
-                fields = [:name, :ensure, :description]
-                hash = {}
-
-                # now turn each returned line into a package object
-                process.each { |line|
-                    if match = regex.match(line)
-                        fields.zip(match.captures) { |field,value|
-                            hash[field] = value
-                        }
-                        yup = nil
-                        name = hash[:name]
-
-                        hash[:provider] = self.name
-
-                        packages << new(hash)
-                        hash = {}
-                    else
-                        # Print a warning on lines we can't match, but move
-                        # on, since it should be non-fatal
-                        warning("Failed to match line %s" % line)
-                    end
-                }
-            end
-
-            return packages
-        rescue Puppet::ExecutionFailure
-            return nil
-        end
-    end
+  include Puppet::Util::Execution
+  desc "OpenBSD's form of ``pkg_add`` support."
+
+  commands :pkginfo => "pkg_info", :pkgadd => "pkg_add", :pkgdelete => "pkg_delete"
+
+  defaultfor :operatingsystem => :openbsd
+  confine :operatingsystem => :openbsd
+
+  has_feature :versionable
 
-    def self.listcmd
-        [command(:pkginfo), " -a"]
+  def self.instances
+    packages = []
+
+    begin
+      execpipe(listcmd) do |process|
+        # our regex for matching pkg_info output
+        regex = /^(.*)-(\d[^-]*)[-]?(\D*)(.*)$/
+        fields = [:name, :ensure, :flavor ]
+        hash = {}
+
+        # now turn each returned line into a package object
+        process.each { |line|
+          if match = regex.match(line.split[0])
+            fields.zip(match.captures) { |field,value|
+              hash[field] = value
+            }
+            yup = nil
+            name = hash[:name]
+
+            hash[:provider] = self.name
+
+            packages << new(hash)
+            hash = {}
+          else
+            # Print a warning on lines we can't match, but move
+            # on, since it should be non-fatal
+            warning("Failed to match line #{line}")
+          end
+        }
+      end
+
+      return packages
+    rescue Puppet::ExecutionFailure
+      return nil
     end
+  end
 
-    def install
-        should = @resource.should(:ensure)
+  def self.listcmd
+    [command(:pkginfo), " -a"]
+  end
 
-        unless @resource[:source]
-            raise Puppet::Error,
-                "You must specify a package source for BSD packages"
-        end
+  def install
+    should = @resource.should(:ensure)
 
-        if @resource[:source] =~ /\/$/
-            withenv :PKG_PATH => @resource[:source] do
-                pkgadd @resource[:name]
-            end
-        else
-            pkgadd @resource[:source]
-        end
+    unless @resource[:source]
+      raise Puppet::Error,
+        "You must specify a package source for BSD packages"
+    end
 
+    old_ensure = @resource[:ensure]
+
+    if @resource[:source] =~ /\/$/
+      withenv :PKG_PATH => @resource[:source] do
+        @resource[:ensure] = old_ensure if (@resource[:ensure] = get_version) == nil
+        full_name = [ @resource[:name], @resource[:ensure], @resource[:flavor] ]
+        pkgadd full_name.join('-').chomp('-')
+      end
+    else
+      pkgadd @resource[:source]
     end
 
-    def query
-        hash = {}
-        info = pkginfo @resource[:name]
+  end
 
-        # Search for the version info
-        if info =~ /Information for (inst:)?#{@resource[:name]}-(\S+)/
-            hash[:ensure] = $2
-        else
-            return nil
-        end
+  def get_version
+      execpipe([command(:pkginfo), " -I ", @resource[:name]]) do |process|
+        # our regex for matching pkg_info output
+        regex = /^(.*)-(\d[^-]*)[-]?(\D*)(.*)$/
+        fields = [ :name, :version, :flavor ]
+        master_version = 0
+
+        process.each do |line|
+          if match = regex.match(line.split[0])
+            # now we return the first version, unless ensure is latest
+            version = match.captures[1]
+            return version unless @resource[:ensure] == "latest"
 
-        # And the description
-        if info =~ /Comment:\s*\n(.+)/
-            hash[:description] = $1
+            master_version = version unless master_version > version
+          end
         end
 
-        return hash
+        return master_version unless master_version == 0
+        raise Puppet::Error, "#{version} is not available for this package"
+      end
+  rescue Puppet::ExecutionFailure
+      return nil
+  end
+
+  def query
+    hash = {}
+    info = pkginfo @resource[:name]
+
+    # Search for the version info
+    if info =~ /Information for (inst:)?#{@resource[:name]}-(\S+)/
+      hash[:ensure] = $2
+    else
+      return nil
     end
 
-    def uninstall
-        pkgdelete @resource[:name]
-    end
+    hash
+  end
+
+  def uninstall
+    pkgdelete @resource[:name]
+  end
 end