puppet 0.9.2 → 0.13.0

data/lib/puppet/statechange.rb

@@ -37,6 +37,8 @@ module Puppet
                 return nil
             end
 
+            #@state.info "Is: %s, Should: %s" % [@state.is.inspect, @state.should.inspect]
+
             begin
                 events = @state.sync
                 if events.nil?
@@ -75,6 +77,9 @@ module Puppet
                 }
             rescue => detail
                 #@state.err "%s failed: %s" % [self.to_s,detail]
+                if Puppet[:debug]
+                    puts detail.backtrace
+                end
                 raise
                 # there should be a way to ask the state what type of event
                 # it would have generated, but...
@@ -147,4 +152,4 @@ module Puppet
 	end
 end
 
-# $Id: statechange.rb 740 2005-11-01 20:22:19Z luke $
+# $Id: statechange.rb 831 2006-01-16 20:01:20Z luke $

data/lib/puppet/storage.rb

@@ -1,95 +1,106 @@
+require 'yaml'
+
 module Puppet
     # a class for storing state
-	class Storage
-		include Singleton
-		
-		def initialize
-			self.class.load
-		end
+    class Storage
+        include Singleton
+        
+        def initialize
+            self.class.load
+        end
+
+        # Return a hash that will be stored to disk.  It's worth noting
+        # here that we use the object's full path, not just the name/type
+        # combination.  At the least, this is useful for those non-isomorphic
+        # types like exec, but it also means that if an object changes locations
+        # in the configuration it will lose its cache.
+        def self.cache(object)
+            unless object.is_a? Puppet::Type
+                raise Puppet::DevFail, "Must pass a Type instance to Storage.cache"
+            end
+            return @@state[object.path] ||= {}
+        end
 
         def self.clear
-            @@state = nil
+            @@state.clear
             Storage.init
         end
 
         def self.init
             Puppet.debug "Initializing Storage"
-            @@state = Hash.new { |hash,key|
-                hash[key] = Hash.new(nil)
-            }
+            @@state = {}
             @@splitchar = "\t"
         end
 
         self.init
 
-		def self.load
-            if Puppet[:checksumfile].nil?
+        def self.load
+            if Puppet[:statefile].nil?
                 raise Puppet::DevError, "Somehow the statefile is nil"
             end
 
-			unless File.exists?(Puppet[:checksumfile])
-                Puppet.info "Statefile %s does not exist" % Puppet[:checksumfile]
+            unless File.exists?(Puppet[:statefile])
+                Puppet.info "Statefile %s does not exist" % Puppet[:statefile]
+                unless defined? @@state and ! @@state.nil?
+                    self.init
+                end
                 return
             end
-            begin
-            #Puppet.debug "Loading statefile %s" % Puppet[:checksumfile]
-			File.open(Puppet[:checksumfile]) { |file|
-				file.each { |line|
-					myclass, key, value = line.split(@@splitchar)
-
+            #Puppet.debug "Loading statefile %s" % Puppet[:statefile]
+            Puppet::Util.lock(Puppet[:statefile]) { |file|
+                #@@state = Marshal.load(file)
+                begin
+                    @@state = YAML.load(file)
+                rescue => detail
+                    Puppet.err "Checksumfile %s is corrupt (%s); replacing" %
+                        [Puppet[:statefile], detail]
                     begin
-                        @@state[eval(myclass)][key] = Marshal::load(value)
-                    rescue => detail
+                        File.rename(Puppet[:statefile],
+                            Puppet[:statefile] + ".bad")
+                    rescue
                         raise Puppet::Error,
-                            "Failed to load value for %s::%s => %s" % [
-                                myclass,key,detail
-                            ], caller
+                            "Could not rename corrupt %s; remove manually" %
+                            Puppet[:statefile]
                     end
-				}
-			}
-            rescue => detail
-                Puppet.err "Could not read %s" % Puppet[:checksumfile]
+                end
+            }
+
+            unless @@state.is_a?(Hash)
+                Puppet.err "State got corrupted"
+                self.init
             end
 
             #Puppet.debug "Loaded state is %s" % @@state.inspect
-		end
+        end
 
-		def self.state(myclass)
-            unless myclass.is_a? Class
-                myclass = myclass.class
-            end
-            result = @@state[myclass]
-            return result
-		end
+        def self.stateinspect
+            @@state.inspect
+        end
 
-		def self.store
-            unless FileTest.directory?(File.dirname(Puppet[:checksumfile]))
+        def self.store
+            Puppet.debug "Storing state"
+            unless FileTest.directory?(File.dirname(Puppet[:statefile]))
                 begin
-                    Puppet.recmkdir(File.dirname(Puppet[:checksumfile]))
+                    Puppet.recmkdir(File.dirname(Puppet[:statefile]))
                     Puppet.info "Creating state directory %s" %
