puppet 0.24.4 → 0.24.5

data/lib/puppet/provider/cron/crontab.rb

@@ -30,7 +30,7 @@ Puppet::Type.type(:cron).provide(:crontab,
         }
 
     crontab = record_line :crontab, :fields => %w{minute hour monthday month weekday command},
-        :match => %r{^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.+)$},
+        :match => %r{^\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.+)$},
         :optional => %w{minute hour weekday month monthday}, :absent => "*"
 
     class << crontab
@@ -69,7 +69,11 @@ Puppet::Type.type(:cron).provide(:crontab,
                 end
             end
 
-            str += join(record)
+            if record[:special]
+                str += "@%s %s" % [record[:special], record[:command]]
+            else
+                str += join(record)
+            end
             str
         end
     end

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

@@ -17,7 +17,7 @@ Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameSe
                 cmd << flag(:gid) << gid
             end
         end
-        if @resource[:allowdupe] == :true
+        if @resource.allowdupe?
             cmd << "-o"
         end
         cmd << @resource[:name]

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

@@ -0,0 +1,48 @@
+require 'puppet/provider/ldap'
+
+Puppet::Type.type(:group).provide :ldap, :parent => Puppet::Provider::Ldap do
+    desc "Group management via ``ldap``.  This provider requires that you
+        have valid values for all of the ldap-related settings,
+        including ``ldapbase``.  You will also almost definitely need settings
+        for ``ldapuser`` and ``ldappassword``, so that your clients can write
+        to ldap.
+        
+        Note that this provider will automatically generate a GID for you if
+        you do not specify one, but it is a potentially expensive operation,
+        as it iterates across all existing groups to pick the appropriate next
+        one."
+
+    confine :true => Puppet.features.ldap?, :false => (Puppet[:ldapuser] == "")
+
+    # We're mapping 'members' here because we want to make it
+    # easy for the ldap user provider to manage groups.  This
+    # way it can just use the 'update' method in the group manager,
+    # whereas otherwise it would need to replicate that code.
+    manages(:posixGroup).at("ou=Groups").and.maps :name => :cn, :gid => :gidNumber, :members => :memberUid
+
+    # Find the next gid after the current largest gid.
+    provider = self
+    manager.generates(:gidNumber).with do 
+        largest = 500
+        if existing = provider.manager.search
+                existing.each do |hash|
+                next unless value = hash[:gid]
+                num = value[0].to_i
+                if num > largest
+                    largest = num
+                end
+            end
+        end
+        largest + 1
+    end
+
+    # Convert a group name to an id.
+    def self.name2id(group)
+        return nil unless result = manager.search("cn=%s" % group) and result.length > 0
+
+        # Only use the first result.
+        group = result[0]
+        gid = group[:gid][0]
+        return gid
+    end
+end

data/lib/puppet/provider/ldap.rb

@@ -0,0 +1,137 @@
+require 'puppet/provider'
+
+# The base class for LDAP providers.
+class Puppet::Provider::Ldap < Puppet::Provider
+    require 'puppet/util/ldap/manager'
+
+    class << self
+        attr_reader :manager
+    end
+
+    # Look up all instances at our location.  Yay.
+    def self.instances
+        return [] unless list = manager.search
+
+        list.collect { |entry| new(entry) }
+    end
+
+    # Specify the ldap manager for this provider, which is
+    # used to figure out how we actually interact with ldap.
+    def self.manages(*args)
+        @manager = Puppet::Util::Ldap::Manager.new
+        @manager.manages(*args)
+
+        # Set up our getter/setter methods.
+        mk_resource_methods
+        return @manager
+    end
+
+    # Query all of our resources from ldap.
+    def self.prefetch(resources)
+        resources.each do |name, resource|
+            if result = manager.find(name)
+                result[:ensure] = :present
+                resource.provider = new(result)
+            else
+                resource.provider = new(:ensure => :absent)
+            end
+        end
+    end
+
+    attr_reader :ldap_properties
+
+    def manager
+        self.class.manager
+    end
+
+    def create
+        @property_hash[:ensure] = :present
+        self.class.resource_type.validproperties.each do |property|
+            if val = resource.should(property)
+                @property_hash[property] = val
+            end
+        end
+    end
+
+    def delete
+        @property_hash[:ensure] = :absent
+    end
+
+    def exists?
+        @property_hash[:ensure] != :absent
+    end
+
+    # Apply our changes to ldap, yo.
+    def flush
+        # Just call the manager's update() method.
+        @property_hash.delete(:groups)
+        @ldap_properties.delete(:groups)
+        manager.update(name, ldap_properties, properties)
+        @property_hash.clear
+        @ldap_properties.clear
+    end
+
+    def initialize(*args)
+        raise(Puppet::DevError, "No LDAP Configuration defined for %s" % self.class) unless self.class.manager
+        raise(Puppet::DevError, "Invalid LDAP Configuration defined for %s" % self.class) unless self.class.manager.valid?
+        super
+
+        @property_hash = @property_hash.inject({}) do |result, ary|
+            param, values = ary
+
+            # Skip any attributes we don't manage.
+            next result unless self.class.resource_type.validattr?(param)
+
+            paramclass = self.class.resource_type.attrclass(param)
+
+            unless values.is_a?(Array)
+                result[param] = values
+                next result
+            end
+
+            # Only use the first value if the attribute class doesn't manage
+            # arrays of values.
+            if paramclass.superclass == Puppet::Parameter or paramclass.array_matching == :first
+                result[param] = values[0]
+            else
+                result[param] = values
+            end
+            result
+        end
+
+        # Make a duplicate, so that we have a copy for comparison 
+        # at the end.
+        @ldap_properties = @property_hash.dup
+    end
+
+    # Return the current state of ldap.
+    def ldap_properties
+        @ldap_properties.dup
+    end
+
+    # Return (and look up if necessary) the desired state.
+    def properties
+        if @property_hash.empty?
+            @property_hash = query || {:ensure => :absent}
+            if @property_hash.empty?
+                @property_hash[:ensure] = :absent
+            end
+        end
+        @property_hash.dup
+    end
+
+    # Collect the current attributes from ldap.  Returns
+    # the results, but also stores the attributes locally,
+    # so we have something to compare against when we update.
+    # LAK:NOTE This is normally not used, because we rely on prefetching.
+    def query
+        # Use the module function.
+        unless attributes = manager.find(name)
+            @ldap_properties = {}
+            return nil
+        end
+
+        @ldap_properties = attributes
+        return @ldap_properties.dup
+    end
+end

data/lib/puppet/provider/nameservice.rb

@@ -323,8 +323,7 @@ class Puppet::Provider::NameService < Puppet::Provider
         begin
             execute(cmd)
         rescue Puppet::ExecutionFailure => detail
-            raise Puppet::Error, "Could not set %s on %s[%s]: %s" %
-                [param, @resource.class.name, @resource.name, detail]
+            raise Puppet::Error, "Could not set %s on %s[%s]: %s" % [param, @resource.class.name, @resource.name, detail]
         end
     end
 end

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

@@ -22,10 +22,8 @@ class ObjectAdd < Puppet::Provider::NameService
     end
 
     def modifycmd(param, value)
-        cmd = [command(:modify),
-            flag(param),
-            value]
-        if @resource[:allowdupe]  == :true
+        cmd = [command(:modify), flag(param), value]
+        if @resource.allowdupe? && ((param == :uid and self.class.name == :useradd) || (param == :gid and self.class.name == :groupadd))
             cmd << "-o"
         end
         cmd << @resource[:name]
@@ -41,4 +39,3 @@ class ObjectAdd < Puppet::Provider::NameService
     end
 end
 end
-

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

@@ -53,7 +53,22 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
         unless file = @resource[:source]
             raise ArgumentError, "You cannot install dpkg packages without a source"
         end
-        dpkg "-i", file
+        
+        args = []
+
+        if config = @resource[:configfiles]
+            case config
+            when :keep
+                args << '--force-confold'
+            when :replace
+                args << '--force-confnew'
+            else
+                raise Puppet::Error, "Invalid 'configfiles' value %s" % config
+            end
+        end
+        args << '-i' << file
+
+        dpkg(*args)
     end
 
     def update

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

@@ -18,11 +18,22 @@ Puppet::Type.type(:package).provide :freebsd, :parent => :openbsd do
     def install
         should = @resource.should(:ensure)
 
-        if @resource[:source]
-            return super
+        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
-
-        pkgadd "-r", @resource[:name]
     end
 
     def query

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

@@ -1,9 +1,12 @@
 require 'puppet/provider/package'
+require 'uri'
 
 # Ruby gems support.
 Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package do
-    desc "Ruby Gem support.  By default uses remote gems, but you can specify
-        the path to a local gem via ``source``."
+    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
 
@@ -65,20 +68,38 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
     end
 
     def install(useversion = true)
-        command = ["install"]
-        if (! @resource.should(:ensure).is_a? Symbol) and useversion
-            command << "-v" << @resource.should(:ensure)
+        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]
-            command << source
+        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]
+            command << resource[:name]
         end
 
