puppet 0.23.1 → 0.23.2

data/lib/puppet/provider/mount.rb

@@ -16,6 +16,9 @@ module Puppet::Provider::Mount
         end
         args << @resource[:name]
 
+        if respond_to?(:flush)
+            flush
+        end
         mountcmd(*args)
     end
 
@@ -48,4 +51,4 @@ module Puppet::Provider::Mount
     end
 end
 
-# $Id: mount.rb 2707 2007-07-18 20:40:11Z luke $
+# $Id: mount.rb 2745 2007-08-05 17:49:23Z luke $

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

@@ -0,0 +1,341 @@
+#  Created by Jeff McCune on 2007-07-22
+#  Copyright (c) 2007. All rights reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation (version 2 of the License)
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston MA  02110-1301 USA
+
+require 'puppet'
+require 'puppet/provider/nameservice'
+
+class Puppet::Provider::NameService
+class DirectoryService < Puppet::Provider::NameService
+    # JJM: Dive into the eigenclass
+    class << self
+        # JJM: This allows us to pass information when calling
+        #      Puppet::Type.type
+        #  e.g. Puppet::Type.type(:user).provide :directoryservice, :ds_path => "Users"
+        #  This is referenced in the get_ds_path class method
+        attr_writer :ds_path
+    end
+
+    # JJM 2007-07-24: Not yet sure what initvars() does.  I saw it in netinfo.rb
+    # I do know, however, that it makes methods "work"  =)
+    # e.g. addcmd isn't available if this method call isn't present.
+    #
+    # JJM: Also, where this method is defined seems to impact the visibility
+    #   of methods.  If I put initvars after commands, confine and defaultfor,
+    #   then getinfo is called from the parent class, not this class.
+    initvars()
+    
+    commands :dscl => "/usr/bin/dscl"
+    confine :operatingsystem => :darwin
+    # JJM FIXME: This will need to be the default around October 2007.
+    # defaultfor :operatingsystem => :darwin
+
+
+    # JJM 2007-07-25: This map is used to map NameService attributes to their
+    #     corresponding DirectoryService attribute names.
+    #     See: http://images.apple.com/server/docs/Open_Directory_v10.4.pdf
+    # JJM: Note, this is de-coupled from the Puppet::Type, and must
+    #     be actively maintained.  There may also be collisions with different
+    #     types (Users, Groups, Mounts, Hosts, etc...)
+    @@ds_to_ns_attribute_map = {
+        'RecordName' => :name,
+        'PrimaryGroupID' => :gid,
+        'NFSHomeDirectory' => :home,
+        'UserShell' => :shell,
+        'UniqueID' => :uid,
+        'RealName' => :comment,
+        'Password' => :password,
+    }
+    # JJM The same table as above, inverted.
+    @@ns_to_ds_attribute_map = {
+        :name => 'RecordName',
+        :gid => 'PrimaryGroupID',
+        :home => 'NFSHomeDirectory',
+        :shell => 'UserShell',
+        :uid => 'UniqueID',
+        :comment => 'RealName',
+        :password => 'Password',
+    }
+    
+    def self.instances
+        # JJM Class method that provides an array of instance objects of this
+        #     type.
+        
+        # JJM: Properties are dependent on the Puppet::Type we're managine.
+        type_property_array = [:name] + @resource_type.validproperties
+        # JJM: No sense reporting the password.  It's hashed.
+        type_property_array.delete(:password) if type_property_array.include? :password
+        
+        # Create a new instance of this Puppet::Type for each object present
+        #    on the system.
+        list_all_present.collect do |name_string|
+            self.new(single_report(name_string, *type_property_array))
+        end
+    end
+    
+    def self.get_ds_path
+        # JJM: 2007-07-24 This method dynamically returns the DS path we're concerned with.
+        #      For example, if we're working with an user type, this will be /Users
+        #      with a group type, this will be /Groups.
+        #   @ds_path is an attribute of the class itself.  
+        if defined? @ds_path
+            return @ds_path
+        else
+            # JJM: "Users" or "Groups" etc ...  (Based on the Puppet::Type)
+            #       Remember this is a class method, so self.class is Class
+            #       Also, @resource_type seems to be the reference to the
+            #       Puppet::Type this class object is providing for.
+            return @resource_type.name.to_s.capitalize + "s"
+        end
+    end
+
+    def self.list_all_present
+        # JJM: List all objects of this Puppet::Type already present on the system.
+        begin
+            dscl_output = execute(get_exec_preamble("-list"))
+        rescue Puppet::ExecutionFailure => detail
+            raise Puppet::Error, "Could not get %s list from DirectoryService" % [ @resource_type.name.to_s ]
+        end
+        return dscl_output.split("\n")
+    end
+    
+    def self.single_report(resource_name, *type_properties)
+        # JJM 2007-07-24:
+        #     Given a the name of an object and a list of properties of that
+        #     object, return all property values in a hash.
+        #     
+        #     This class method returns nil if the object doesn't exist
+        #     Otherwise, it returns a hash of the object properties.
+        
+        all_present_str_array = list_all_present()
+        
+        # JJM: Return nil if the named object isn't present.
+        return nil unless all_present_str_array.include? resource_name
+        
+        dscl_vector = get_exec_preamble("-read", resource_name)
+        begin
+            dscl_output = execute(dscl_vector)
+        rescue Puppet::ExecutionFailure => detail
+            raise Puppet::Error, "Could not get report.  command execution failed."
+        end
+        
+        # JJM: We need a new hash to return back to our caller.
+        attribute_hash = Hash.new
+        
+        # JJM: First, the output string goes into an array.
+        #      Then, the each array element is split
+        #      If you want to figure out what this is doing, I suggest
+        #      ruby-debug, and stepping through it.
+        dscl_output.split("\n").each do |line|
+            # JJM: Split the attribute name and the list of values.
+            ds_attribute, ds_values_string = line.split(':')
+            
+            # JJM: skip this attribute line if the Puppet::Type doesn't care about it.
+            next unless (@@ds_to_ns_attribute_map.keys.include?(ds_attribute) \
+                and type_properties.include? @@ds_to_ns_attribute_map[ds_attribute])
+
+            # JJM: We asked dscl to output url encoded values so we're able
+            #     to machine parse on whitespace.  We need to urldecode:
+            #     " Jeff%20McCune John%20Doe " => ["Jeff McCune", "John Doe"]
+            ds_value_array = ds_values_string.scan(/[^\s]+/).collect do |v|
+                url_decoded_value = CGI::unescape v
+                if url_decoded_value =~ /^[-0-9]+$/
+                    url_decoded_value.to_i
+                else                
+                    url_decoded_value
+                end
+            end
+            
+            # JJM: Finally, we're able to build up our attribute hash.
+            #    Remember, the hash is keyed by NameService attribute names,
+            #    not DirectoryService attribute names.
+            # NOTE: We're also sort of cheating here...  DirectoryService
+            #   is robust enough to allow multiple values for almost every
+            #   attribute in the system.  Traditional NameService things
+            #   really don't handle this case, so we'll always pull thet first
+            #   value returned from DirectoryService.
+            #   THERE MAY BE AN ORDERING ISSUE HERE, but I think it's ok...
+            attribute_hash[@@ds_to_ns_attribute_map[ds_attribute]] = ds_value_array[0]
+        end
+        return attribute_hash
+    end
+    
+    def self.get_exec_preamble(ds_action, resource_name = nil)
+        # JJM 2007-07-24
+        #     DSCL commands are often repetitive and contain the same positional
+        #     arguments over and over. See http://developer.apple.com/documentation/Porting/Conceptual/PortingUnix/additionalfeatures/chapter_10_section_9.html
+        #     for an example of what I mean.
+        #     This method spits out proper DSCL commands for us.
+        #     We EXPECT name to be @resource[:name] when called from an instance object.
+
+        # JJM: With dscl, the domain "/" is always the default local domain.
+        #      The domain /Search will search all domains, and you may
+        #      get at specific domains with /LDAPv3/server1.foobar.com,
+        #      /LDAPv3/server2.foobar.com, etc...
+        command_vector = [ command(:dscl), "-url", "/" ]
+        # JJM: The actual action to perform.  See "man dscl"
+        #      Common actiosn: -create, -delete, -merge, -append, -passwd
+        command_vector << ds_action
+        # JJM: get_ds_path will spit back "Users" or "Groups",
+        # etc...  Depending on the Puppet::Type of our self.
+        if resource_name
+            command_vector << "/%s/%s" % [ get_ds_path, resource_name ]
+        else
+            command_vector << "/%s" % [ get_ds_path ]
+        end
+        # JJM:  This returns most of the preamble of the command.
+        #       e.g. 'dscl / -create /Users/mccune'
+        return command_vector
+    end
+
+    def ensure=(ensure_value)
+        super
+        # JJM: Modeled after nameservice/netinfo.rb, we need to
+        #   loop over all valid properties for the type we're managing
+        #   and call the method which sets that property value
+        #   Like netinfo, dscl can't create everything at once, afaik.
+        if ensure_value == :present
+            @resource.class.validproperties.each do |name|
+                next if name == :ensure
+                next unless val = @resource.should(name) || autogen(name)
+                # JJM: This calls the method.
+                self.send(name.to_s + "=", val)
+            end
+        end 
+    end
+    
+    def password=(passphrase)
+        # JJM: Setting the password is a special case.  We don't just
+        #      set the attribute because we need to update the password
+        #      databases.
+        # FIRST, make sure the AuthenticationAuthority is ;ShadowHash;  If
+        #  we don't do this, we don't get a shadow hash account.  ("Obviously...")
+        dscl_vector = self.class.get_exec_preamble("-create", @resource[:name])
+        dscl_vector << "AuthenticationAuthority" << ";ShadowHash;"
+        begin
+            dscl_output = execute(dscl_vector)
+        rescue Puppet::ExecutionFailure => detail
+            raise Puppet::Error, "Could not set AuthenticationAuthority."
+        end        
+        
+        # JJM: Second, we need to actually set the password.  dscl does
+        #   some magic, creating the proper hash for us based on the
+        #   AuthenticationAuthority attribute, set above.
+        dscl_vector = self.class.get_exec_preamble("-passwd", @resource[:name])
+        dscl_vector << passphrase
+        # JJM: Should we not log the password string?  This may be a security
+        #      risk...
+        begin
+            dscl_output = execute(dscl_vector)
+        rescue Puppet::ExecutionFailure => detail
+            raise Puppet::Error, "Could not set password using command vector: %{dscl_vector.inspect}"
+        end
+    end
+    
+    # JJM: nameservice.rb defines methods for each attribute of the type.
+    #   We implement these methods here, by implementing get() and set()
+    #   See the resource_type= method defined in nameservice.rb
+    #   I'm not sure what the implications are of doing things this way.
+    #   It was a bit difficult to sort out what was happening in my head,
+    #   but ruby-debug makes this process much more transparent.
+    #
+    def set(property, value)
+        # JJM: As it turns out, the set method defined in our parent class
+        #   is fine.  It just calls the modifycmd() method, which
+        #   I'll implement here.
+        super
+    end
+    
+    def get(param)
+        hash = getinfo(false)
+        if hash
+            return hash[param]
+        else
+            return :absent
+        end
+    end
+    
+    def modifycmd(property, value)
+        # JJM: This method will assemble a exec vector which modifies
+        #    a single property and it's value using dscl.
+        # JJM: With /usr/bin/dscl, the -create option will destroy an
+        #      existing property record if it exists
+        exec_arg_vector = self.class.get_exec_preamble("-create", @resource[:name])
+        # JJM: The following line just maps the NS name to the DS name
+        #      e.g. { :uid => 'UniqueID' }
+        exec_arg_vector << @@ns_to_ds_attribute_map[symbolize(property)]
+        # JJM: The following line sends the actual value to set the property to
+        exec_arg_vector << value.to_s
+        return exec_arg_vector
+    end
+    
+    def addcmd
+        # JJM 2007-07-24: 
+        #    - addcmd returns an array to be executed to create a new object.
+        #    - This method is probably being called from the
+        #      ensure= method in nameservice.rb, or here...
+        #    - This should only be called if the object doesn't exist.
+        # JJM: Blame nameservice.rb for the terse method name. =)
+        #
+        self.class.get_exec_preamble("-create", @resource[:name])
+    end
+    
+    def deletecmd
+        # JJM: Like addcmd, only called when deleting the object itself
+        #    Note, this isn't used to delete properties of the object,
+        #    at least that's how I understand it...
+        self.class.get_exec_preamble("-delete", @resource[:name])
+    end
+    
+    def getinfo(refresh = false)
+        # JJM 2007-07-24: 
+        #      Override the getinfo method, which is also defined in nameservice.rb
+        #      This method returns and sets @infohash, which looks like:
+        #      (NetInfo provider, user type...)
+        #       @infohash = {:comment=>"Jeff McCune", :home=>"/Users/mccune", 
+        #       :shell=>"/bin/zsh", :password=>"********", :uid=>502, :gid=>502,
+        #       :name=>"mccune"}
+        #
+        # I'm not re-factoring the name "getinfo" because this method will be
+        # most likely called by nameservice.rb, which I didn't write.
+        if refresh or (! defined?(@property_value_cache_hash) or ! @property_value_cache_hash)
+            # JJM 2007-07-24: OK, there's a bit of magic that's about to
+            # happen... Let's see how strong my grip has become... =)
+            # 
+            # self is a provider instance of some Puppet::Type, like
+            # Puppet::Type::User::ProviderDirectoryservice for the case of the
+            # user type and this provider.
+            # 
+            # self.class looks like "user provider directoryservice", if that
+            # helps you ...
+            # 
+            # self.class.resource_type is a reference to the Puppet::Type class,
+            # probably Puppet::Type::User or Puppet::Type::Group, etc...
+            # 
+            # self.class.resource_type.validproperties is a class method,
+            # returning an Array of the valid properties of that specific
+            # Puppet::Type.
+            # 
+            # So... something like [:comment, :home, :password, :shell, :uid,
+            # :groups, :ensure, :gid]
+            # 
+            # Ultimately, we add :name to the list, delete :ensure from the
+            # list, then report on the remaining list. Pretty whacky, ehh?
+            type_properties = [:name] + self.class.resource_type.validproperties
+            type_properties.delete(:ensure) if type_properties.include? :ensure
+            @property_value_cache_hash = self.class.single_report(@resource[:name], *type_properties)
+        end
+        return @property_value_cache_hash
+    end
+end
+end

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

