puppet 0.13.6 → 0.16.0

data/lib/puppet/storage.rb

@@ -6,6 +6,7 @@ module Puppet
     # a class for storing state
     class Storage
         include Singleton
+        include Puppet::Util
 
         def initialize
             self.class.load
@@ -47,19 +48,21 @@ module Puppet
                 end
                 return
             end
-            Puppet::Util.readlock(Puppet[:statefile]) do |file|
-                begin
-                    @@state = YAML.load(file)
-                rescue => detail
-                    Puppet.err "Checksumfile %s is corrupt (%s); replacing" %
-                        [Puppet[:statefile], detail]
+            Puppet::Util.benchmark(:debug, "Loaded state") do
+                Puppet::Util.readlock(Puppet[:statefile]) do |file|
                     begin
-                        File.rename(Puppet[:statefile],
-                            Puppet[:statefile] + ".bad")
-                    rescue
-                        raise Puppet::Error,
-                            "Could not rename corrupt %s; remove manually" %
-                            Puppet[:statefile]
+                        @@state = YAML.load(file)
+                    rescue => detail
+                        Puppet.err "Checksumfile %s is corrupt (%s); replacing" %
+                            [Puppet[:statefile], detail]
+                        begin
+                            File.rename(Puppet[:statefile],
+                                Puppet[:statefile] + ".bad")
+                        rescue
+                            raise Puppet::Error,
+                                "Could not rename corrupt %s; remove manually" %
+                                Puppet[:statefile]
+                        end
                     end
                 end
             end
@@ -79,27 +82,18 @@ module Puppet
         def self.store
             Puppet.config.use(:puppet)
             Puppet.debug "Storing state"
-#            unless FileTest.directory?(File.dirname(Puppet[:statefile]))
-#                begin
-#                    Puppet.recmkdir(File.dirname(Puppet[:statefile]))
-#                    Puppet.info "Creating state directory %s" %
-#                        File.dirname(Puppet[:statefile])
-#                rescue => detail
-#                    Puppet.err "Could not create state file: %s" % detail
-#                    return
-#                end
-#            end
 
             unless FileTest.exist?(Puppet[:statefile])
                 Puppet.info "Creating state file %s" % Puppet[:statefile]
             end
 
-            Puppet::Util.writelock(Puppet[:statefile], 0600) do |file|
-                file.print YAML.dump(@@state)
+            Puppet::Util.benchmark(:debug, "Stored state") do
+                Puppet::Util.writelock(Puppet[:statefile], 0660) do |file|
+                    file.print YAML.dump(@@state)
+                end
             end
-            Puppet.debug "Stored state"
         end
     end
 end
 
-# $Id: storage.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: storage.rb 1098 2006-04-10 22:13:10Z luke $

data/lib/puppet/transaction.rb

@@ -1,38 +1,34 @@
 # the class that actually walks our object/state tree, collects the changes,
 # and performs them
 
-# there are two directions of walking:
-#   - first we recurse down the tree and collect changes
-#   - then we walk back up the tree through 'refresh' after the changes
-
 require 'puppet'
 require 'puppet/statechange'
 
-#---------------------------------------------------------------
 module Puppet
 class Transaction
     attr_accessor :toplevel, :component, :objects
 
