puppet 0.18.4 → 0.22.4

data/lib/puppet/event.rb

@@ -1,5 +1,6 @@
 require 'puppet'
-require 'puppet/type'
+require 'puppet/util/methodhelper'
+require 'puppet/util/errors'
 
 module Puppet
     # events are transient packets of information; they result in one or more (or none)
@@ -7,252 +8,16 @@ module Puppet
     # eventually, these will be passed on to some central event system
 	class Event
         include Puppet
-
-        # subscriptions are permanent associations determining how different
-        # objects react to an event
-        class Subscription
-            include Puppet
-            attr_accessor :event, :callback
-
-            # Remove the existing subscriptions and such
-            def self.clear
-                self.init
-            end
-
-            # Remove a subscription
-            def self.delete(sub)
-                type, name = sub.targetarray
-                if @dependencies[type][name].include?(sub)
-                    @dependencies[type][name].delete(sub)
-                end
-
-                type, name = sub.sourcearray
-                if @subscriptions[type][name].include?(sub)
-                    @subscriptions[type][name].delete(sub)
-                end
-            end
-
-            # Initialize our class variables.  This is in a method so it can
-            # be called to clear the variables, too.
-            def self.init
-                # A hash of subscriptions and another of dependencies, organized by
-                # type, then by name.  I'm storing them all here, so that I don't
-                # have to store the subscriptions with the individual objects,
-                # which makes creating and destroying objects as necessary much
-                # easier.
-                @subscriptions = Hash.new { |hash, key|
-                    hash[key] = Hash.new { |shash, skey|
-                        # Each object has an array of subscriptions
-                        shash[skey] = []
-                    }
-                }
-
-                @dependencies = Hash.new { |hash, key|
-                    hash[key] = Hash.new { |shash, skey|
-                        # Each object has an array of subscriptions
-                        shash[skey] = []
-                    }
-                }
-            end
-
-            self.init
-
-            # Store the new subscription in a central hash.
-            def self.newsub(sub)
-                # The dependencies map allows me to look up a subscription by
-                # target -- find out which objects a given object is subscribed
-                # to, and thus find out which objects that given object depends
-                # upon.
-                # DEPENDENCIES == TARGET
-                ttype, tname = sub.targetarray
-                @dependencies[ttype][tname] << sub
-
-                # Subscriptions are the list of subscriptions for a given object,
-                # i.e., the list of all objects that care about a given object's
-                # events.
-                # SUBSCRIPTION == SOURCE
-                stype, sname = sub.sourcearray
-                @subscriptions[stype][sname] << sub
-            end
-
-            # Collect all of the subscriptions that target a specific event.
-            def self.targets_of(event, source)
-                type, name = self.split(source)
-
-                @subscriptions[type][name].each { |sub|
-                    if sub.match?(event)
-                        yield sub
-                    end
-                }
-            end
-
-            # Trigger the subscriptions related to an event, and then pass it up
-            # as appropriate
-            def self.trigger(source, event)
-                type, name = self.split(source)
-
-                @subscriptions[type][name].each { |sub|
-                    if sub.match?(event)
-                        yield sub
-                        #sub.trigger(transaction)
-                    end
-                }
-            end
-
-            # Look up an object by type and name.  This is used because we
-            # store symbolic links in our subscription hash rather than storing
-            # actual object references.
-            def self.retrieve(ary)
-                type, name = ary
-                typeobj = Puppet::Type.type(type)
-
-                unless typeobj
-                    return nil
-                end
-
-                obj = typeobj[name]
-                return obj
-            end
-
-            # Split an object into its type and name
-            def self.split(object)
-                return [object.class.name, object.name]
-            end
-
-            # Retrieve all of the subscriptions that result in a dependency.
-            # We return the whole dependency here, because it is being returned
-            # to the object that made the subscription.
-            def self.dependencies(target)
-                type, name = self.split(target)
-                return @dependencies[type][name]
-            end
-
-            # Return all objects that are subscribed to us.  We are only willing
-            # to return the object, not the subscription object, because the
-            # source shouldn't need to know things like the event or method that
-            # we're subscribed to.
-            def self.subscribers(source)
-                type, name = self.split(source)
-                return @subscriptions[type][name].collect { |sub|
-                    sub.target
-                }.reject { |o|
-                    o.nil?
-                }
-            end
-
-            def delete
-                self.class.delete(self)
-            end
-
-            # The hash here must include the target and source objects, the event,
-            # and the callback to call.
-            def initialize(hash)
-                hash.each { |param,value|
-                    # assign each value appropriately
-                    # this is probably wicked-slow
-                    self.send(param.to_s + "=",value)
-                }
-
-                self.class.newsub(self)
-                #Puppet.debug "New Subscription: '%s' => '%s'" %
-                #    [@source,@event]
-            end
-
-            # Determine whether the passed event matches our event
-            def match?(event)
-                if event == :NONE or @event == :NONE
-                    return false
-                elsif @event == :ALL_EVENTS or event == :ALL_EVENTS or event == @event
-                    return true
-                else
-                    return false
-                end
-            end
-
-            # The source is the event source.
-            def source=(object)
-                type, name = self.class.split(object)
-                @source = [type, name]
-            end
-
-            def source
-                if source = self.class.retrieve(@source)
-                    return source
-                else
-                    raise Puppet::Error,
-                        "Could not retreive dependency %s[%s] for %s[%s]" %
-                        [@source[0], @source[1], @target[0], @target[1]]
-                end
-            end
-
-            def sourcearray
-                @source
-            end
-
-            # The target is the object who will receive the callbacks, i.e.,
-            # a source generates an event, which results in a callback on the
-            # target.
-            def target=(object)
-                type, name = self.class.split(object)
-                @target = [type, name]
-            end
-
-            def target
-                self.class.retrieve(@target)
-            end
-
-            def targetarray
-                @target
-            end
-
-            # Trigger a subscription, which basically calls the associated method
-            # on the target object. XXX This is currently unused.
-            def trigger(transaction)
-                event = nil
-
-                if @event == :NONE
-                    # just ignore these subscriptions
-                    return
-                end
-
-                if transaction.triggered?(self.target, @callback) > 0
-                    self.target.info "already applied %s" % [@callback]
-                else
-                    # We need to call the method, so that it gets retrieved
-                    # as a real object.
-                    target = self.target
-                    #Puppet.debug "'%s' matched '%s'; triggering '%s' on '%s'" %
-                    #    [@source,@event,@method,target]
-                    if target.respond_to?(@callback)
-                        target.log "triggering %s" % @callback
-                        event = target.send(@callback)
-                    else
-                        Puppet.debug(   
-                            "'%s' of type '%s' does not respond to '%s'" %
-                            [target,target.class,@callback.inspect]
-                        )
-                    end
-                    transaction.triggered(target, @callback)
-                end
-                return event
-            end
-        end
-
+        include Puppet::Util::MethodHelper
+        include Puppet::Util::Errors
+        
 		attr_accessor :event, :source, :transaction
 
         @@events = []
 