-                        File.dirname(Puppet[:checksumfile])
+                        File.dirname(Puppet[:statefile])
                 rescue => detail
                     Puppet.err "Could not create state file: %s" % detail
                     return
                 end
             end
 
-            unless FileTest.exist?(Puppet[:checksumfile])
-                Puppet.info "Creating state file %s" % Puppet[:checksumfile]
+            unless FileTest.exist?(Puppet[:statefile])
+                Puppet.info "Creating state file %s" % Puppet[:statefile]
             end
 
-			File.open(Puppet[:checksumfile], File::CREAT|File::WRONLY, 0600) { |file|
-				@@state.each { |klass, thash|
-                    thash.each { |key,value|
-                        mvalue = Marshal::dump(value)
-                        file.puts([klass,key,mvalue].join(@@splitchar))
-                    }
-				}
-			}
-
-            #Puppet.debug "Stored state is %s" % @@state.inspect
-		end
-	end
+            Puppet::Util.lock(
+                Puppet[:statefile], "w", 0600
+            ) { |file|
+                file.print YAML.dump(@@state)
+            }
+        end
+    end
 end
 
-# $Id: storage.rb 742 2005-11-16 17:12:11Z luke $
+# $Id: storage.rb 848 2006-01-24 06:01:58Z luke $

data/lib/puppet/transaction.rb

@@ -41,8 +41,10 @@ class Transaction
     # then, we need to pass the event to the object's containing component,
     # to see if it or any of its parents have subscriptions on the event
     def evaluate
-        Puppet.debug "executing %s changes " % @changes.length
+        Puppet.debug "Beginning transaction %s with %s changes" %
+            [self.object_id, @changes.length]
 