-    #---------------------------------------------------------------
+
+    Puppet.config.setdefaults(:transaction,
+        :tags => ["", "Tags to use to find objects.  If this is set, then
+            only objects tagged with the specified tags will be applied.  Values must
+            be comma-separated."]
+    )
+
     # a bit of a gross hack; a global list of objects that have failed to sync,
     # so that we can verify during later syncs that our dependencies haven't
     # failed
     def Transaction.init
         @@failures = Hash.new(0)
         Puppet::Metric.init
-        @@changed = []
     end
-    #---------------------------------------------------------------
 
-    #---------------------------------------------------------------
     # for now, just store the changes for executing linearly
     # later, we might execute them as we receive them
     def change(change)
         @changes.push change
     end
-    #---------------------------------------------------------------
 
-    #---------------------------------------------------------------
     # okay, here's the deal:
     # a given transaction maps directly to a component, and each transaction
     # will only ever receive changes from its respective component
@@ -46,7 +42,19 @@ class Transaction
 
         count = 0
         now = Time.now
+        tags = Puppet[:tags]
+        if tags == ""
+            tags = nil
+        else
+            tags = tags.split(/\s*,\s*/)
+        end
         events = @objects.find_all { |child|
+            if tags
+                child.tagged?(tags)
+            else
+                true # match everything when there are no tags
+            end
+        }.find_all { |child|
             child.scheduled?
         }.collect { |child|
             # these children are all Puppet::Type instances
@@ -67,7 +75,6 @@ class Transaction
                     # use an array, so that changes can return more than one
                     # event if they want
                     events = [change.forward].flatten.reject { |e| e.nil? }
-                    #@@changed.push change.state.parent
                 rescue => detail
                     change.state.err "change from %s to %s failed: %s" %
                         [change.state.is_to_s, change.state.should_to_s, detail]
@@ -94,60 +101,13 @@ class Transaction
         }.flatten.reject { |child|
             child.nil? # remove empties
         }
-#        events = @changes.collect { |change|
-#            if change.is_a?(Puppet::StateChange)
-#                change.transaction = self
-#                events = nil
-#                begin
-#                    # use an array, so that changes can return more than one
-#                    # event if they want
-#                    events = [change.forward].flatten.reject { |e| e.nil? }
-#                    #@@changed.push change.state.parent
-#                rescue => detail
-#                    change.state.err "change from %s to %s failed: %s" %
-#                        [change.state.is_to_s, change.state.should_to_s, detail]
-#                    #Puppet.err("%s failed: %s" % [change.to_s,detail])
-#                    if Puppet[:debug]
-#                        puts detail.backtrace
-#                    end
-#                    next
-#                    # FIXME this should support using onerror to determine
-#                    # behaviour; or more likely, the client calling us
-#                    # should do so
-#                end
-#
-#                # This is kinda lame, because it can result in the same
-#                # object being modified multiple times, but that's difficult
-#                # to avoid as long as we're syncing each state individually.
-#                change.state.parent.cache(:synced, now)
-#
-#                unless events.nil? or (events.is_a?(Array) and events.empty?)
-#                    change.changed = true
-#                end
-#                events
-#            else
-#                puts caller
-#                raise Puppet::DevError,
-#                    "Transactions cannot handle objects of type %s" % change.class
-#            end
-#        }.flatten.reject { |event|
-#            event.nil?
-#        }
 
         Puppet.debug "Finishing transaction %s with %s changes" %
             [self.object_id, count]
-        #@triggerevents = []
-        events.each { |event|
-            object = event.source
-            #Puppet::Event::Subscriptions.propagate(object, event, self)
-            object.propagate(event, self)
-        }
 
-        #events += @triggerevents
+        self.propagate(events)
     end
-    #---------------------------------------------------------------
 
-    #---------------------------------------------------------------
     # this should only be called by a Puppet::Container object now
     # and it should only receive an array
     def initialize(objects)
@@ -165,26 +125,36 @@ class Transaction
         end
 
         @changes = []
+    end
 
-        # change collection is in-band, and message generation is out-of-band
-        # of course, exception raising is also out-of-band
-        now = Time.now.to_i
-#        @changes = @objects.find_all { |child|
-#            child.scheduled?
-#        }.collect { |child|
-#            # these children are all Puppet::Type instances
-#            # not all of the children will return a change, and Containers
-#            # return transactions
-#            #ary = child.evaluate
-#            #ary
-#            child.evaluate
-#        }.flatten.reject { |child|
-#            child.nil? # remove empties
-#        }
+    # Respond to each of the events.  This method walks up the parent tree,
+    # triggering each parent in turn.  It's important that the transaction
+    # itself know whether a given subscription fails, so that it can respond
+    # appropriately (when we get to the point where we're responding to events).
+    def propagate(events)
+        events.each do |event|
+            source = event.source
+
+            while source
+                Puppet::Event::Subscription.trigger(source, event) do |sub|
+                    begin
+                        sub.trigger(self)
+                    rescue => detail
+                        sub.target.err "Failed to respond to %s: %s" % [event, detail]
+                        if Puppet[:debug]
+                            puts detail.backtrace
+                        end
+                    end
+                end
+
+                # Reset the source if there's a parent obj
+                source = source.parent
+            end
+            #Puppet::Event::Subscriptions.propagate(object, event, self)
+        end
     end
-    #---------------------------------------------------------------
 
-    #---------------------------------------------------------------
+    # Roll all completed changes back.
     def rollback
         events = @changes.reverse.collect { |change|
             if change.is_a?(Puppet::StateChange)
@@ -196,7 +166,6 @@ class Transaction
                 #change.transaction = self
                 begin
                     change.backward
-                    #@@changed.push change.state.parent
                 rescue => detail
                     Puppet.err("%s rollback failed: %s" % [change,detail])
                     if Puppet[:debug]
@@ -220,30 +189,18 @@ class Transaction
             end
         }.flatten.reject { |e| e.nil? }
 
-        #@triggerevents = []
-        events.each { |event|
-            object = event.source
-            object.propagate(event, self)
-        }
-
-        #events += @triggerevents
+        self.propagate(events)
     end
-    #---------------------------------------------------------------
 
-    #---------------------------------------------------------------
     def triggered(object, method)
         @triggered[object][method] += 1
         #@triggerevents << ("%s_%sed" % [object.class.name.to_s, method.to_s]).intern
     end
-    #---------------------------------------------------------------
 
-    #---------------------------------------------------------------
     def triggered?(object, method)
         @triggered[object][method]
     end
-    #---------------------------------------------------------------
 end
 end
-#---------------------------------------------------------------
 
-# $Id: transaction.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: transaction.rb 1005 2006-03-11 22:18:59Z luke $

data/lib/puppet/type.rb

@@ -9,7 +9,10 @@ require 'puppet/util'
 # see the bottom of the file for the rest of the inclusions
 
 module Puppet
+# The type is unknown
+class UnknownTypeError < Puppet::Error; end
 class Type < Puppet::Element
+
     # Types (which map to elements in the languages) are entirely composed of
     # attribute value pairs.  Generally, Puppet calls any of these things an
     # 'attribute', but these attributes always take one of three specific
@@ -19,7 +22,8 @@ class Type < Puppet::Element
     # that it is clear whether it operates on all attributes (thus has 'attr' in
     # the method name, or whether it operates on a specific type of attributes.
     attr_accessor :children, :parent
-    attr_accessor :file, :line, :tags
+    attr_accessor :file, :line
+    attr_reader :tags
 
     attr_writer :implicit
     def implicit?
@@ -61,7 +65,6 @@ class Type < Puppet::Element
         include Enumerable
 
         def inspect
-            Puppet.info "inspecting class with name %s" % self.name
             "Type(%s)" % self.name
         end
 
@@ -215,6 +218,17 @@ class Type < Puppet::Element
             name = name.intern
         end
 
+        unless @types.include? name
+            begin
+                require "puppet/type/#{name}"
+                unless @types.include? name
+                    Puppet.warning "Loaded puppet/type/#{name} but no class was created"
+                end
+            rescue LoadError
+                # nothing
+            end
+        end
+
         @types[name]
     end
 
@@ -417,6 +431,9 @@ class Type < Puppet::Element
         param = Class.new(Puppet::Parameter) do
             @name = name
         end
+
+        param.initvars
+
         param.ismetaparameter
         param.class_eval(&block)
         const_set("MetaParam" + name.to_s.capitalize,param)
@@ -440,6 +457,9 @@ class Type < Puppet::Element
         param = Class.new(Puppet::Parameter) do
             @name = name
         end
+
+        param.initvars
+
         param.element = self
         param.class_eval(&block)
         const_set("Parameter" + name.to_s.capitalize,param)
@@ -475,6 +495,9 @@ class Type < Puppet::Element
         s = Class.new(parent) do
             @name = name
         end
+
+        s.initvars
+
         const_set("State" + name.to_s.capitalize,s)
         s.class_eval(&block)
         @states ||= []
@@ -919,7 +942,8 @@ class Type < Puppet::Element
         end
         param = klass.new
         param.parent = self
-        if value
+
+        unless value.nil?
             param.value = value
         end
 
@@ -1000,7 +1024,11 @@ class Type < Puppet::Element
     # Remove an object.  The argument determines whether the object's
     # subscriptions get eliminated, too.
     def remove(rmdeps = true)
-        @children.each { |child|
+        # Our children remove themselves from our @children array (else the object
+        # we called this on at the top would not be removed), so we duplicate the
+        # array and iterate over that.  If we don't do this, only half of the
+        # objects get removed.
+        @children.dup.each { |child|
             child.remove(rmdeps)
         }
 
@@ -1308,7 +1336,7 @@ class Type < Puppet::Element
             if attrs.include?(namevar)
                 attrs.delete(namevar)
             else
-                self.devfail "My namevar isn't a valid attribute...?"
+                self.devfail "My namevar isn\'t a valid attribute...?"
             end
         else
             self.devfail "I was not passed a namevar"
@@ -1325,6 +1353,8 @@ class Type < Puppet::Element
             if hash.include?(name)
                 begin
                     self[name] = hash[name]
+                rescue ArgumentError, Puppet::Error, TypeError
+                    raise
                 rescue => detail
                     self.devfail(
                         "Could not set %s on %s: %s" %
@@ -1375,8 +1405,13 @@ class Type < Puppet::Element
                 obj = nil
                 # Support them passing objects directly, to save some effort.
                 if dep.is_a? Puppet::Type
+                    self.info "requiring %s" % dep.name
                     type = dep.class.name
                     obj = dep
+
+                    # Now change our dependency to just the string, instead of
+                    # the object itself.
+                    dep = dep.name
                 else
                     # Skip autorequires that we aren't managing
                     unless obj = typeobj[dep]
@@ -1452,8 +1487,36 @@ class Type < Puppet::Element
         return schedule.match?(self.cached(:checked).to_i)
     end
 
+    # Add a new tag.
     def tag(tag)
-        @tags << tag
+        tag = tag.intern if tag.is_a? String
+        unless @tags.include? tag
+            @tags << tag
+        end
+    end
+
+    # Define the initial list of tags.
+    def tags=(list)
+        list = [list] unless list.is_a? Array
+
+        @tags = list.collect do |t|
+            case t
+            when String: t.intern
+            when Symbol: t
+            else
+                self.warning "Ignoring tag %s of type %s" % [tag.inspect, tag.class]
+            end
+        end
+    end
+
+    # Figure out of any of the specified tags apply to this object.  This is an
+    # OR operation.
+    def tagged?(tags)
+        tags = [tags] unless tags.is_a? Array
+
+        tags = tags.collect { |t| t.intern }
+
+        return tags.find { |tag| @tags.include? tag }
     end
 
     # Is the specified parameter set?
@@ -1622,6 +1685,34 @@ class Type < Puppet::Element
         self.name
     end
 
+    # Convert to a transportable object
+    def to_trans
+        # Collect all of the "is" values
+        retrieve()
+
+        trans = TransObject.new(self.name, self.class.name)
+
+        states().each do |state|
+            trans[state.name] = state.is
+        end
+
+        @parameters.each do |name, param|
+            # Avoid adding each instance name as both the name and the namevar
+            next if param.class.isnamevar? and param.value == self.name
+            trans[name] = param.value
+        end
+
+        @metaparams.each do |name, param|
+            trans[name] = param.value
+        end
+
+        trans.tags = self.tags
+
+        # FIXME I'm currently ignoring 'parent' and 'path'
+
+        return trans
+    end
+
     # instance methods dealing with actually doing work
 
     public
@@ -1725,7 +1816,7 @@ class Type < Puppet::Element
         # now record how many changes we've resulted in
         Puppet::Metric.add(self.class,self,:changes,changes.length)
         if changes.length > 0
-            self.info "%s change(s)" %
+            self.debug "%s change(s)" %
                 [changes.length]
         end
         self.cache(:checked, now)
@@ -1746,9 +1837,11 @@ class Type < Puppet::Element
 
         states.each { |state|
             unless state.insync?
-                self.debug("%s is not in sync: %s vs %s" %
-                    [state, state.is.inspect, state.should.inspect])
+                state.debug("Not in sync: %s vs %s" %
+                    [state.is.inspect, state.should.inspect])
                 insync = false
+            #else
+            #    state.debug("In sync")
             end
         }
 
@@ -1845,16 +1938,6 @@ class Type < Puppet::Element
         }
     end
 
-    # Trigger any associated subscriptions, and then pass the event up to our
-    # parent.
-    def propagate(event, transaction)
-        Puppet::Event::Subscription.trigger(self, event, transaction)
-
-        if defined? @parent
-            @parent.propagate(event, transaction)
-        end
-    end
-
     def requires?(object)
         req = false
         self.eachdependency { |dep|
@@ -1989,6 +2072,13 @@ class Type < Puppet::Element
             on all packages."
 
         munge do |args|
+            # If they've specified all, collect all known states
+            if args == :all
+                args = @parent.class.states.collect do |state|
+                    state.name
+                end
+            end
+
             unless args.is_a?(Array)
                 args = [args]
             end
@@ -2004,6 +2094,8 @@ class Type < Puppet::Element
                 end
                 next if @parent.statedefined?(state)
 
+                next unless @parent.class.validstate?(state).checkable?
+
                 @parent.newstate(state)
             }
         end
@@ -2101,23 +2193,15 @@ class Type < Puppet::Element
              currently the default)."
         defaultto :notice
 
-        validate do |loglevel|
-            if loglevel.is_a?(String)
-                loglevel = loglevel.intern
-            end
-            unless Puppet::Log.validlevel?(loglevel)
-                self.fail "Invalid log level %s" % loglevel
-            end
-        end
+        newvalues(*Puppet::Log.levels)
+        newvalues(:verbose)
 
         munge do |loglevel|
-            if loglevel.is_a?(String)
-                loglevel = loglevel.intern
-            end
-            if loglevel == :verbose
-                loglevel = :info 
+            val = super(loglevel)
+            if val == :verbose
+                val = :info 
             end        
-            loglevel
+            val
         end
     end
 
@@ -2169,7 +2253,7 @@ class Type < Puppet::Element
                 if obj = @parent.class[other]
                     unless obj == @parent
                         self.fail(
-                            "%s an not create alias %s: object already exists" %
+                            "%s can not create alias %s: object already exists" %
                             [@parent.name, other]
                         )
                     end
@@ -2179,6 +2263,29 @@ class Type < Puppet::Element
             end
         end
     end
+
+    newmetaparam(:tag) do
+        desc "Add the specified tags to the associated element.  While all elements
+            are automatically tagged with as much information as possible
+            (e.g., each class and component containing the element), it can
+            be useful to add your own tags to a given element.
+
+            Tags are currently useful for things like applying a subset of a
+            host's configuration:
+                
+                puppetd -v --tag mytag --onetime
+
+            This way, when you're testing a configuration you can run just the
+            portion you're testing."
+
+        munge do |tags|
+            tags = [tags] unless tags.is_a? Array
+
+            tags.each do |tag|
+                @parent.tag(tag)
+            end
+        end
+    end
 end # Puppet::Type
 end
 
@@ -2197,4 +2304,4 @@ require 'puppet/type/user'
 require 'puppet/type/tidy'
 require 'puppet/type/parsedtype'
 
-# $Id: type.rb 966 2006-03-02 17:12:26Z luke $
+# $Id: type.rb 1129 2006-04-21 19:14:59Z luke $