-        @@subscriptions = []
-
 		def initialize(args)
-            unless args.include?(:event) and args.include?(:source)
-				raise Puppet::DevError, "Event.new called incorrectly"
-			end
-
-			@change = args[:change]
-			@event = args[:event]
-			@source = args[:source]
-			@transaction = args[:transaction]
+		    set_options symbolize_options(args)
+		    requiredopts(:event, :source)
 		end
 
         def to_s
@@ -261,4 +26,4 @@ module Puppet
 	end
 end
 
-# $Id: event.rb 1178 2006-05-05 19:43:23Z luke $
+# $Id: event.rb 1964 2006-12-23 04:49:56Z luke $

data/lib/puppet/external/event-loop.rb

@@ -0,0 +1 @@
+require "puppet/external/event-loop/event-loop"

data/lib/puppet/{event-loop → external/event-loop}/event-loop.rb

@@ -17,8 +17,8 @@
 # Software Foundation, 51 Franklin Street, Fifth Floor,
 # Boston, MA 02110-1301, USA.
 
-require "puppet/event-loop/better-definers"
-require "puppet/event-loop/signal-system"
+require "puppet/external/event-loop/better-definers"
+require "puppet/external/event-loop/signal-system"
 
 require "fcntl"
 

data/lib/puppet/{event-loop → external/event-loop}/signal-system.rb

@@ -17,7 +17,7 @@
 # Software Foundation, 51 Franklin Street, Fifth Floor,
 # Boston, MA 02110-1301, USA.
 