@@ -24,7 +24,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
             # now turn each returned line into a package object
             process.each { |line|
                 if match = regex.match(line)
-                    hash.clear
+                    hash = {}
 
                     fields.zip(match.captures) { |field,value|
                         hash[field] = value
@@ -122,4 +122,4 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     end
 end
 
-# $Id: dpkg.rb 2708 2007-07-18 23:48:58Z luke $
+# $Id: dpkg.rb 2753 2007-08-07 02:38:45Z luke $

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

@@ -21,7 +21,6 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
 
                 # now turn each returned line into a package object
                 process.each { |line|
-                    hash.clear
                     if match = regex.match(line)
                         fields.zip(match.captures) { |field,value|
                             hash[field] = value
@@ -32,6 +31,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
                         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
@@ -85,4 +85,4 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
     end
 end
 
-# $Id: openbsd.rb 2555 2007-06-08 17:20:00Z luke $
+# $Id: openbsd.rb 2753 2007-08-07 02:38:45Z luke $

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

@@ -30,13 +30,11 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
                 # our regex for matching dpkg output
                 regex = %r{^(\S+)\s+(\S+)}
                 fields = [:name, :ensure]
-                hash = {}
 
                 # now turn each returned line into a package object
                 process.each { |line|
                     if match = regex.match(line)
-                        hash.clear
-
+                        hash = {}
                         fields.zip(match.captures) { |field,value|
                             hash[field] = value
                         }
@@ -129,4 +127,4 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     end
 end
 
-# $Id: rpm.rb 2701 2007-07-16 23:43:50Z luke $
+# $Id: rpm.rb 2753 2007-08-07 02:38:45Z luke $

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

@@ -43,7 +43,7 @@ Puppet::Type.type(:package).provide :sun, :parent => Puppet::Provider::Package d
                     hash[:provider] = :sun
 
                     packages << new(hash)
-                    hash.clear
+                    hash = {}
                 when /\s*(\w+):\s+(.+)/:
                     name = $1
                     value = $2
@@ -167,4 +167,4 @@ Puppet::Type.type(:package).provide :sun, :parent => Puppet::Provider::Package d
     end
 end
 
-# $Id: sun.rb 2581 2007-06-14 06:21:40Z luke $
+# $Id: sun.rb 2753 2007-08-07 02:38:45Z luke $

data/lib/puppet/provider/parsedfile.rb

@@ -110,7 +110,7 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
     def self.instances
         prefetch()
         @records.find_all { |r| r[:record_type] == self.name }.collect { |r|
-            new(clean(r))
+            new(r)
         }
     end
 
@@ -134,27 +134,16 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
                 if @property_hash[attr] or self.class.valid_attr?(self.class.name, attr)
                     @property_hash[attr] || :absent
                 else
-                    @resource.should(attr)
+                    if defined? @resource
+                        @resource.should(attr)
+                    else
+                        nil
+                    end
                 end
             end
 
             define_method(attr.to_s + "=") do |val|
-                # Mark that this target was modified.
-                resourcetarget = @resource.should(:target) || self.class.default_target
-
-                # If they're the same, then just mark that one as modified
-                if @property_hash[:target] and @property_hash[:target] == resourcetarget
-                    self.class.modified(resourcetarget)
-                else
-                    # Always mark the resourcetarget as modified, and if there's
-                    # and old property_hash target, mark it as modified and replace
-                    # it.
-                    self.class.modified(resourcetarget)
-                    if @property_hash[:target]
-                        self.class.modified(@property_hash[:target])
-                    end
-                    @property_hash[:target] = resourcetarget
-                end
+                mark_target_modified
                 @property_hash[attr] = val
             end
         end
@@ -296,14 +285,13 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
         header + text
     end
 
-
     def create
         @resource.class.validproperties.each do |property|
             if value = @resource.should(property)
                 @property_hash[property] = value
             end
         end
-        self.class.modified(@property_hash[:target] || self.class.default_target)
+        mark_target_modified()
         return (@resource.class.name.to_s + "_created").intern
     end
 
@@ -338,16 +326,15 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
         #@property_hash = {}
     end
 
-    def initialize(resource)
+    def initialize(record)
         super
 
-        # See if there's already a matching property_hash in the records list;
-        # else, use a default value.
-        # We provide a default for 'ensure' here, because the provider will
-        # override it if the thing exists, but it won't touch it if it doesn't
-        # exist.
-        @property_hash = self.class.record?(resource[:name]) ||
-            {:record_type => self.class.name, :ensure => :absent}
+        # The 'record' could be a resource or a record, depending on how the provider
+        # is initialized.  If we got an empty property hash (probably because the resource
+        # is just being initialized), then we want to set up some defualts.
+        if @property_hash.empty?
+            @property_hash = self.class.record?(resource[:name]) || {:record_type => self.class.name, :ensure => :absent}
+        end
     end
 
     # Retrieve the current state from disk.
@@ -357,6 +344,22 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
         end
         self.class.prefetch(@resource[:name] => @resource)
     end
+
+    def record_type
+        @property_hash[:record_type]
+    end
+
+    private
+
+    # Mark both the resource and provider target as modified.
+    def mark_target_modified
+        if defined? @resource and restarget = @resource.should(:target) and restarget != @property_hash[:target]
+            self.class.modified(restarget)
+        end
+        if @property_hash[:target] != :absent
+            self.class.modified(@property_hash[:target])
+        end
+    end
 end
 
-# $Id: parsedfile.rb 2722 2007-07-20 16:27:44Z luke $
+# $Id: parsedfile.rb 2750 2007-08-06 17:59:37Z luke $