+        now = Time.now
         events = @changes.collect { |change|
             if change.is_a?(Puppet::StateChange)
                 change.transaction = self
@@ -53,9 +55,11 @@ class Transaction
                     events = [change.forward].flatten.reject { |e| e.nil? }
                     #@@changed.push change.state.parent
                 rescue => detail
-                    Puppet.err("%s failed: %s" % [change.to_s,detail])
-                    if Puppet[:debug] and detail.respond_to?(:stack)
-                        puts detail.stack
+                    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
@@ -63,13 +67,19 @@ class Transaction
                     # 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" % child.class
+                    "Transactions cannot handle objects of type %s" % change.class
             end
         }.flatten.reject { |event|
             event.nil?
@@ -104,10 +114,15 @@ class Transaction
         end
         # change collection is in-band, and message generation is out-of-band
         # of course, exception raising is also out-of-band
-        @changes = @objects.collect { |child|
+        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
@@ -130,6 +145,9 @@ class Transaction
                     #@@changed.push change.state.parent
                 rescue => detail
                     Puppet.err("%s rollback failed: %s" % [change,detail])
+                    if Puppet[:debug]
+                        puts detail.backtrace
+                    end
                     next
                     # at this point, we would normally do error handling
                     # but i haven't decided what to do for that yet
@@ -160,7 +178,6 @@ class Transaction
 
     #---------------------------------------------------------------
     def triggered(object, method)
-        Puppet.notice "Triggered %s" % method
         @triggered[object][method] += 1
         #@triggerevents << ("%s_%sed" % [object.class.name.to_s, method.to_s]).intern
     end
@@ -168,7 +185,6 @@ class Transaction
 
     #---------------------------------------------------------------
     def triggered?(object, method)
-        Puppet.notice "Looking for triggered %s" % method
         @triggered[object][method]
     end
     #---------------------------------------------------------------
@@ -176,4 +192,4 @@ end
 end
 #---------------------------------------------------------------
 
-# $Id: transaction.rb 740 2005-11-01 20:22:19Z luke $
+# $Id: transaction.rb 858 2006-01-30 19:22:25Z luke $

data/lib/puppet/transportable.rb

@@ -1,18 +1,33 @@
 require 'puppet'
+require 'yaml'
 
 module Puppet
     # The transportable objects themselves.  Basically just a hash with some
-    # metadata and a few extra methods.
-    class TransObject < Hash
+    # metadata and a few extra methods.  I used to have the object actually
+    # be a subclass of Hash, but I could never correctly dump them using
+    # YAML.
+    class TransObject
+        include Enumerable
         attr_accessor :type, :name, :file, :line
 
         attr_writer :tags
 
+        %w{has_key? include? length delete empty? << [] []=}.each { |method|
+            define_method(method) do |*args|
+                @params.send(method, *args)
+            end
+        }
+
+        def each
+            @params.each { |p,v| yield p, v }
+        end
+
         def initialize(name,type)
-            self[:name] = name
             @type = type
             @name = name
+            @params = {"name" => name}
             #self.class.add(self)
+            @tags = []
         end
 
         def longname
@@ -23,45 +38,79 @@ module Puppet
             return @tags
         end
 
+        def to_hash
+            @params.dup
+        end
+
         def to_s
             return "%s(%s) => %s" % [@type,self[:name],super]
         end
 
+        def to_manifest
+            "#{self.type.to_s} { \"#{self.name}\":\n%s\n}" % @params.collect { |p, v|
+                "    #{p} => \"#{v}\""
+            }.join(",\n")
+        end
+
+        def to_yaml_properties
+            instance_variables
+            #%w{ @type @name @file @line @tags }.find_all { |v|
+            #}
+        end
+
         def to_type(parent = nil)
-            if parent
-                self[:parent] = parent
-            end
             retobj = nil
             if type = Puppet::Type.type(self.type)
                 unless retobj = type.create(self)
+                    #Puppet.notice "Could not create %s[%s]" %
+                    #    [self.type, self.name]
                     return nil
                 end
-                retobj.file = @file
-                retobj.line = @line
+                #retobj.file = @file
+                #retobj.line = @line
             else
                 raise Puppet::Error.new("Could not find object type %s" % self.type)
             end
 
-            if defined? @tags and @tags
-                #Puppet.debug "%s(%s) tags: %s" % [@type, @name, @tags.join(" ")]
-                retobj.tags = @tags
-            end
+            #if defined? @tags and @tags
+            #    #Puppet.debug "%s(%s) tags: %s" % [@type, @name, @tags.join(" ")]
+            #    retobj.tags = @tags
+            #end
 
             if parent
+                self[:parent] = parent
                 parent.push retobj
             end
 
             return retobj
         end
     end
-    #------------------------------------------------------------
 
-    #------------------------------------------------------------
-    # just a linear container for objects
-    class TransBucket < Array
-        attr_accessor :name, :type, :file, :line
+    # Just a linear container for objects.  Behaves mostly like an array, except
+    # that YAML will correctly dump them even with their instance variables.
+    class TransBucket
+        include Enumerable
+
+        attr_accessor :name, :type, :file, :line, :classes, :autoname, :keyword, :top
+
+        %w{delete shift include? length empty? << []}.each { |method|
+            define_method(method) do |*args|
+                #Puppet.warning "Calling %s with %s" % [method, args.inspect]
+                @children.send(method, *args)
+                #Puppet.warning @params.inspect
+            end
+        }
+
+        def each
+            @children.each { |c| yield c }
+        end
+
+        def initialize
+            @children = []
+        end
 
         def push(*args)
+            #Puppet.warning "calling push"
             args.each { |arg|
                 case arg
                 when Puppet::TransBucket, Puppet::TransObject
@@ -72,7 +121,37 @@ module Puppet
                             arg.class
                 end
             }
-            super
+            @children += args
+            #Puppet.warning @children.inspect
+        end
+
+        # Convert to a parseable manifest
+        def to_manifest
+            unless self.top
+                unless defined? @keyword and @keyword
+                    raise Puppet::DevError, "No keyword; cannot convert to manifest"
+                end
+            end
+
+            str = nil
+            if self.top
+                str = "%s"
+            else
+                str = "#{@keyword} #{@type} {\n%s\n}"
+            end
+            str % @children.collect { |child|
+                child.to_manifest
+            }.collect { |str|
+                if self.top
+                    str
+                else
+                    str.gsub(/^/, "    ") # indent everything once
+                end
+            }.join("\n\n") # and throw in a blank line
+        end
+
+        def to_yaml_properties
+            instance_variables
         end
 
         def to_type(parent = nil)
@@ -96,13 +175,14 @@ module Puppet
                     hash[param] = value
                 }
             else
-                Puppet.debug "%s[%s] has no parameters" % [@type, @name]
+                #Puppet.debug "%s[%s] has no parameters" % [@type, @name]
             end
 
             if parent
                 hash[:parent] = parent
             end
-            container = Puppet::Type::Component.create(hash)
+            container = Puppet.type(:component).create(hash)
+            #Puppet.info container.inspect
 
             if parent
                 parent.push container
@@ -128,7 +208,7 @@ module Puppet
                 # Now just call to_type on them with the container as a parent
                 unless obj = child.to_type(container)
                     # nothing; we assume the method already warned
-                    Puppet.warning "Could not create child %s" % child.name
+                    #Puppet.warning "Could not create child %s" % child.name
                 end
             }
 
@@ -148,4 +228,4 @@ module Puppet
     #------------------------------------------------------------
 end
 
-# $Id: transportable.rb 740 2005-11-01 20:22:19Z luke $
+# $Id: transportable.rb 873 2006-02-07 23:12:33Z luke $