-require "puppet/event-loop/better-definers"
+require "puppet/external/event-loop/better-definers"
 
 module SignalEmitterModule
   def self.extended (object)

data/lib/puppet/external/gratr.rb

@@ -0,0 +1,33 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+
+require 'puppet/external/gratr/base'
+require 'puppet/external/gratr/digraph'
+require 'puppet/external/gratr/undirected_graph'
+require 'puppet/external/gratr/common'

data/lib/puppet/external/gratr/adjacency_graph.rb

@@ -0,0 +1,257 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+
+require 'puppet/external/gratr/edge'
+require 'puppet/external/gratr/graph'
+require 'set'
+
+module GRATR
+
+  # This provides the basic routines needed to implement the Digraph, UndirectedGraph,
+  # PseudoGraph, DirectedPseudoGraph, MultiGraph and DirectedPseudoGraph class.
+  module AdjacencyGraph
+    
+    include Graph
+
+    class ArrayWithAdd < Array # :nodoc:
+      alias add push
+    end
+
+    # Initialization parameters can include an Array of edges to add, Graphs to
+    # copy (will merge if multiple)
+    # :parallel_edges denotes that duplicate edges are allowed
+    # :loops denotes that loops are allowed
+    def initialize(*params)
+      @vertex_dict     = Hash.new    
+      raise ArgumentError if params.any? do |p| 
+        !(p.kind_of? GRATR::Graph or 
+          p.kind_of? Array or 
+          p == :parallel_edges or
+          p == :loops)
+      end
+      clear_all_labels
+
+      # Basic configuration of adjacency
+      @allow_loops    = params.any? {|p| p == :loops}
+      @parallel_edges = params.any? {|p| p == :parallel_edges}
+      @edgelist_class = @parallel_edges ? ArrayWithAdd : Set
+      if @parallel_edges
+        @edge_number      = Hash.new
+        @next_edge_number = 0 
+      end
+
+      # Copy any given graph into this graph
+      params.select {|p| p.kind_of? GRATR::Graph}.each do |g|
+        g.edges.each do |e| 
+          add_edge!(e)
+          edge_label_set(e, edge_label(e)) if edge_label(e)
+        end
+        g.vertices.each do |v|
+          vertex_label_set(v, vertex_label(v)) if vertex_label(v)
+        end  
+      end
+
+      # Add all array edges specified
+      params.select {|p| p.kind_of? Array}.each do |a|
+        0.step(a.size-1, 2) {|i| add_edge!(a[i], a[i+1])}
+      end
+
+    end
+
+    # Returns true if v is a vertex of this Graph
+    # An O(1) implementation of vertex?
+    def vertex?(v) @vertex_dict.has_key?(v); end
+
+    # Returns true if [u,v] or u is an Edge
+    # An O(1) implementation 
+    def edge?(u, v=nil)
+      u, v = u.source, u.target if u.kind_of? GRATR::Edge
+      vertex?(u) and @vertex_dict[u].include?(v)
+    end
+
+    # Adds a vertex to the graph with an optional label
+    def add_vertex!(vertex, label=nil)
+      @vertex_dict[vertex] ||= @edgelist_class.new
+      self[vertex] = label if label
+      self
+    end
+
+    # Adds an edge to the graph
+    # Can be called in two basic ways, label is optional
+    #   * add_edge!(Edge[source,target], "Label")
+    #   * add_edge!(source,target, "Label")
+    def add_edge!(u, v=nil, l=nil, n=nil)
+      if u.class.include? EdgeNumber and n.nil?
+          n = u.number
+      end
+      if u.kind_of? GRATR::Edge
+          edge = u
+          u, v, l = u.source, u.target, u.label
+      end
+      if not @allow_loops and u == v
+          return self
+      end
+      if @parallel_edges and ! n
+          n = (@next_edge_number+=1)
+      end
+      add_vertex!(u);
+      add_vertex!(v)        
+      @vertex_dict[u].add(v)
+
+      if @parallel_edges
+          (@edge_number[u] ||= @edgelist_class.new).add(n)
+      end
+      unless directed?
+        @vertex_dict[v].add(u)
+        if @parallel_edges
+            (@edge_number[v] ||= @edgelist_class.new).add(n)
+        end
+      end        
+
+      if l
+          unless edge
+              if n
+                  edge = edge_class[u,v,n]
+              else
+                  edge = edge_class[u,v]
+              end
+          end
+          self[edge] = l
+      end
+      self
+    end
+
+    # Removes a given vertex from the graph
+    def remove_vertex!(v)
+# FIXME This is broken for multi graphs 
+      @vertex_dict.delete(v)
+      @vertex_dict.each_value { |adjList| adjList.delete(v) }
+      @vertex_dict.keys.each  do |u| 
+        delete_label(edge_class[u,v]) 
+        delete_label(edge_class[v,u])
+      end
+      delete_label(v) 
+      self
+    end
+
+    # Removes an edge from the graph, can be called with source and target or with
+    # and object of GRATR::Edge derivation
+    def remove_edge!(u, v=nil)
+      unless u.kind_of? GRATR::Edge
+        raise ArgumentError if @parallel_edges
+        u = edge_class[u,v]
+      end
+      raise ArgumentError if @parallel_edges and (u.number || 0) == 0
+      return self unless @vertex_dict[u.source] # It doesn't exist
+      delete_label(u) # Get rid of label
+      if @parallel_edges
+        index = @edge_number[u.source].index(u.number)
+        raise NoEdgeError unless index
+        @vertex_dict[u.source].delete_at(index)
+        @edge_number[u.source].delete_at(index) 
+      else
+        @vertex_dict[u.source].delete(u.target) 
+      end
+      self
+    end
+
+    # Returns an array of vertices that the graph has
+    def vertices() @vertex_dict.keys; end
+
+    # Returns an array of edges, most likely of class Edge or UndirectedEdge depending 
+    # upon the type of graph
+    def edges
+      @vertex_dict.keys.inject(Set.new) do |a,v|
+        if @parallel_edges and @edge_number[v]
+          @vertex_dict[v].zip(@edge_number[v]).each do |w|
+            s,t,n = v,w[0],w[1]
+            a.add( edge_class[ s,t,n, edge_label(s,t,n) ] )
+          end
+        else
+          @vertex_dict[v].each do |w|
+            a.add(edge_class[v,w,edge_label(v,w)])
+          end
+        end; a
+      end.to_a
+    end
+ 
+    alias graph_adjacent adjacent
+    def adjacent(x, options={})
+        unless @vertex_dict.has_key?(x)
+            raise ArgumentError, "%s is not a vertex" % x
+        end
+      options[:direction] ||= :out
+      if !x.kind_of?(GRATR::Edge) and (options[:direction] == :out || !directed?)
+        if options[:type] == :edges
+          @parallel_edges ?
+            @vertex_dict[x].map {|v| e=edge_class[x,v,@edge_number[x][v]]; e.label = self[e]; e} :
+            @vertex_dict[x].map {|v| e=edge_class[x,v];  e.label = self[e]; e}
+        else
+          @vertex_dict[x].to_a
+        end
+      else
+        graph_adjacent(x,options)
+      end
+    end
+    
+ 
+  public
+
+    def self.included(cl)
+      # Shortcut for creating a Graph
+      #
+      #  Example: GRATR::Digraph[1,2, 2,3, 2,4, 4,5].edges.to_a.to_s =>
+      #    "(1-2)(2-3)(2-4)(4-5)"
+      # 
+      # Or as a Hash for specifying lables
+      # GRATR::Digraph[ [:a,:b] => 3, [:b,:c] => 4 ]  (Note: Do not use for Multi or Pseudo graphs)
+      def cl.[] (*a)
+        result = new
+        if a.size == 1 and a[0].kind_of? Hash
+          # Convert to edge class
+          a[0].each do |k,v|
+            if result.edge_class.include? GRATR::EdgeNumber
+              result.add_edge!(result.edge_class[k[0],k[1],nil,v])
+            else
+             result.add_edge!(result.edge_class[k[0],k[1],v])
+            end 
+          end
+        elsif a[0].kind_of? GRATR::Edge
+          a.each{|e| result.add_edge!(e); result[e] = e.label}
+        elsif a.size % 2 == 0    
+          0.step(a.size-1, 2) {|i| result.add_edge!(a[i], a[i+1])}
+        else
+          raise ArgumentError
+        end
+        result
+      end
+    end
+          
+  end # Adjacency Graph
+end # GRATR