puppet 0.24.9 → 0.25.0

data/lib/puppet/util/posix.rb

@@ -28,7 +28,7 @@ module Puppet::Util::POSIX
     end
 
     # A degenerate method of retrieving name/id mappings.  The job of this method is
-    # to retrieve all objects of a certain type, search for a specific entry 
+    # to retrieve all objects of a certain type, search for a specific entry
     # and then return a given field from that entry.
     def search_posix_field(type, field, id)
         idmethod = idfield(type)
@@ -52,81 +52,42 @@ module Puppet::Util::POSIX
         # Apparently the group/passwd methods need to get reset; if we skip
         # this call, then new users aren't found.
         case type
-        when :passwd: Etc.send(:endpwent)
-        when :group: Etc.send(:endgrent)
+        when :passwd; Etc.send(:endpwent)
+        when :group; Etc.send(:endgrent)
         end
         return nil
     end
-    
-    # Look in memory for an already-managed type and use its info if available.
-    # Currently unused.
-    def get_provider_value(type, field, id)
-        unless typeklass = Puppet::Type.type(type)
-            raise ArgumentError, "Invalid type %s" % type
-        end
-        
-        id = id.to_s
-        
-        chkfield = idfield(type)
-        obj = typeklass.find { |obj|
-            if id =~ /^\d+$/
-                obj.should(chkfield).to_s == id ||
-                    obj.provider.send(chkfield) == id
-            else 
-                obj[:name] == id
-            end                    
-        }
-        
-        return nil unless obj
-        
-        if obj.provider
-            begin
-                val = obj.provider.send(field)
-                if val == :absent
-                    return nil
-                else
-                    return val
-                end
-            rescue => detail
-                if Puppet[:trace]
-                    puts detail.backtrace
-                    Puppet.err detail
-                    return nil
-                end
-            end
-        end
-    end
-    
+
     # Determine what the field name is for users and groups.
     def idfield(space)
         case Puppet::Util.symbolize(space)
-        when :gr, :group: return :gid
-        when :pw, :user, :passwd: return :uid
+        when :gr, :group; return :gid
+        when :pw, :user, :passwd; return :uid
         else
             raise ArgumentError.new("Can only handle users and groups")
         end
     end
-    
+
     # Determine what the method is to get users and groups by id
     def methodbyid(space)
         case Puppet::Util.symbolize(space)
-        when :gr, :group: return :getgrgid
-        when :pw, :user, :passwd: return :getpwuid
+        when :gr, :group; return :getgrgid
+        when :pw, :user, :passwd; return :getpwuid
         else
             raise ArgumentError.new("Can only handle users and groups")
         end
     end
-    
+
     # Determine what the method is to get users and groups by name
     def methodbyname(space)
         case Puppet::Util.symbolize(space)
-        when :gr, :group: return :getgrnam
-        when :pw, :user, :passwd: return :getpwnam
+        when :gr, :group; return :getgrnam
+        when :pw, :user, :passwd; return :getpwnam
         else
             raise ArgumentError.new("Can only handle users and groups")
         end
     end
-    
+
     # Get the GID of a given group, provided either a GID or a name
     def gid(group)
         begin

data/lib/puppet/util/provider_features.rb

@@ -14,7 +14,7 @@ module Puppet::Util::ProviderFeatures
 
         # Are all of the requirements met?
         def available?(obj)
-            if self.methods 
+            if self.methods
                 if methods_available?(obj)
                     return true
                 else
@@ -126,8 +126,8 @@ module Puppet::Util::ProviderFeatures
             # Create a method that will list all functional features.
             @feature_module.send(:define_method, :features) do
                 return false unless defined?(features)