-        output = gemcmd(*command)
+        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
@@ -87,17 +108,17 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
 
     def latest
         # This always gets the latest version available.
-        hash = self.class.gemlist(:justme => @resource[:name])
+        hash = self.class.gemlist(:justme => resource[:name])
 
         return hash[:ensure]
     end
 
     def query
-        self.class.gemlist(:justme => @resource[:name], :local => true)
+        self.class.gemlist(:justme => resource[:name], :local => true)
     end
 
     def uninstall
-        gemcmd "uninstall", "-x", "-a", @resource[:name]
+        gemcmd "uninstall", "-x", "-a", resource[:name]
     end
 
     def update

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

@@ -28,66 +28,7 @@
 require 'puppet/provider/package'
 
 Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Package do
-    desc "Package management based on Apple's Installer.app and DiskUtility.app
-    
-Author: Jeff McCune <jeff@northstarlabs.net>
-
-Please direct questions about this provider to the puppet-users mailing list.
-
-This package 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. Sub directories are not checked for packages.
-
-This provider always assumes the label (formerly called 'name') attribute
-declared in the manifest will always exactly match the file name (without
-path) of the DMG file itself. Therefore, if you want to install packages in
-'Foobar.pkg.dmg' you must explicitly specify the label::
-
-    package { Foobar.pkg.dmg: ensure => installed, provider => pkgdmg }
-
-Only the dmg file name itself is used when puppet determines if the packages
-contained within are currently installed. For example, if a package resource
-named 'Foobar.pkg.dmg' is named for installation and contains multiple
-packages, this provider will install all packages in the root directory of
-this file system, then create a small cookie for the whole bundle, located at
-/var/db/.puppet_pkgdmg_installed_Foobar.pkg.dmg
-
-As a result, if you change the contents of the DMG file in any way, Puppet
-will not update or re-install the packages contained within unless you change
-the file name of the DMG wrapper itself. Therefore, if you use this provider,
-I recommend you name the DMG wrapper files in a manner that lends itself to
-incremental version changes. I include some version or date string in the DMG
-name, like so::
-
-    Firefox-2.0.0.3-1.pkg.dmg
-
-If I realize I've mis-packaged this DMG, then I have the option to increment
-the package version, yielding Firefox-2.0.0.3-2.pkg.dmg.
-
-This provider allows you to host DMG files within an FTP or HTTP server. This
-is primarily how the author provider distributes software. Any URL mechanism
-curl or Ruby's open-uri module supports is supported by this provider. Curl
-supported URL's yield much faster data throughput than open-uri, so I
-recommend HTTP, HTTPS, or FTP for source package repositories.
-
-Because the provider assumes packages will be transfered via CURL, a two stage
-process occurs. First, if a URL is detected, curl is invoked to transfer the
-file into a temporary directory. If no URL is present, the provider skips
-straight to step 2. In step two, the source file is mounted, then packages
-installed, and finally the DMG file is removed.
-
-If this is a problem for you, please patch the code, or bug Jeff to fix this.
-
-Example usage::
-
-    package { Thunderbird-2.0.0.4-1.pkg.dmg:
-      provider => pkgdmg, ensure => present
-      source => 'http://0.0.0.0:8000/packages/Thunderbird-2.0.0.4-1.pkg.dmg',
-    }
-
-**WARNING**: Because I assume files will be downloaded to /tmp, the current
-implementation attempts to delete DMG files if you install directly from the
-file system and not via a URL method."
+    desc "Package management based on Apple's Installer.app and DiskUtility.app.  This package 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. Sub directories are not checked for packages.  See `the wiki docs </trac/puppet/wiki/DmgPackages>` for more detail."
   
     confine :exists => "/Library/Receipts"
     commands :installer => "/usr/sbin/installer"