-                features.keys.find_all { |n| feature?(n) }.sort { |a,b| 
-                    a.to_s <=> b.to_s 
+                features.keys.find_all { |n| feature?(n) }.sort { |a,b|
+                    a.to_s <=> b.to_s
                 }
             end
 

data/lib/puppet/util/queue.rb

@@ -0,0 +1,96 @@
+
+require 'puppet/indirector'
+require 'puppet/util/instance_loader'
+
+# Implements a message queue client type plugin registry for use by the indirector facility.
+# Client modules for speaking a particular protocol (e.g. Stomp::Client for Stomp message
+# brokers, Memcached for Starling and Sparrow, etc.) register themselves with this module.
+#
+# Client classes are expected to live under the Puppet::Util::Queue namespace and corresponding
+# directory; the attempted use of a client via its typename (see below) will cause Puppet::Util::Queue
+# to attempt to load the corresponding plugin if it is not yet loaded.  The client class registers itself
+# with Puppet::Util::Queue and should use the same type name as the autloader expects for the plugin file.
+#   class Puppet::Util::Queue::SpecialMagicalClient < Messaging::SpecialMagic
+#       ...
+#       Puppet::Util::Queue.register_queue_type_class(self)
+#   end
+#
+# This module reduces the rightmost segment of the class name into a pretty symbol that will
+# serve as the queuing client's name.  Which means that the "SpecialMagicalClient" above will
+# be named <em>:special_magical_client</em> within the registry.
+#
+# Another class/module may mix-in this module, and may then make use of the registered clients.
+#   class Queue::Fue
+#       # mix it in at the class object level rather than instance level
+#       extend ::Puppet::Util::Queue
+#   end
+#
+# Queue::Fue instances can get a message queue client through the registry through the mixed-in method
+# +client+, which will return a class-wide singleton client instance, determined by +client_class+.
+#
+# The client plugins are expected to implement an interface similar to that of Stomp::Client:
+# * <tt>new()</tt> should return a connected, ready-to-go client instance.  Note that no arguments are passed in.
+# * <tt>send_message(queue, message)</tt> should send the _message_ to the specified _queue_.
+# * <tt>subscribe(queue)</tt> _block_ subscribes to _queue_ and executes _block_ upon receiving a message.
+# * _queue_ names are simple names independent of the message broker or client library.  No "/queue/" prefixes like in Stomp::Client.
+module Puppet::Util::Queue
+    extend Puppet::Util::InstanceLoader
+    instance_load :queue_clients, 'puppet/util/queue'
+
+    # Adds a new class/queue-type pair to the registry.  The _type_ argument is optional; if not provided,
+    # _type_ defaults to a lowercased, underscored symbol programmatically derived from the rightmost
+    # namespace of <em>klass.name</em>.
+    #
+    #   # register with default name +:you+
+    #   register_queue_type(Foo::You)
+    #
+    #   # register with explicit queue type name +:myself+
+    #   register_queue_type(Foo::Me, :myself)
+    #
+    # If the type is already registered, an exception is thrown.  No checking is performed of _klass_,
+    # however; a given class could be registered any number of times, as long as the _type_ differs with
+    # each registration.
+    def self.register_queue_type(klass, type = nil)
+        type ||= queue_type_from_class(klass)
+        raise Puppet::Error, "Queue type %s is already registered" % type.to_s if instance_hash(:queue_clients).include?(type)
+        instance_hash(:queue_clients)[type] = klass
+    end
+
+    # Given a queue type symbol, returns the associated +Class+ object.  If the queue type is unknown
+    # (meaning it hasn't been registered with this module), an exception is thrown.
+    def self.queue_type_to_class(type)
+        c = loaded_instance :queue_clients, type
+        raise Puppet::Error, "Queue type %s is unknown." % type unless c
+        c
+    end
+
+    # Given a class object _klass_, returns the programmatic default queue type name symbol for _klass_.
+    # The algorithm is as shown in earlier examples; the last namespace segment of _klass.name_ is taken
+    # and converted from mixed case to underscore-separated lowercase, and interned.
+    #   queue_type_from_class(Foo) -> :foo
+    #   queue_type_from_class(Foo::Too) -> :too
+    #   queue_type_from_class(Foo::ForYouTwo) -> :for_you_too
+    #
+    # The implicit assumption here, consistent with Puppet's approach to plugins in general,
+    # is that all your client modules live in the same namespace, such that reduction to
+    # a flat namespace of symbols is reasonably safe.
+    def self.queue_type_from_class(klass)
+        # convert last segment of classname from studly caps to lower case with underscores, and symbolize
+        klass.name.split('::').pop.sub(/^[A-Z]/) {|c| c.downcase}.gsub(/[A-Z]/) {|c| '_' + c.downcase }.intern
+    end
+
+    # The class object for the client to be used, determined by queue configuration
+    # settings.
+    # Looks to the <tt>:queue_type</tt> configuration entry in the running application for
+    # the default queue type to use.
+    def client_class
+        Puppet::Util::Queue.queue_type_to_class(Puppet[:queue_type])
+    end
+
+    # Returns (instantiating as necessary) the singleton queue client instance, according to the
+    # client_class.  No arguments go to the client class constructor, meaning its up to the client class
+    # to know how to determine its queue message source (presumably through Puppet configuration data).
+    def client
+        @client ||= client_class.new
+    end
+end

data/lib/puppet/util/queue/stomp.rb

@@ -0,0 +1,47 @@
+require 'puppet/util/queue'
+require 'stomp'
+require 'uri'
+
+# Implements the Ruby Stomp client as a queue type within the Puppet::Indirector::Queue::Client
+# registry, for use with the <tt>:queue</tt> indirection terminus type.
+#
+# Looks to <tt>Puppet[:queue_source]</tt> for the sole argument to the underlying Stomp::Client constructor;
+# consequently, for this client to work, <tt>Puppet[:queue_source]</tt> must use the Stomp::Client URL-like
+# syntax for identifying the Stomp message broker: <em>login:pass@host.port</em>
+class Puppet::Util::Queue::Stomp
+    attr_accessor :stomp_client
+
+    def initialize
+        begin
+            uri = URI.parse(Puppet[:queue_source])
+        rescue => detail
+            raise ArgumentError, "Could not create Stomp client instance - queue source %s is invalid: %s" % [Puppet[:queue_source], detail]
+        end
+        unless uri.scheme == "stomp"
+            raise ArgumentError, "Could not create Stomp client instance - queue source %s is not a Stomp URL: %s" % [Puppet[:queue_source], detail]
+        end
+
+        begin
+            self.stomp_client = Stomp::Client.new(uri.user, uri.password, uri.host, uri.port, true)
+        rescue => detail
+            raise ArgumentError, "Could not create Stomp client instance with queue source %s: got internal Stomp client error %s" % [Puppet[:queue_source], detail]
+        end
+    end
+
+    def send_message(target, msg)
+        stomp_client.send(stompify_target(target), msg, :persistent => true)
+    end
+
+    def subscribe(target)
+        stomp_client.subscribe(stompify_target(target), :ack => :client) do |stomp_message|
+            yield(stomp_message.body)
+            stomp_client.acknowledge(stomp_message)
+        end
+    end
+
+    def stompify_target(target)
+        '/queue/' + target.to_s
+    end
+
+    Puppet::Util::Queue.register_queue_type(self, :stomp)
+end

data/lib/puppet/util/rails/cache_accumulator.rb

@@ -0,0 +1,65 @@
+require 'puppet/util'
+
+module Puppet::Util::CacheAccumulator
+    def self.included(klass)
+        klass.extend ClassMethods
+    end
+
+    class Base
+        attr_reader :klass, :attribute
+
+        def initialize(klass, attribute)
+            @klass = klass
+            @attribute = attribute
+            @find_or_create = "find_or_create_by_#{@attribute.to_s}".intern
+        end
+
+        def store
+            @store || reset
+        end
+
+        def reset
+            @store = {}
+        end
+
+        def find(*keys)
+            result = nil
+            if keys.length == 1
+                result = store[keys[0]] ||= @klass.send(@find_or_create, *keys)
+            else
+                found, missing = keys.partition {|k| store.include? k}
+                result = found.length
+                result += do_multi_find(missing) if missing.length > 0
+            end
+            result
+        end
+
+        def do_multi_find(keys)
+            result = 0
+            @klass.find(:all, :conditions => {@attribute => keys}).each do |obj|
+                store[obj.send(@attribute)] = obj
+                result += 1
+            end
+            result
+        end
+    end
+
+    module ClassMethods
+        def accumulates(*attributes)
+            attributes.each {|attrib| install_accumulator(attrib)}
+        end
+
+        def accumulators
+            @accumulators ||= {}
+        end
+
+        def install_accumulator(attribute)
+            self.accumulators[attribute] = Base.new(self, attribute)
+            module_eval %{
+                def self.accumulate_by_#{attribute.to_s}(*keys)
+                    accumulators[:#{attribute.to_s}].find(*keys)
+                end
+            }
+        end
+    end
+end

data/lib/puppet/util/rails/collection_merger.rb

@@ -1,43 +1,4 @@
 module Puppet::Util::CollectionMerger
-    # Merge new values with the old list.  This is only necessary
-    # because deletion seems to mess things up on unsaved objects.
-    def collection_merge(collection, args)
-        remove = []
-        list = args[:existing] || send(collection)
-        hash = args[:updates]
-        list.each do |object|
-            name = object.name
-            if existing = hash[name]
-                hash.delete(name)
-                if existing.respond_to?(:to_rails)
-                    existing.to_rails(self, object)
-                elsif args.include?(:modify)
-                    args[:modify].call(object, name, existing)
-                else
-                    raise ArgumentError, "Must pass :modify or the new objects must respond to :to_rails"
-                end
-            else
-                remove << object
-            end
-        end
-
-        # Make a new rails object for the rest of them
-        hash.each do |name, object|
-            if object.respond_to?(:to_rails)
-                object.to_rails(self)
-            elsif args.include?(:create)
-                args[:create].call(name, object)
-            else
-                raise ArgumentError, "Must pass :create or the new objects must respond to :to_rails"
-            end
-        end
-
-        # Now remove anything necessary.
-        remove.each do |object|
-            send(collection).delete(object)
-        end
-    end
-    
     def ar_hash_merge(db_hash, mem_hash, args)
         (db_hash.keys | mem_hash.keys).each do |key|
             if (db_hash[key] && mem_hash[key])

data/lib/puppet/util/rails/reference_serializer.rb

@@ -1,18 +1,32 @@
 
 module Puppet::Util::ReferenceSerializer
     def unserialize_value(val)
-        if val =~ /^--- [!:]/
+        case val
+        when /^--- /
             YAML.load(val)
+        when "true"
+            true
+        when "false"
+            false
         else
             val
         end
     end
 
     def serialize_value(val)
-        if val.is_a?(Puppet::Parser::Resource::Reference)
+        case val
+        when Puppet::Parser::Resource::Reference
             YAML.dump(val)
+        when true, false
+            # The database does this for us, but I prefer the
+            # methods be their exact inverses.
+            # Note that this means quoted booleans get returned
+            # as actual booleans, but there doesn't appear to be
+            # a way to fix that while keeping the ability to
+            # search for parameters set to true.
+            val.to_s
         else
             val
         end
     end
-end
+end

data/lib/puppet/util/rdoc.rb

@@ -22,6 +22,7 @@ module Puppet::Util::RDoc
             # specify our own format & where to output
             options = [ "--fmt", "puppet",
                         "--quiet",
+                        "--force-update",
                         "--op", outputdir ]
 
             options += files

data/lib/puppet/util/rdoc/code_objects.rb

@@ -4,7 +4,7 @@ module RDoc
 
     # This modules contains various class that are used to hold information
     # about the various Puppet language structures we found while parsing.
-    # 
+    #
     # Those will be mapped to their html counterparts which are defined in
     # PuppetGenerator.
 
@@ -102,6 +102,10 @@ module RDoc
         def is_module?
             false
         end
+
+        def superclass=(superclass)
+            @superclass = superclass
+        end
     end
 
     # PuppetNode holds a puppet node

data/lib/puppet/util/rdoc/generators/puppet_generator.rb

@@ -4,14 +4,14 @@ module Generators
 
     # This module holds all the classes needed to generate the HTML documentation
     # of a bunch of puppet manifests.
-    # 
-    # It works by traversing all the code objects defined by the Puppet RDoc::Parser 
+    #
+    # It works by traversing all the code objects defined by the Puppet RDoc::Parser
     # and produces HTML counterparts objects that in turns are used by RDoc template engine
     # to produce the final HTML.
-    # 
+    #
     # It is also responsible of creating the whole directory hierarchy, and various index
     # files.
-    # 
+    #
     # It is to be noted that the whole system is built on top of ruby RDoc. As such there
     # is an implicit mapping of puppet entities to ruby entitites:
     #
@@ -20,7 +20,7 @@ module Generators
     #         Module          Module
     #         Class           Class
     #         Definition      Method
-    #         Resource        
+    #         Resource
     #         Node
     #         Plugin
     #         Fact